youiyoux 0.1.6 → 0.1.8

package/dist/chunks/{chunk-W2KFNGQP.js → chunk-BARSW3JO.js}

@@ -13,6 +13,7 @@ import {
   captureText,
   checkCapabilities,
   chosenSession,
+  collectComponents,
   compareToBaseline,
   componentCard,
   createBaseline,
@@ -50,9 +51,11 @@ import {
   shotsText,
   substituteVars,
   vendoredPath,
-  whereUsed
-} from "./chunk-RHXBYN4W.js";
+  whereUsed,
+  withFile
+} from "./chunk-3HON5Q5K.js";
 import {
+  escapingLinks,
   within
 } from "./chunk-42YJX3W5.js";
 import {
@@ -64,7 +67,7 @@ import {
   libraryOfPackage,
   packageOf,
   playwrightCli
-} from "./chunk-S57F4CMN.js";
+} from "./chunk-HDJ2TOWZ.js";
 import {
   MissingIndexError,
   buildGaps,
@@ -88,13 +91,17 @@ import {
   showFromCatalog,
   storeLocation,
   syncIndex
-} from "./chunk-XAO3LS7M.js";
+} from "./chunk-6GITMASZ.js";
 import {
+  DL_EXT,
   buildTokens,
   compareParity,
   cssValue,
-  parseCssColor
-} from "./chunk-VOSWAWKC.js";
+  importTokens,
+  parseCssColor,
+  parseDimension,
+  readRules
+} from "./chunk-FLBRX6Y3.js";
 import {
   Baseline,
   DESIGN_CONFIG_FILE,
@@ -108,11 +115,14 @@ import {
   PACKAGE_NAME,
   ProjectConfig,
   ScanReport,
+  WORKSPACE_FILE,
+  WorkspaceConfig,
   copyleft,
   executionLabel,
   findFiles,
   findUp,
   getSystem,
+  implementationsDir,
   loadDesignRepo,
   loadLibrary,
   matchesAny,
@@ -128,17 +138,17 @@ import {
   shortHash,
   toPosix,
   writeFileAtomic
-} from "./chunk-DP54SKL4.js";
+} from "./chunk-DWYDHVLZ.js";
 import {
   __toESM
 } from "./chunk-WNTS7ZO4.js";
 
 // ../cli/src/main.ts
-var import_yaml3 = __toESM(require_dist(), 1);
+var import_yaml4 = __toESM(require_dist(), 1);
 import { execFile as execFile5 } from "node:child_process";
 import { existsSync as existsSync5 } from "node:fs";
-import { appendFile as appendFile2, readFile as readFile8 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname10, join as join22, relative as relative8, resolve as resolve12 } from "node:path";
+import { appendFile as appendFile2, readFile as readFile10, rm as rm6, rmdir as rmdir3 } from "node:fs/promises";
+import { basename as basename5, dirname as dirname13, join as join25, relative as relative11, resolve as resolve15 } from "node:path";
 import { parseArgs, promisify as promisify5 } from "node:util";
 
 // ../cli/src/check.ts
@@ -156,7 +166,7 @@ import { join as join2, relative, resolve } from "node:path";
 
 // ../cli/src/command.ts
 var COMMAND = "youiyoux";
-var SUBCOMMANDS = ["show", "where", "bom", "check", "baseline", "rules", "plan", "migrate", "init", "sync", "link", "unlink", "scan", "watch", "hooks", "agents", "mcp", "ui", "library", "discover", "index", "report", "render", "screens", "requests", "detect", "build", "parity", "schema", "inventory", "gaps", "help"];
+var SUBCOMMANDS = ["show", "where", "bom", "check", "baseline", "rules", "plan", "migrate", "init", "adopt", "status", "system", "sync", "link", "unlink", "scan", "watch", "hooks", "agents", "mcp", "ui", "library", "discover", "index", "report", "render", "screens", "requests", "detect", "build", "parity", "schema", "inventory", "gaps", "help"];
 
 // ../cli/src/agents.ts
 var import_yaml = __toESM(require_dist(), 1);
@@ -206,7 +216,7 @@ function enumSummary(contract) {
   return Object.entries(contract.props).filter(([, spec]) => spec.type === "enum").map(([name, spec]) => `${name}: ${spec.values.join("|")}`).join("; ");
 }
 function importHint(config) {
-  return config.importFrom ? `\`${config.importFrom}\`` : `\`${config.componentsDir}\` (by a relative path from your file)`;
+  return config.importFrom ? `\`${withFile(config.importFrom)}\`` : `\`${config.componentsDir}\` (by a relative path from your file)`;
 }
 function agentsBlock(project2) {
   const { config, system } = project2;
@@ -260,7 +270,7 @@ function frontmatter(project2, build) {
     if (dark !== colors[key(t)]) colors[`${key(t)}-dark`] = dark;
   }
   const typography = {};
-  for (const t of byGroup("typography")) {
+  for (const t of byGroup("typography").filter((t2) => t2.type === "typography")) {
     const v = t.light;
     typography[key(t)] = {
       fontFamily: cssValue("fontFamily", v.fontFamily),
@@ -466,8 +476,9 @@ async function initProject(options) {
   }
   notes.push(`owned components: ${componentsDir}`);
   const alias = await aliasRoot(root);
-  const importFrom = alias !== void 0 && componentsDir.startsWith(alias) ? `@/${componentsDir.slice(alias.length)}` : void 0;
-  if (importFrom) notes.push(`imports use the @/ alias: ${importFrom}`);
+  const barrel = (await Promise.all(["index.ts", "index.tsx", "index.js"].map((f) => exists(join2(root, componentsDir, f))))).some(Boolean);
+  const importFrom = alias !== void 0 && componentsDir.startsWith(alias) ? `@/${componentsDir.slice(alias.length)}${barrel ? "" : "/{file}"}` : void 0;
+  if (importFrom) notes.push(`imports use the @/ alias: ${importFrom}${barrel ? "" : " (each component from its own file; no index barrel)"}`);
   const include = (await Promise.all(
     [
       ["app", "app/**/*.{ts,tsx,css}"],
@@ -491,7 +502,8 @@ async function initProject(options) {
     componentsDir,
     ...importFrom ? { importFrom } : {},
     routes: expo ? { strategy: "expo-router", appDir } : { strategy: "none" },
-    ...prefix ? { outputs: { cssVarPrefix: prefix } } : {}
+    ...options.outputs ? { outputs: options.outputs } : prefix ? { outputs: { cssVarPrefix: prefix } } : {},
+    ...options.tokenSources && options.tokenSources.length > 0 ? { tokenSources: [...options.tokenSources] } : {}
   });
   await writeFileAtomic(file, `${JSON.stringify(config, null, 2)}
 `);
@@ -617,7 +629,7 @@ var DRIFT_SEVERITY = { "near-duplicate": "warn", "hardcoded-value": "error", "of
 async function importOf(project2) {
   const alias = await aliasRoot(project2.root, project2.config.tsconfig);
   return (file, fromFile) => {
-    if (project2.system && file.startsWith(`${project2.config.componentsDir}/`)) return importSpecifier(project2.config, fromFile);
+    if (project2.system && file.startsWith(`${project2.config.componentsDir}/`)) return importSpecifier(project2.config, fromFile, file);
     if (alias !== void 0 && file.startsWith(alias)) return `@/${file.slice(alias.length).replace(/\.(tsx?|jsx?|mjs)$/, "").replace(/\/index$/, "")}`;
     const path = posix.relative(posix.dirname(fromFile), file).replace(/\.(tsx?|jsx?|mjs|astro)$/, "").replace(/\/index$/, "");
     return path.startsWith(".") ? path : `./${path}`;
@@ -634,7 +646,7 @@ async function chosenLibraries(project2, added, notes) {
   const chosen = /* @__PURE__ */ new Map();
   for (const { contract } of project2.system?.components ?? []) {
     const type = EXPORT_TYPES[contract.name];
-    if (type && !chosen.has(type)) chosen.set(type, { library: "system", label: `the System's ${contract.name} (${contract.id})`, fix: (from) => `import { ${contract.name} } from "${importSpecifier(project2.config, from)}"` });
+    if (type && !chosen.has(type)) chosen.set(type, { library: "system", label: `the System's ${contract.name} (${contract.id})`, fix: (from) => `import { ${contract.name} } from "${importSpecifier(project2.config, from, contract.source.file)}"` });
   }
   let hits;
   try {
@@ -917,23 +929,24 @@ var Writer = class {
   }
   async link(file, target) {
     const path = this.path(file);
-    const stat3 = await lstat(path).catch(() => null);
-    if (stat3?.isSymbolicLink() && await readlink(path) === target) return this.record({ file, role: "agents", action: "unchanged" });
-    if (stat3 && !stat3.isSymbolicLink()) return this.record({ file, role: "agents", action: "skipped", detail: "a real directory is in the way" });
+    const stat4 = await lstat(path).catch(() => null);
+    if (stat4?.isSymbolicLink() && await readlink(path) === target) return this.record({ file, role: "agents", action: "unchanged" });
+    if (stat4 && !stat4.isSymbolicLink()) return this.record({ file, role: "agents", action: "skipped", detail: "a real directory is in the way" });
     if (!this.options.dryRun) {
       await mkdir(dirname2(path), { recursive: true });
-      if (stat3) await rm(path);
+      if (stat4) await rm(path);
       await symlink(target, path);
     }
-    this.record({ file, role: "agents", action: stat3 ? "updated" : "created", detail: `\u2192 ${target}` });
+    this.record({ file, role: "agents", action: stat4 ? "updated" : "created", detail: `\u2192 ${target}` });
   }
 };
 async function syncProject(project2, options = {}) {
   const { config, system, repo } = project2;
   const previous = await readLock(project2.root);
   const writer = new Writer(project2, options, previous);
+  const implementations = implementationsDir(system.config);
   for (const { contract } of system.components) {
-    if (await readTextOrNull(join6(repo.root, system.config.components, contract.source.file)) === null) throw new Error(`${system.config.components}/${contract.source.file} is named by ${contract.id} but does not exist; nothing was written`);
+    if (await readTextOrNull(join6(repo.root, implementations, contract.source.file)) === null) throw new Error(`${implementations}/${contract.source.file} is named by ${contract.id} but does not exist; nothing was written`);
   }
   const build = await buildTokens(repo.root, system.config, config.outputs, { contracts: system.components.map((c) => c.contract) });
   for (const file of build.files) await writer.generated(`${config.outputs.dir}/${file.path}`, file.content, "tokens");
@@ -952,11 +965,15 @@ async function syncProject(project2, options = {}) {
   for (const support of system.config.support) if (!sources.has(support)) sources.set(support, { elements: system.components.map((c) => c.contract.id), version: system.config.version });
   const upstreams = /* @__PURE__ */ new Map();
   for (const source of sources.keys()) {
-    const upstream = await readTextOrNull(join6(repo.root, system.config.components, source));
-    if (upstream === null) throw new Error(`${system.config.components}/${source} is named by a contract but does not exist`);
+    const upstream = await readTextOrNull(join6(repo.root, implementations, source));
+    if (upstream === null) throw new Error(`${implementations}/${source} is named by a contract but does not exist`);
     upstreams.set(source, upstream);
   }
-  for (const [source, { elements, version }] of sources) await writer.owned(vendoredPath(project2, source), upstreams.get(source), elements, version);
+  for (const [source, { elements, version }] of sources) {
+    const file = vendoredPath(project2, source);
+    if (await sameFile(join6(repo.root, implementations, source), join6(project2.root, file))) writer.record({ file, role: "component", action: "unchanged", detail: "the system's own implementation, in this project" });
+    else await writer.owned(file, upstreams.get(source), elements, version);
+  }
   await writer.retire();
   const lock = {
     schema: "youi.lock/v1",
@@ -970,6 +987,10 @@ async function syncProject(project2, options = {}) {
 `);
   return { actions: writer.actions, lock, unknownTools: unknownToolMentions(project2) };
 }
+async function sameFile(a, b) {
+  const [x, y] = await Promise.all([realpath(a).catch(() => null), realpath(b).catch(() => null)]);
+  return x !== null && x === y;
+}
 function mcpArgs(project2) {
   const rel = (path) => relative3(project2.root, path) || ".";
   return [
@@ -1039,7 +1060,7 @@ async function runCheck(project2, options = {}) {
   const { report } = scan;
   const checked = new Set(scan.files);
   const unmatched = scope ? [...scope].filter((f) => !checked.has(f)) : [];
-  const failed = report.coverage.failed.filter((f) => !scope || scope.has(f.file) || !/\.(tsx?|css)$/.test(f.file));
+  const failed2 = report.coverage.failed.filter((f) => !scope || scope.has(f.file) || !/\.(tsx?|css)$/.test(f.file));
   const wantedRule = (id) => !options.rule || id.endsWith(`/rule/${options.rule}`);
   const violations = report.violations.filter((v) => wantedRule(v.rule) && (!options.quiet || v.severity === "error"));
   const notRun = failedChecks(report.checks).filter((c) => wantedRule(c.rule));
@@ -1050,7 +1071,7 @@ async function runCheck(project2, options = {}) {
   const failing = baseline ? [...baseline.comparison.new, ...baseline.comparison.regressed] : violations;
   const errors = failing.filter((v) => v.severity === "error").length + (lock ?? []).filter((i) => i.severity === "error").length;
   const drift = diff ? await analyseChange(project2, scan, diff, { violations }) : null;
-  return { identity: scan.identity, scan, scope, unmatched, failed, notRun, violations, lock, baseline, errors, incomplete: unmatched.length > 0 || failed.length > 0 || notRun.length > 0 || (drift?.incomplete.length ?? 0) > 0, diff: drift };
+  return { identity: scan.identity, scan, scope, unmatched, failed: failed2, notRun, violations, lock, baseline, errors, incomplete: unmatched.length > 0 || failed2.length > 0 || notRun.length > 0 || (drift?.incomplete.length ?? 0) > 0, diff: drift };
 }
 async function lockIssues(project2) {
   const lock = await verifyLock(project2);
@@ -1760,18 +1781,18 @@ async function runClaudeHook(input, target = {}) {
   try {
     const project2 = await load(target, dirname5(file));
     const real = (path) => realpath3(path).catch(() => path);
-    const relative9 = relPath(await real(project2.root), await real(file));
-    if (!isChecked(project2, relative9)) return SILENT;
-    const found = await changeFor(() => workingTreeChange(project2, void 0, [relative9]));
+    const relative12 = relPath(await real(project2.root), await real(file));
+    if (!isChecked(project2, relative12)) return SILENT;
+    const found = await changeFor(() => workingTreeChange(project2, void 0, [relative12]));
     if (found.problem !== void 0) return claudeContext(found.problem, project2.root);
     const { change } = found;
     const result = configured(project2) ? await runCheck(project2, { files: [file], lock: false, baseline: await baselineFor(project2, target), diff: change }) : await runRepoCheck(project2, change);
     const lines = findingLines(result, project2.root);
-    const see = COMPONENT_FILE.test(relative9) ? `See it: youiyoux render ${quoted(relative9)} (or the MCP tool ui_render), then open the images: light and dark, desktop and phone, accessibility issues and the diff against the base.` : null;
-    if (lines.length === 0) return see ? claudeContext(`youiyoux: ${relative9} passes the design-system check. ${see}`, project2.root) : SILENT;
+    const see = COMPONENT_FILE.test(relative12) ? `See it: youiyoux render ${quoted(relative12)} (or the MCP tool ui_render), then open the images: light and dark, desktop and phone, accessibility issues and the diff against the base.` : null;
+    if (lines.length === 0) return see ? claudeContext(`youiyoux: ${relative12} passes the design-system check. ${see}`, project2.root) : SILENT;
     const older = "violations" in result ? result.violations.filter((v) => !isAdded(change.added, v.file, v.line)).length : 0;
     const known = older > 0 ? ` (${older} older findings on unchanged lines omitted)` : "";
-    return claudeContext(`youiyoux design-system check (advisory) on ${relative9}${known}:
+    return claudeContext(`youiyoux design-system check (advisory) on ${relative12}${known}:
 ${lines.join("\n")}${!configured(project2) ? `
 ${result.diff?.notes.join("\n")}` : ""}
 Fix these before finishing (each "Fix:" says what to write); \`youiyoux show <component>\` and the youiyoux MCP tools give the legal values. CI runs the authoritative check.${see ? `
@@ -1919,30 +1940,30 @@ var serialize = ({ data, indent, newline }) => `${JSON.stringify(data, null, ind
 async function installClaudeMcp(repoRoot, server) {
   const file = join11(repoRoot, CLAUDE_MCP);
   const before = await readTextOrNull(file);
-  const json2 = readJson2(file, before);
-  const servers = json2.data.mcpServers ?? {};
-  const next2 = { ...json2, data: { ...json2.data, mcpServers: { ...servers, [MCP_NAME]: { command: server.command, args: server.args } } } };
+  const json4 = readJson2(file, before);
+  const servers = json4.data.mcpServers ?? {};
+  const next2 = { ...json4, data: { ...json4.data, mcpServers: { ...servers, [MCP_NAME]: { command: server.command, args: server.args } } } };
   return write(file, serialize(next2), before, `Claude Code starts the ${MCP_NAME} MCP server in this repo (it asks once before trusting a project .mcp.json); the command uses the installed tool or portable npx invocation; youiyoux sync writes the same entry`);
 }
 async function removeClaudeMcp(repoRoot) {
   const file = join11(repoRoot, CLAUDE_MCP);
   const before = await readTextOrNull(file);
   if (before === null) return { file, action: "unchanged", guarantee: `no ${MCP_NAME} server here` };
-  const json2 = readJson2(file, before);
-  const servers = { ...json2.data.mcpServers ?? {} };
+  const json4 = readJson2(file, before);
+  const servers = { ...json4.data.mcpServers ?? {} };
   if (!(MCP_NAME in servers)) return { file, action: "unchanged", guarantee: `no ${MCP_NAME} server here` };
   delete servers[MCP_NAME];
-  const { mcpServers: _, ...rest } = json2.data;
-  const data = Object.keys(servers).length > 0 ? { ...json2.data, mcpServers: servers } : rest;
-  return removeOrWrite(file, Object.keys(data).length > 0 ? serialize({ ...json2, data }) : "", `${MCP_NAME} removed; other servers kept`);
+  const { mcpServers: _, ...rest } = json4.data;
+  const data = Object.keys(servers).length > 0 ? { ...json4.data, mcpServers: servers } : rest;
+  return removeOrWrite(file, Object.keys(data).length > 0 ? serialize({ ...json4, data }) : "", `${MCP_NAME} removed; other servers kept`);
 }
 var tomlString = (value) => JSON.stringify(value);
 function codexBlock(server) {
   return [TOML_BEGIN, `[mcp_servers.${MCP_NAME}]`, `command = ${tomlString(server.command)}`, `args = [${server.args.map(tomlString).join(", ")}]`, TOML_END].join("\n");
 }
 function foreignTable(text) {
-  const inside2 = withoutBlock(text, TOML_BEGIN, TOML_END) ?? text;
-  return new RegExp(`^\\s*\\[\\s*mcp_servers\\s*\\.\\s*"?${MCP_NAME}"?\\s*\\]`, "m").test(inside2);
+  const inside3 = withoutBlock(text, TOML_BEGIN, TOML_END) ?? text;
+  return new RegExp(`^\\s*\\[\\s*mcp_servers\\s*\\.\\s*"?${MCP_NAME}"?\\s*\\]`, "m").test(inside3);
 }
 async function installCodexMcp(repoRoot, server) {
   const file = join11(repoRoot, CODEX_CONFIG);
@@ -2066,7 +2087,7 @@ import { homedir, userInfo } from "node:os";
 import { join as join12, resolve as resolve6 } from "node:path";
 async function swapImpact(candidate, family) {
   try {
-    const { discoverIndexPath: discoverIndexPath2, sharedStore: sharedStore2 } = await import("./src-7RRKYIAS.js");
+    const { discoverIndexPath: discoverIndexPath2, sharedStore: sharedStore2 } = await import("./src-DPFJ4S2N.js");
     const path = discoverIndexPath2();
     if (!process.env.DATABASE_URL && !existsSync(path)) return null;
     const impact = await (await sharedStore2(path, process.env, { readOnly: true })).swapImpact(candidate, family);
@@ -2077,7 +2098,7 @@ async function swapImpact(candidate, family) {
 }
 async function libraryLicence(id) {
   try {
-    const { discoverCacheDir: discoverCacheDir2, findListing } = await import("./src-7RRKYIAS.js");
+    const { discoverCacheDir: discoverCacheDir2, findListing } = await import("./src-DPFJ4S2N.js");
     const { entry } = await findListing(discoverCacheDir2(void 0, process.env), id);
     return entry.id === id ? entry.license : null;
   } catch {
@@ -2085,7 +2106,7 @@ async function libraryLicence(id) {
   }
 }
 async function startRuleEditor(options) {
-  const { FileStore, RuleWorkflow, serveWorkflow } = await import("./src-VKQJF7KR.js");
+  const { FileStore, RuleWorkflow, serveWorkflow } = await import("./src-EUVBYTKY.js");
   const projectRoot = resolve6(options.project);
   const load2 = { ...options.config ? { configPath: resolve6(options.config) } : {}, ...options.design ? { designRoot: resolve6(options.design) } : {}, ...options.root ? { productRoot: resolve6(options.root) } : {} };
   const project2 = await loadProject(projectRoot, load2);
@@ -2126,7 +2147,7 @@ function builtHubPlan(toolRoot, options, out) {
   if (options.watch && !namesSystem(options)) throw new Error("--watch keeps a system's snapshot live: name it with --design or --project (the demo system is not watched)");
   const hub = join13(toolRoot, BUILT_HUB);
   const snapshot = flags.length > 0 ? [join13(toolRoot, "hub-snapshot.js"), "--out", out, ...flags] : null;
-  const server = [join13(toolRoot, "hub-server.js"), "--dist", hub, "--kit", join13(hub, "kit"), "--snapshot", snapshot ? out : join13(toolRoot, BUILT_DEMO), ...snapshot ? ["--build-frame"] : [], ...options.port ? ["--port", options.port] : [], ...options.api ? ["--api", options.api] : [], ...options.watch ? ["--live"] : []];
+  const server = [join13(toolRoot, "hub-server.js"), "--dist", hub, "--kit", join13(hub, "kit"), "--snapshot", snapshot ? out : join13(toolRoot, BUILT_DEMO), ...snapshot ? ["--build-frame"] : [], ...options.port ? ["--port", options.port] : [], ...options.api ? ["--api", options.api] : [], ...options.watch || options.workspace ? ["--live"] : []];
   return { snapshot, server, watch: options.watch && snapshot ? [...snapshot, "--watch"] : null };
 }
 function run5(args, cwd, env, started) {
@@ -2151,6 +2172,7 @@ async function runBuiltHub(toolRoot, options) {
       const code = await run5(plan.snapshot, process.cwd(), {}, (child) => children.add(child));
       if (code !== 0) return code;
     }
+    options.workspace?.((project2) => run5(builtHubPlan(toolRoot, { ...options, project: project2 }, out).snapshot, process.cwd(), {}, (child) => children.add(child)));
     if (plan.watch) children.add(spawn(process.execPath, plan.watch, { cwd: process.cwd(), stdio: "inherit" }));
     return await run5(plan.server, process.cwd(), {}, (child) => children.add(child));
   } finally {
@@ -2170,6 +2192,7 @@ async function runHub(toolRoot, options) {
     const code = await run5(plan.snapshot, process.cwd(), {});
     if (code !== 0) return code;
   }
+  options.workspace?.((project2) => run5(hubPlan(toolRoot, { ...options, project: project2 }).snapshot, process.cwd(), {}));
   const watcher = plan.watch ? spawn(process.execPath, plan.watch, { cwd: process.cwd(), stdio: "inherit" }) : null;
   try {
     return await run5(plan.vite, plan.web, plan.env);
@@ -2217,15 +2240,587 @@ function renderRequests(briefs, status, unreadable) {
   return lines.join("\n\n");
 }
 
+// ../cli/src/adopt.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute5, join as join14, posix as posix3, relative as relative6, resolve as resolve8 } from "node:path";
+var import_yaml2 = __toESM(require_dist(), 1);
+var OUT_DIR = "design/build";
+var DARK_BLOCKS = [
+  { selector: ".dark" },
+  { selector: ":root.dark" },
+  { selector: '[data-theme="dark"]' },
+  { selector: ':root[data-theme="dark"]' },
+  { selector: ":root", outer: "@media (prefers-color-scheme: dark)" },
+  { selector: ':root:not([data-theme="light"])', outer: "@media (prefers-color-scheme: dark)" }
+];
+var kebab = (name) => name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+var pascal = (file) => basename2(file).replace(/\.[^.]+$/, "").split(/[-_.]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+var json = (value) => `${JSON.stringify(value, null, 2)}
+`;
+function slugOf(name) {
+  return name.replace(/^@[^/]+\//, "").toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^[^a-z]+/, "").replace(/-+$/, "") || "app";
+}
+function inside2(root, path, what) {
+  const normal = posix3.normalize(path.split("\\").join("/")).replace(/^\.\//, "").replace(/\/+$/, "");
+  if (isAbsolute5(normal) || normal === ".." || normal.startsWith("../") || !within(root, resolve8(root, normal))) throw new Error(`${what} ${JSON.stringify(path)} leads outside ${root}: adopt reads and writes only inside the product`);
+  return normal;
+}
+function exportedNames(source) {
+  const names = /* @__PURE__ */ new Set();
+  for (const match of source.matchAll(/^export\s+(?:declare\s+)?(?:const|let|var|function\*?|class|async\s+function)\s+([A-Za-z_$][\w$]*)/gm)) names.add(match[1]);
+  for (const match of source.matchAll(/^export\s+\{([^}]*)\}/gm)) {
+    for (const part of match[1].split(",")) {
+      const spec = part.trim();
+      if (!spec || spec.startsWith("type ")) continue;
+      names.add(spec.split(/\s+as\s+/).at(-1).trim());
+    }
+  }
+  return [...names];
+}
+function defaultVariants(source) {
+  const body = /defaultVariants\s*:\s*\{([^}]*)\}/.exec(source)?.[1] ?? "";
+  return Object.fromEntries([...body.matchAll(/([A-Za-z_$][\w$]*)\s*:\s*["'`]([^"'`]+)["'`]/g)].map((m) => [m[1], m[2]]));
+}
+function propsOf(facts, defaults) {
+  const props = {};
+  for (const prop of facts?.props ?? []) {
+    if (prop.values && prop.values.length > 0) props[prop.name] = { type: "enum", values: [...prop.values], required: false, ...defaults[prop.name] && prop.values.includes(defaults[prop.name]) ? { default: defaults[prop.name] } : {} };
+    else if (prop.name === "className") props[prop.name] = { type: "string", required: false, description: "Extra classes, merged last." };
+    else if (prop.name === "children") props[prop.name] = { type: "node", required: false };
+    else if (/^on[A-Z]/.test(prop.name)) props[prop.name] = { type: "function", required: false };
+  }
+  return props;
+}
+function generatedOf(file, css) {
+  const head = css.slice(0, 400);
+  if (!head.includes(GENERATED_MARK)) return null;
+  const from = /@generated by youi from the (.+?) design language v(\d+\.\d+\.\d+(?:-[\w.-]+?)?)\./.exec(head);
+  return { file, count: rootVariables(css).length, system: from?.[1] ?? null, version: from?.[2] ?? null };
+}
+async function stylesheetOf(root, asked, fork) {
+  const generated = [];
+  let forked = null;
+  const usable = async (file) => {
+    const css = await readTextOrNull(join14(root, file));
+    if (css === null) return false;
+    const made = generatedOf(file, css);
+    if (made && !generated.some((g) => g.file === file)) generated.push(made);
+    if (made && fork) forked = made;
+    return !made || fork;
+  };
+  if (asked) {
+    if (!await usable(asked) && generated.length > 0) throw new Error(`${asked} is generated by youiyoux sync${generated[0].system ? ` from ${generated[0].system}` : ""}: name the stylesheet the product writes its own variables in, or take that System's values as the product's own with youiyoux adopt --fork`);
+    return { file: asked, generated, forked };
+  }
+  const shadcn = (await readJson(join14(root, "components.json")))?.tailwind?.css;
+  if (typeof shadcn === "string" && await usable(shadcn)) return { file: posix3.normalize(shadcn), generated, forked };
+  let best = null;
+  for (const file of await findFiles(root, ["**/*.css"], ["**/build/**", "**/out/**", "**/.next/**", `${OUT_DIR}/**`])) {
+    const css = await readTextOrNull(join14(root, file)) ?? "";
+    const count = rootVariables(css).length;
+    if (count === 0) continue;
+    const made = generatedOf(file, css);
+    if (made && !generated.some((g) => g.file === file)) generated.push(made);
+    if (made && !fork) continue;
+    if (!best || count > best.count) best = { file, count, made };
+  }
+  return { file: best?.file ?? null, generated, forked: best?.made ?? forked };
+}
+function rootVariables(css) {
+  return readRules(css).filter((r) => r.preludes.length === 1 && r.preludes[0] === ":root").flatMap((r) => r.declarations).filter((d) => d.property.startsWith("--") && !d.property.startsWith("---")).map((d) => ({ name: d.property.slice(2), value: d.value }));
+}
+var NOT_A_PREFIX = /* @__PURE__ */ new Set(["color", "colors", "bg", "fg", "radius", "rounded", "font", "text", "shadow", "space", "spacing", "size", "ease", "easing", "duration", "motion", "z", "leading", "tracking", "border", "ring", "chart", "sidebar", "background", "foreground", "primary", "secondary", "muted", "accent", "destructive", "card", "popover", "input", "typography", "brand", "gray", "grey", "neutral"]);
+function commonPrefix(names) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const name of names) if (name.includes("-")) counts.set(name.split("-")[0], (counts.get(name.split("-")[0]) ?? 0) + 1);
+  const [word, count] = [...counts].sort((a, b) => b[1] - a[1])[0] ?? ["", 0];
+  return count >= 3 && count >= names.length * 0.8 && /^[a-z][a-z0-9]*$/.test(word) && !NOT_A_PREFIX.has(word) ? word : "";
+}
+function lengthPath(name, value) {
+  if (parseDimension(value) === null && !/^var\(/.test(value)) return null;
+  if (/radius/.test(name)) return `radius.${name.replace(/^radius-(?=.)/, "")}`;
+  if (/^typography-/.test(name)) return `typography.${name.slice("typography-".length)}`;
+  if (/^(?:text|font)-|-(?:font-size|line-height|letter-spacing|font-weight)$/.test(name)) return `typography.${name}`;
+  return null;
+}
+function variableNames(tree, path = []) {
+  return Object.entries(tree).flatMap(([key2, node]) => {
+    if (key2.startsWith("$")) return [];
+    if (node && typeof node === "object" && "$value" in node) {
+      const css = node.$extensions?.[DL_EXT]?.css;
+      return [css ?? [...path, key2].join("-")];
+    }
+    return variableNames(node, [...path, key2]);
+  });
+}
+function moveDeclarations(css, blocks, moved, importPath) {
+  const rules = readRules(css).filter((r) => blocks.some((b) => r.preludes.at(-1) === b.selector && (b.outer ? r.preludes.length === 2 && r.preludes[0] === b.outer : r.preludes.length === 1)));
+  if (rules.length === 0) return null;
+  const lines = css.split("\n");
+  const drop = /* @__PURE__ */ new Set();
+  for (const rule2 of rules) {
+    for (const d of rule2.declarations) {
+      const line = lines[d.line - 1] ?? "";
+      if (moved.has(d.property.slice(2)) && new RegExp(`^\\s*${d.property.replace(/[-]/g, "\\-")}\\s*:[^;]*;?\\s*$`).test(line)) drop.add(d.line - 1);
+    }
+  }
+  if (drop.size === 0) return null;
+  let content = lines.filter((_, i) => !drop.has(i)).join("\n");
+  for (const block of blocks) content = content.replace(new RegExp(`(^|\\n)[ \\t]*${block.selector.replace(/[.[\]()"=:]/g, "\\$&")}\\s*\\{\\s*\\}[ \\t]*(?=\\n|$)`, "g"), "");
+  for (const outer of new Set(blocks.flatMap((b) => b.outer ? [b.outer] : []))) content = content.replace(new RegExp(`(^|\\n)[ \\t]*${outer.replace(/[.[\]()"=:]/g, "\\$&")}\\s*\\{\\s*\\}[ \\t]*(?=\\n|$)`, "g"), "");
+  const statement = `@import "${importPath}";`;
+  const imports = [...content.matchAll(/^@import[^;]*;[ \t]*$/gm)];
+  const at = imports.length > 0 ? imports.at(-1).index + imports.at(-1)[0].length : 0;
+  content = at > 0 ? `${content.slice(0, at)}
+${statement}${content.slice(at)}` : `${statement}
+${content}`;
+  return { content: content.replace(/\n{3,}/g, "\n\n"), moved: drop.size };
+}
+async function planAdoption(options) {
+  const root = options.root;
+  const pkg = await readJson(join14(root, "package.json"));
+  const name = typeof pkg?.name === "string" ? pkg.name : basename2(root);
+  const id = options.system ?? slugOf(name);
+  if (!/^[a-z][a-z0-9-]*$/.test(id)) throw new Error(`"${id}" cannot be a system id: use lowercase letters, digits and hyphens, starting with a letter (--system <id>)`);
+  const notes = [];
+  const facts = await collectComponents(root);
+  const chosen = options.componentsDir ?? facts.shadcnUi ?? await uiFolder(root) ?? facts.componentsDir;
+  const componentsDir = chosen ? inside2(root, chosen, "the components folder") : null;
+  if (!componentsDir || !await exists(join14(root, componentsDir))) throw new Error("no folder of components found: pass --components <dir> (the folder your app imports its UI components from)");
+  const inDir = (file) => posix3.dirname(file) === componentsDir;
+  const files = (await findFiles(root, [`${componentsDir}/*.{ts,tsx,js,jsx}`])).filter((f) => !/^index\./.test(posix3.basename(f)) && !/\.(test|spec|stories|d)\.[^.]+$/.test(f));
+  const byFile = /* @__PURE__ */ new Map();
+  for (const c of facts.components) if (c.definition.kind === "react" && inDir(c.definition.file)) byFile.set(c.definition.file, [...byFile.get(c.definition.file) ?? [], c]);
+  const out = [];
+  const components = [];
+  const support = [];
+  const RULES = ["color.no-raw-color", "tokens.no-arbitrary-values", "components.canonical-import"].map((r) => `youi:${id}/rule/${r}`);
+  for (const file of files) {
+    const defined = (byFile.get(file) ?? []).filter((c) => /^[A-Z]/.test(c.export));
+    const source = await readFile4(join14(root, file), "utf8");
+    if (defined.length === 0) {
+      support.push(posix3.basename(file));
+      continue;
+    }
+    const main2 = defined.find((c) => c.export === pascal(file)) ?? defined[0];
+    const folder = kebab(main2.export);
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(folder)) {
+      notes.push(`${file}: ${main2.export} has no contract (its name is not plain letters and digits); write one by hand`);
+      continue;
+    }
+    const exportsOf = exportedNames(source);
+    const sites = main2.sites.length;
+    const contract = {
+      schema: "youi.component/v1",
+      id: `youi:${id}/component/${folder}`,
+      name: main2.export,
+      version: "0.1.0",
+      status: "draft",
+      summary: `The product's own ${main2.export} (${file}), used at ${sites} ${sites === 1 ? "site" : "sites"}.`.slice(0, 200),
+      source: { file: posix3.basename(file), export: main2.export, also: defined.filter((c) => c !== main2).map((c) => c.export) },
+      platforms: facts.dependencies.includes("react-native") && !facts.dependencies.includes("react-dom") ? ["ios", "android"] : ["web"],
+      props: propsOf(main2, defaultVariants(source)),
+      tokens: {},
+      a11y: { notes: [] },
+      rules: RULES,
+      guidance: { do: [], dont: [] },
+      examples: [],
+      aliases: exportsOf.filter((n) => !/^[A-Z]/.test(n)),
+      owners: []
+    };
+    out.push({ path: `design/components/${folder}/${folder}.contract.json`, content: json(contract) });
+    components.push(main2.export);
+  }
+  if (components.length === 0) throw new Error(`${componentsDir} exports no React components: pass --components <dir> (the folder your app imports its UI components from)`);
+  const found = await stylesheetOf(root, options.css, options.fork === true);
+  const stylesheet = found.file ? inside2(root, found.file, "the stylesheet") : null;
+  const css = stylesheet ? await readTextOrNull(join14(root, stylesheet)) : null;
+  if (stylesheet && css === null) throw new Error(`${stylesheet} does not exist (--css <file>: the stylesheet that defines your :root variables)`);
+  const darkBlocks = css ? DARK_BLOCKS.filter((b) => readRules(css).some((r) => r.preludes.at(-1) === b.selector && (b.outer ? r.preludes.length === 2 && r.preludes[0] === b.outer : r.preludes.length === 1) && r.declarations.some((d) => d.property.startsWith("--")))) : [];
+  const darkBlock = darkBlocks[0];
+  const variables = css ? rootVariables(css) : [];
+  const prefix = commonPrefix(variables.map((v) => v.name));
+  const full = (name2) => prefix ? `${prefix}-${name2}` : name2;
+  const own = variables.filter((v) => !prefix || v.name.startsWith(`${prefix}-`)).map((v) => ({ name: prefix ? v.name.slice(prefix.length + 1) : v.name, value: v.value }));
+  const unprefixed = variables.filter((v) => prefix && !v.name.startsWith(`${prefix}-`)).map((v) => v.name);
+  if (unprefixed.length > 0) notes.push(`${plural(unprefixed.length, "variable")} without the --${prefix}- prefix stay in ${stylesheet}: ${unprefixed.slice(0, 4).map((n) => `--${n}`).join(", ")}${unprefixed.length > 4 ? ", \u2026" : ""}`);
+  const paths = Object.fromEntries(own.flatMap((v) => lengthPath(v.name, v.value) ? [[v.name, lengthPath(v.name, v.value)]] : []));
+  const imported = css ? importTokens({ css: { css, prefix, light: { selector: ":root" }, ...darkBlock ? { dark: darkBlock } : {} }, paths }) : null;
+  const tokenCount = imported?.report.fromCss.length ?? 0;
+  const hasDark = Boolean(imported && Object.keys(imported.dark).length > 0);
+  out.push({ path: `design/tokens/${id}.tokens.json`, content: json(imported?.base ?? {}) });
+  if (hasDark) out.push({ path: `design/tokens/${id}.dark.tokens.json`, content: json(imported.dark) });
+  out.push({
+    path: `design/tokens/${id}.resolver.json`,
+    content: json({
+      $schema: "https://www.designtokens.org/schemas/2025.10/resolver.json",
+      name,
+      version: "2025.10",
+      description: `${name}'s tokens, adopted from ${stylesheet ?? "no stylesheet"}.`,
+      sets: { base: { sources: [{ $ref: `${id}.tokens.json` }] } },
+      ...hasDark ? { modifiers: { theme: { contexts: { light: [], dark: [{ $ref: `${id}.dark.tokens.json` }] }, default: "light" } } } : {},
+      resolutionOrder: [{ $ref: "#/sets/base" }, ...hasDark ? [{ $ref: "#/modifiers/theme" }] : []]
+    })
+  });
+  if (!stylesheet) notes.push("no stylesheet defines :root variables, so the System has no tokens yet: add them to design/tokens");
+  const left = (imported?.report.unparsed ?? []).map((l) => ({ ...l, name: full(l.name) }));
+  const moved = new Set(imported ? variableNames(imported.base).map(full) : []);
+  const importPath = stylesheet ? relative6(dirname7(join14(root, stylesheet)), join14(root, OUT_DIR, "tokens.css")).split("\\").join("/") : "";
+  const moving = css && moved.size > 0 ? moveDeclarations(css, [{ selector: ":root" }, ...darkBlocks], moved, importPath.startsWith(".") ? importPath : `./${importPath}`) : null;
+  const rewritten = moving && found.forked ? { ...moving, content: moving.content.split("\n").filter((line) => !line.includes(GENERATED_MARK) && !/^\/\* Built with Terrazzo/.test(line)).join("\n") } : moving;
+  if (found.forked) notes.push(`forked from ${found.forked.system ?? "the System"}${found.forked.version ? ` v${found.forked.version}` : ""}: this product's System starts from the ${found.forked.count} variables it generated into ${found.forked.file}, and the product no longer follows ${found.forked.system ?? "it"}`);
+  if (css && moved.size > 0 && !rewritten) notes.push(`${stylesheet}'s variables were copied, not moved (their blocks are nested or share lines): import ${OUT_DIR}/tokens.css from it and remove them by hand`);
+  for (const [rule2, content] of starterRules(id, componentsDir)) out.push({ path: `design/rules/${rule2}.rule.yaml`, content });
+  out.push({
+    path: "design/design.md",
+    content: `# ${name}
+
+The design system of ${name}, adopted from its own code: the components in \`${componentsDir}\` and the variables ${stylesheet ? `\`${stylesheet}\`` : "its stylesheet"} defined. Write here what each colour and component is for and the rules people follow; agents read it in DESIGN.md.
+`
+  });
+  const system = {
+    id,
+    name,
+    version: "0.1.0",
+    description: `${name}'s own components and tokens, adopted with youiyoux adopt.`,
+    tokens: `design/tokens/${id}.resolver.json`,
+    ...hasDark ? { themeModifier: { name: "theme", light: "light", dark: "dark" } } : {},
+    components: "design/components",
+    implementations: componentsDir,
+    support,
+    rules: "design/rules",
+    design: "design/design.md"
+  };
+  out.unshift({ path: "youi.config.json", content: json({ schema: "youi.config/v1", name, systems: [system] }) });
+  return {
+    system,
+    componentsDir,
+    files: out,
+    components,
+    support,
+    tokens: { stylesheet, count: tokenCount, dark: hasDark, left },
+    stylesheet: rewritten && stylesheet ? { path: stylesheet, ...rewritten } : null,
+    outputs: { dir: OUT_DIR, cssVarPrefix: prefix, dark: darkBlocks.map((b) => ({ ...b.outer ? { media: b.outer.replace(/^@media\s+/, "") } : {}, selector: b.selector })), targets: ["css-vars"] },
+    tokenSources: stylesheet ? [stylesheet] : [],
+    notes,
+    follows: found.generated.filter((g) => g.file !== found.forked?.file),
+    forked: found.forked
+  };
+}
+async function uiFolder(root) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of await findFiles(root, ["**/components/ui/*.{tsx,jsx}"], ["**/build/**", "**/out/**", "**/.next/**"])) counts.set(posix3.dirname(file), (counts.get(posix3.dirname(file)) ?? 0) + 1);
+  return [...counts].sort((a, b) => b[1] - a[1] || a[0].length - b[0].length)[0]?.[0] ?? null;
+}
+function starterRules(id, componentsDir) {
+  const rule2 = (spec) => (0, import_yaml2.stringify)({ schema: "youi.rule/v1", ...spec });
+  return [
+    ["color.no-raw-color", rule2({
+      id: `youi:${id}/rule/color.no-raw-color`,
+      title: "No raw colours",
+      severity: "warn",
+      statement: "Colour comes from the tokens. Never write a hex, rgb(), hsl() or oklch() literal in a component, class name, inline style or stylesheet; only the token source may define colour values.",
+      rationale: "A literal colour cannot follow the dark scheme or a token change, and it hides from every audit.",
+      agent: "Never hard-code a colour: use the token utilities (bg-primary, text-muted-foreground) or the variables (var(--primary)); look up the role with system_get_tokens.",
+      check: { engine: "youi", id: "raw-color", options: {} },
+      files: ["**/*.{ts,tsx,css}"]
+    })],
+    ["tokens.no-arbitrary-values", rule2({
+      id: `youi:${id}/rule/tokens.no-arbitrary-values`,
+      title: "Use token utilities, not arbitrary values",
+      severity: "warn",
+      statement: "When a token holds a value, use its utility instead of a Tailwind arbitrary value.",
+      rationale: "An arbitrary value copies a token's value once; it does not follow when the token changes.",
+      agent: "Prefer token utilities over [arbitrary] values; youiyoux check names the utility.",
+      check: { engine: "youi", id: "arbitrary-value", options: {} },
+      files: ["**/*.tsx"]
+    })],
+    ["components.canonical-import", rule2({
+      id: `youi:${id}/rule/components.canonical-import`,
+      title: "Render the System's component, not a lookalike",
+      severity: "warn",
+      statement: `A component named like one of the System's (Button, Input, Card) must be the one in ${componentsDir}. A second one with the same name splits the System in two.`,
+      rationale: "Two Buttons drift apart: a fix to one never reaches the other.",
+      agent: `Import components only from ${componentsDir}; never define or import another component with one of their names.`,
+      check: { engine: "youi", id: "lookalike-component", options: {} },
+      files: ["**/*.tsx"]
+    })]
+  ];
+}
+
+// ../cli/src/extract.ts
+import { cp, mkdir as mkdir3, mkdtemp as mkdtemp3, readdir as readdir3, readFile as readFile5, realpath as realpath4, rename, rm as rm4, rmdir as rmdir2, stat } from "node:fs/promises";
+import { basename as basename3, dirname as dirname8, join as join15, posix as posix4, relative as relative7, resolve as resolve9, sep as sep2 } from "node:path";
+var json2 = (value) => `${JSON.stringify(value, null, 2)}
+`;
+var toPosix2 = (path) => path.split(sep2).join("/");
+async function isDirectory(path) {
+  return (await stat(path).catch(() => null))?.isDirectory() ?? false;
+}
+async function heldInPlace(project2) {
+  const [repo, root] = await Promise.all([realpath4(project2.repo.root), realpath4(project2.root)]);
+  return repo === root && project2.system.config.implementations !== void 0;
+}
+function ownedPaths(project2, paths, kept) {
+  const root = project2.repo.root;
+  for (const path of paths) {
+    const own = normalizeRelPath(path);
+    if (own === "." || own.startsWith("../") || !within(root, join15(root, own)) || resolve9(root, own) === resolve9(root)) throw new Error(`the System's ${path} is not a folder of its own inside ${root}: move its files into one (design/\u2026) before extracting; nothing was changed`);
+    for (const keep of kept.map((k) => normalizeRelPath(toPosix2(k)))) {
+      if (keep === own || keep.startsWith(`${own}/`)) throw new Error(`the System's ${own} holds ${keep}, which stays in the product: move the System's files into a folder of their own before extracting; nothing was changed`);
+    }
+  }
+}
+async function extractSystem(project2, dir, options = {}) {
+  if (!await heldInPlace(project2)) throw new Error(`${project2.root}'s System is already a design repo of its own (${project2.repo.root}): extract moves a System youiyoux adopt keeps inside the product`);
+  const target = resolve9(dir);
+  if (await isDirectory(target)) {
+    if ((await readdir3(target)).length > 0) throw new Error(`${target} already exists and is not empty: extract into a new folder`);
+  } else if (await stat(target).catch(() => null) !== null) throw new Error(`${target} already exists: extract into a new folder`);
+  const { repo, system } = project2;
+  const config = system.config;
+  const from = (path) => join15(repo.root, path);
+  const components = from(config.components);
+  const implementations = from(implementationsDir(config));
+  const tokensDir = posix4.dirname(config.tokens);
+  const removed = [DESIGN_CONFIG_FILE, config.components, tokensDir, config.rules, ...config.design ? [config.design] : []];
+  ownedPaths(project2, removed, [implementationsDir(config), relative7(project2.root, project2.configFile ?? join15(project2.root, PROJECT_FILE)), project2.config.outputs.dir, relative7(project2.root, target)]);
+  const { implementations: _inPlace, ...rest } = config;
+  const shared = config.support.map((file) => `_shared/${posix4.basename(file)}`);
+  const next2 = { ...rest, tokens: `tokens/${posix4.relative(tokensDir, config.tokens)}`, components: "components", support: shared, rules: "rules", ...config.design ? { design: "design.md" } : {} };
+  const written = [];
+  const temp = await mkdtemp3(join15(dirname8(target), `.${basename3(target)}.`));
+  try {
+    const copy = async (source2, to) => {
+      await mkdir3(dirname8(join15(temp, to)), { recursive: true });
+      await cp(source2, join15(temp, to), { recursive: true });
+    };
+    await copy(components, "components");
+    const placed = /* @__PURE__ */ new Map();
+    for (const { contract, dir: folder } of system.components) {
+      const contractFile = (await readdir3(folder)).find((name) => name.endsWith(".contract.json"));
+      const at = toPosix2(relative7(components, folder));
+      const file = placed.get(contract.source.file) ?? `${at}/${posix4.basename(contract.source.file)}`;
+      if (!placed.has(contract.source.file)) {
+        await copy(join15(implementations, contract.source.file), `components/${file}`);
+        placed.set(contract.source.file, file);
+      }
+      const raw = JSON.parse(await readFile5(join15(folder, contractFile), "utf8"));
+      await writeFileAtomic(join15(temp, "components", at, contractFile), json2({ ...raw, source: { ...raw.source, file } }));
+    }
+    for (const [i, file] of config.support.entries()) await copy(join15(implementations, file), `components/${shared[i]}`);
+    await copy(from(tokensDir), "tokens");
+    if (await isDirectory(from(config.rules))) await copy(from(config.rules), "rules");
+    if (config.design) await copy(from(config.design), "design.md");
+    await writeFileAtomic(join15(temp, DESIGN_CONFIG_FILE), json2({ schema: "youi.config/v1", name: repo.config.name, systems: [next2] }));
+    if (options.package) await writeFileAtomic(join15(temp, "package.json"), json2({ name: options.package, version: config.version, description: config.description, files: [DESIGN_CONFIG_FILE, "components", "tokens", "rules", ...config.design ? ["design.md"] : []] }));
+    const leaving = escapingLinks(temp);
+    if (leaving.length > 0) throw new Error(`the System has links that lead outside it (${leaving.slice(0, 3).join(", ")}); nothing was changed`);
+    await loadDesignRepo(temp);
+    for (const entry of await readdir3(temp, { recursive: true })) if (!await isDirectory(join15(temp, entry))) written.push(toPosix2(entry));
+    written.sort();
+    const source = { path: toPosix2(relative7(project2.root, target)) || "." };
+    if (!options.dryRun) {
+      if (await isDirectory(target)) await rmdir2(target);
+      await rename(temp, target);
+      const configFile = project2.configFile ?? join15(project2.root, PROJECT_FILE);
+      const raw = JSON.parse(await readTextOrNull(configFile) ?? "{}");
+      await writeFileAtomic(configFile, json2({ ...raw, source }));
+      for (const path of removed) await rm4(join15(repo.root, path), { recursive: true, force: true });
+    }
+    return { target, system: next2, written, removed, source };
+  } finally {
+    await rm4(temp, { recursive: true, force: true });
+  }
+}
+
+// ../cli/src/status.ts
+import { realpath as realpath5 } from "node:fs/promises";
+import { dirname as dirname9, join as join16, relative as relative8, resolve as resolve10 } from "node:path";
+var placeOf = (cwd, root) => {
+  const rel = relative8(cwd, root) || ".";
+  return rel.split(/[\\/]/).filter((part) => part === "..").length > 1 ? resolve10(root) : rel;
+};
+var WRITES = /* @__PURE__ */ new Set(["created", "updated", "merged", "adopted", "conflict", "removed"]);
+function sourceOf(project2) {
+  if (project2.linked) return `your checkout ${project2.linked}`;
+  const source = project2.config.source;
+  if ("package" in source) return `package ${source.package}`;
+  if ("git" in source) return `git ${source.git} at ${source.ref}`;
+  return resolve10(project2.root) === resolve10(project2.repo.root) ? "this repo" : `path ${source.path}`;
+}
+function nextStep(s) {
+  if (s.sync.state === "never") return "youiyoux sync: this product has never been synced with its System";
+  if (s.sync.state === "conflict") return "youiyoux sync: resolve the conflicts it reports, then youiyoux sync --adopt records them";
+  if (s.sync.state === "behind") return `youiyoux sync: ${plural(s.sync.changes.length, "file")} would change`;
+  if (s.check.incomplete) return "youiyoux check: some files or rules could not be checked, and it says which";
+  if (s.check.errors > 0) return `youiyoux check: fix ${plural(s.check.errors, "error")}`;
+  if (s.requests.open > 0) return `youiyoux requests: answer ${plural(s.requests.open, "open request")}`;
+  if (s.check.warnings > 0 && !s.check.baseline) return `youiyoux check: ${plural(s.check.warnings, "warning")} to fix, or youiyoux baseline records them as accepted debt`;
+  return "nothing to do";
+}
+async function projectStatus(project2, cwd = process.cwd()) {
+  const lock = await readLock(project2.root);
+  const { actions } = await syncProject(project2, { dryRun: true });
+  const changes = actions.filter((a) => WRITES.has(a.action)).map((a) => ({ file: a.file, action: a.action }));
+  const baselineFile2 = baselinePath(project2);
+  const check = await runCheck(project2, { baseline: await readTextOrNull(baselineFile2) === null ? null : baselineFile2 });
+  const comparison = check.baseline?.comparison;
+  const counted = comparison ? [...comparison.new, ...comparison.regressed] : check.violations;
+  const usages = check.scan.report.usages;
+  const { RequestStore } = await import("./src-EUVBYTKY.js");
+  const requests = await new RequestStore(project2.root, project2.config.id).list();
+  const status = {
+    id: project2.config.id,
+    root: placeOf(cwd, project2.root),
+    system: { id: project2.system.config.id, name: project2.system.config.name, version: project2.system.config.version, source: sourceOf(project2), linked: Boolean(project2.linked), commit: project2.designCommit ?? null },
+    lock: lock ? { systemVersion: lock.systemVersion, syncedAt: lock.syncedAt } : null,
+    sync: { state: lock === null ? "never" : actions.some((a) => a.action === "conflict") ? "conflict" : changes.length > 0 ? "behind" : "current", changes },
+    drift: (await verifyLock(project2) ?? []).map((i) => ({ file: i.file, severity: i.severity, message: i.message })),
+    check: {
+      errors: check.errors,
+      warnings: counted.filter((v) => v.severity === "warn").length,
+      baseline: comparison ? { known: comparison.known.length, new: comparison.new.length + comparison.regressed.length, fixed: comparison.fixed.reduce((n, f) => n + f.gone, 0) } : null,
+      incomplete: check.incomplete
+    },
+    components: { system: project2.system.components.length, used: new Set(usages.map((u) => u.element)).size, sites: usages.length },
+    requests: { open: requests.requests.filter((r) => r.status === "open").length, addressed: requests.requests.filter((r) => r.status === "addressed").length, unreadable: requests.unreadable.length }
+  };
+  return { ...status, next: nextStep(status) };
+}
+async function statusTargets(cwd, named2) {
+  if (named2) return { roots: [resolve10(named2)], workspace: null };
+  const product2 = findUp(cwd, PROJECT_FILE);
+  if (product2) return { roots: [product2], workspace: null };
+  const at = findUp(cwd, WORKSPACE_FILE);
+  if (at) {
+    const file = join16(at, WORKSPACE_FILE);
+    const workspace = await readDefinition(file, WorkspaceConfig);
+    return { roots: workspace.projects.map((p) => resolve10(at, p)), workspace: file };
+  }
+  const top = findUp(cwd, ".git") ?? null;
+  if (top === null) return { roots: [], workspace: null };
+  const configs = await findFiles(cwd, [`**/${PROJECT_FILE}`]);
+  const roots = [];
+  for (const config of configs) {
+    const dir = resolve10(cwd, dirname9(config));
+    if (await realpath5(findUp(dir, ".git") ?? dir) === await realpath5(top)) roots.push(dir);
+  }
+  return { roots, workspace: null };
+}
+async function workspaceStatus(cwd, named2) {
+  const { roots, workspace } = await statusTargets(cwd, named2);
+  const projects = [];
+  for (const root of roots) {
+    try {
+      projects.push(await projectStatus(await loadProject(root), cwd));
+    } catch (error) {
+      const label = placeOf(cwd, root);
+      projects.push({ root: label, error: error instanceof Error ? error.message : String(error), next: await readTextOrNull(join16(root, PROJECT_FILE)) === null ? `youiyoux adopt or youiyoux init --design <dir> in ${label}` : `fix ${join16(label, PROJECT_FILE)}` });
+    }
+  }
+  return { schema: "youi.status/v1", generatedAt: (/* @__PURE__ */ new Date()).toISOString(), workspace: workspace ? relative8(cwd, workspace) || WORKSPACE_FILE : null, projects };
+}
+var failed = (p) => "error" in p;
+function projectLines(s) {
+  const row = (label, text) => `  ${padEnd(label, 11)} ${text}`;
+  const synced = s.lock ? `synced ${s.lock.syncedAt.slice(0, 10)}${s.lock.systemVersion !== s.system.version ? ` at v${s.lock.systemVersion}` : ""}` : "never synced";
+  const sync = { current: style.ok("up to date"), behind: style.warn(`behind: ${plural(s.sync.changes.length, "file")} would change`), conflict: style.error(`conflict: ${plural(s.sync.changes.filter((c) => c.action === "conflict").length, "file")}`), never: style.warn("never synced") }[s.sync.state];
+  const edited = s.drift.filter((d) => d.severity === "warn");
+  const broken = s.drift.filter((d) => d.severity === "error");
+  const drift = s.drift.length === 0 ? style.ok("none") : [broken.length > 0 ? style.error(`${plural(broken.length, "file")} wrong (${broken.slice(0, 3).map((d) => d.file.split("/").at(-1)).join(", ")})`) : "", edited.length > 0 ? style.warn(`${plural(edited.length, "owned file")} edited locally, merged on sync (${edited.slice(0, 3).map((d) => d.file.split("/").at(-1)).join(", ")})`) : ""].filter(Boolean).join("; ");
+  const { check } = s;
+  const counts = `${check.errors > 0 ? style.error(plural(check.errors, "error")) : style.ok("0 errors")} \xB7 ${plural(check.warnings, "warning")}`;
+  const baseline = check.baseline ? style.dim(` beyond the baseline (${check.baseline.known} accepted${check.baseline.fixed > 0 ? `, ${check.baseline.fixed} fixed` : ""})`) : "";
+  return [
+    `${style.bold(s.id)}${s.root === s.id ? "" : ` ${style.dim(`\xB7 ${s.root}`)}`} \xB7 ${s.system.name} v${s.system.version} ${style.dim(`(${s.system.source}${s.system.linked ? ", linked" : ""}) \xB7 ${synced}`)}`,
+    row("sync", sync),
+    row("drift", drift),
+    row("check", `${counts}${baseline}${check.incomplete ? style.warn(" \xB7 incomplete: not a pass") : ""}`),
+    row("components", `${s.components.used} of ${s.components.system} System components used, at ${plural(s.components.sites, "site")}`),
+    row("requests", s.requests.open + s.requests.addressed + s.requests.unreadable === 0 ? style.dim("none") : [s.requests.open > 0 ? style.warn(`${s.requests.open} open`) : "0 open", `${s.requests.addressed} addressed`, ...s.requests.unreadable > 0 ? [style.error(`${s.requests.unreadable} unreadable`)] : []].join(" \xB7 ")),
+    `${style.bold("Next:")} ${s.next}`
+  ];
+}
+function renderStatus(report) {
+  if (report.projects.length === 0) return `${style.warn("!")} no product here: no ${PROJECT_FILE} upward, no ${WORKSPACE_FILE}, and none in this repository below here
+Next: youiyoux adopt makes this product's own UI its design system, or youiyoux init --design <dir> follows one`;
+  const blocks = report.projects.map((p) => failed(p) ? [`${style.bold(p.root)} ${style.error("\u2716")} ${p.error}`, `${style.bold("Next:")} ${p.next}`] : projectLines(p));
+  const head = report.projects.length > 1 ? [`${style.bold("workspace")} ${style.dim(`\xB7 ${plural(report.projects.length, "product")}${report.workspace ? ` from ${report.workspace}` : " in this repository"}`)}`, ""] : [];
+  return [...head, ...blocks.flatMap((b, i) => i === 0 ? b : ["", ...b])].join("\n");
+}
+var statusExitCode = (report) => report.projects.some((p) => failed(p) || p.check.incomplete || p.check.errors > 0 || p.sync.state === "conflict") ? 1 : 0;
+
+// ../cli/src/workspace-hub.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { createServer } from "node:http";
+var KEY_HEADER = "x-youi-session";
+function send(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+  res.end(JSON.stringify(body));
+}
+async function readBody(req) {
+  let text = "";
+  for await (const chunk2 of req) {
+    text += String(chunk2);
+    if (text.length > 4096) throw new Error("request too large");
+  }
+  return text ? JSON.parse(text) : {};
+}
+async function startWorkspaceHub(options) {
+  const key2 = randomBytes2(18).toString("base64url");
+  let report = await options.status();
+  let current = options.current;
+  let busy = false;
+  const server = createServer((req, res) => {
+    void (async () => {
+      const path = (req.url ?? "").split("?")[0];
+      if (req.method === "GET" && path === "/api/workspace") return send(res, 200, { report, current });
+      if (req.method !== "POST" || path !== "/api/workspace/open" && path !== "/api/workspace/refresh") {
+        return send(res, 404, { error: "Not in a workspace hub: Rules and Changes are read-only here; youiyoux ui --project <dir> opens the rule editor on one product" });
+      }
+      if (req.headers[KEY_HEADER] !== key2) return send(res, 401, { error: "this tab does not carry this run's key" });
+      if (busy) return send(res, 409, { error: "another product is opening; try again in a moment" });
+      busy = true;
+      try {
+        if (path === "/api/workspace/refresh") {
+          report = await options.status();
+          return send(res, 200, { report, current });
+        }
+        const { index } = await readBody(req);
+        const entry = typeof index === "number" && Number.isInteger(index) ? report.projects[index] : void 0;
+        if (entry === void 0 || options.roots[index] === void 0) return send(res, 400, { error: `no product ${JSON.stringify(index)} in this workspace` });
+        if ("error" in entry) return send(res, 400, { error: `${entry.root} cannot be opened: ${entry.error}`, problems: [entry.next] });
+        const code = await options.open(options.roots[index]);
+        if (code !== 0) return send(res, 500, { error: `the snapshot of ${entry.root} failed (exit ${code}); the hub still shows the product it showed` });
+        current = index;
+        return send(res, 200, { report, current });
+      } catch (error) {
+        return send(res, 400, { error: error instanceof Error ? error.message : String(error) });
+      } finally {
+        busy = false;
+      }
+    })();
+  });
+  await new Promise((done) => server.listen(0, "127.0.0.1", done));
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : 0;
+  return {
+    url: `http://127.0.0.1:${port}`,
+    key: key2,
+    close: () => new Promise((done) => server.close(() => done()))
+  };
+}
+
 // ../cli/src/index-store.ts
-import { appendFile, mkdir as mkdir3, readFile as readFile4, stat, rename, mkdtemp as mkdtemp3, rm as rm4 } from "node:fs/promises";
-import { dirname as dirname7, join as join14, resolve as resolve8 } from "node:path";
+import { appendFile, mkdir as mkdir4, readFile as readFile6, stat as stat2, rename as rename2, mkdtemp as mkdtemp4, rm as rm5 } from "node:fs/promises";
+import { dirname as dirname10, join as join17, resolve as resolve11 } from "node:path";
 var SOURCES_FILE = "index-sources.json";
 var SCANS_LOG = "scans.jsonl";
 var EMPTY = { discover: null, inventories: [], projects: [] };
 async function readIndexSources(home) {
   try {
-    const raw = JSON.parse(await readFile4(join14(home, SOURCES_FILE), "utf8"));
+    const raw = JSON.parse(await readFile6(join17(home, SOURCES_FILE), "utf8"));
     return { discover: raw.discover ?? null, inventories: raw.inventories ?? [], projects: raw.projects ?? [] };
   } catch {
     return EMPTY;
@@ -2238,14 +2833,14 @@ async function noteSource(home, change) {
     inventories: change.inventory && !sources.inventories.includes(change.inventory) ? [...sources.inventories, change.inventory] : sources.inventories,
     projects: change.project ? [...sources.projects.filter((p) => p.root !== change.project.root), change.project] : sources.projects
   };
-  await writeFileAtomic(join14(home, SOURCES_FILE), `${JSON.stringify(next2, null, 2)}
+  await writeFileAtomic(join17(home, SOURCES_FILE), `${JSON.stringify(next2, null, 2)}
 `);
 }
 async function recordInventory(store, home, report, file) {
-  const run7 = inventoryRun(report, resolve8(file));
+  const run7 = inventoryRun(report, resolve11(file));
   const logged = { run: run7.run, source: run7.source, scannedAt: run7.scannedAt, projects: run7.projects, families: run7.families };
-  await mkdir3(home, { recursive: true });
-  await appendFile(join14(home, SCANS_LOG), `${JSON.stringify({ schema: "youi.scan-log/v1", ...logged })}
+  await mkdir4(home, { recursive: true });
+  await appendFile(join17(home, SCANS_LOG), `${JSON.stringify({ schema: "youi.scan-log/v1", ...logged })}
 `);
   await store.recordInventory(run7);
   await noteSource(home, { inventory: run7.source });
@@ -2256,7 +2851,7 @@ async function recordProject(store, project2, usage) {
   await store.replaceGraph(`project:${project2.root}`, projectGraph({ project: project2.config.id, rules: project2.system.rules, components: project2.system.components.map((c) => ({ id: c.contract.id, name: c.contract.name })), usage }));
 }
 async function readLog(home) {
-  const text = await readFile4(join14(home, SCANS_LOG), "utf8").catch(() => "");
+  const text = await readFile6(join17(home, SCANS_LOG), "utf8").catch(() => "");
   return text.split("\n").flatMap((line) => {
     if (!line.trim()) return [];
     try {
@@ -2271,9 +2866,9 @@ async function rebuildIndex(path, options = {}) {
   const started = performance.now();
   const env = options.env ?? process.env;
   const home = indexHome(path, env);
-  await mkdir3(dirname7(path), { recursive: true });
-  const scratch = !env.DATABASE_URL ? await mkdtemp3(`${path}.rebuild-`) : null;
-  const target = scratch ? join14(scratch, "index.db") : path;
+  await mkdir4(dirname10(path), { recursive: true });
+  const scratch = !env.DATABASE_URL ? await mkdtemp4(`${path}.rebuild-`) : null;
+  const target = scratch ? join17(scratch, "index.db") : path;
   const store = scratch ? await openSqlite(target) : await sharedStore(path, env);
   try {
     if (env.DATABASE_URL) await store.reset();
@@ -2281,7 +2876,7 @@ async function rebuildIndex(path, options = {}) {
     const sources = await readIndexSources(home);
     const cache = options.discoverCache ?? sources.discover;
     let discover = { cache, chosen: 0, all: 0 };
-    if (cache && await stat(join14(cache, "index.json")).then(() => true, () => false)) {
+    if (cache && await stat2(join17(cache, "index.json")).then(() => true, () => false)) {
       const loaded = await ingestCatalog(store, cache);
       discover = { cache, chosen: loaded.chosen, all: loaded.all };
     }
@@ -2298,53 +2893,53 @@ async function rebuildIndex(path, options = {}) {
       await store.recordInventory(inventoryRun(parsed.data, file));
       replayed++;
     }
-    const failed = [];
+    const failed2 = [];
     let projects = 0;
     const gone = [];
     for (const source of sources.projects) {
-      if (!await stat(source.root).then((s) => s.isDirectory(), () => false)) {
+      if (!await stat2(source.root).then((s) => s.isDirectory(), () => false)) {
         gone.push(source.root);
-        failed.push({ root: source.root, reason: "folder not found (moved or deleted), skipped" });
+        failed2.push({ root: source.root, reason: "folder not found (moved or deleted), skipped" });
         continue;
       }
       try {
         const project2 = await loadProject(source.root, source.options);
-        const usage = ScanReport.safeParse(await readJson(source.usage ?? join14(project2.root, ".youi/usage.json")));
+        const usage = ScanReport.safeParse(await readJson(source.usage ?? join17(project2.root, ".youi/usage.json")));
         await recordProject(store, project2, usage.success ? usage.data : null);
         projects++;
       } catch (error) {
-        failed.push({ root: source.root, reason: error instanceof Error ? error.message.split("\n")[0] : String(error) });
+        failed2.push({ root: source.root, reason: error instanceof Error ? error.message.split("\n")[0] : String(error) });
       }
     }
-    const broken = failed.filter((f) => !gone.includes(f.root));
+    const broken = failed2.filter((f) => !gone.includes(f.root));
     if (broken.length) throw new Error(`Index rebuild failed: ${broken.map((f) => `${f.root}: ${f.reason}`).join("; ")}`);
     await linkCandidates(store);
     const tables = (await store.stats()).tables;
     if (scratch) {
       await store.close();
       checkpointSqlite(target);
-      if (await stat(path).then(() => true, () => false)) checkpointSqlite(path);
+      if (await stat2(path).then(() => true, () => false)) checkpointSqlite(path);
       const moved = [];
       try {
         for (const suffix of ["-wal", "-shm"]) {
           try {
-            await rename(`${path}${suffix}`, `${target}.old${suffix}`);
+            await rename2(`${path}${suffix}`, `${target}.old${suffix}`);
             moved.push(suffix);
           } catch (error) {
             if (error.code !== "ENOENT") throw error;
           }
         }
-        await rename(target, path);
+        await rename2(target, path);
       } catch (error) {
-        for (const suffix of moved) await rename(`${target}.old${suffix}`, `${path}${suffix}`);
+        for (const suffix of moved) await rename2(`${target}.old${suffix}`, `${path}${suffix}`);
         throw error;
       }
     }
-    return { location: scratch ? path : store.location, discover, scans: log.length, inventories: { replayed, missing }, projects: { replayed: projects, failed }, tables, durationMs: Math.round(performance.now() - started) };
+    return { location: scratch ? path : store.location, discover, scans: log.length, inventories: { replayed, missing }, projects: { replayed: projects, failed: failed2 }, tables, durationMs: Math.round(performance.now() - started) };
   } finally {
     if (scratch) {
       await store.close();
-      await rm4(scratch, { recursive: true, force: true });
+      await rm5(scratch, { recursive: true, force: true });
     }
   }
 }
@@ -2526,9 +3121,9 @@ function renderAdoptionRequest(request) {
 }
 
 // ../cli/src/report/run.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { mkdir as mkdir4, rename as rename2, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join21, relative as relative7, resolve as resolve11 } from "node:path";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { mkdir as mkdir5, rename as rename3, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join24, relative as relative10, resolve as resolve14 } from "node:path";
 
 // ../cli/src/report/card.ts
 import { deflateSync } from "node:zlib";
@@ -2763,8 +3358,8 @@ function drawCard(input) {
 }
 
 // ../cli/src/report/model.ts
-import { readFile as readFile6 } from "node:fs/promises";
-import { join as join18 } from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import { join as join21 } from "node:path";
 
 // ../cli/src/report/filters.ts
 var SHOWCASE_GLOBS = ["**/{__stories__,.storybook,storybook,storybook-static,example,examples,demo,demos,playground,showcase,showcases}/**", "**/*.stories.*", "**/*.story.*"];
@@ -2891,11 +3486,11 @@ function publicLook(caption) {
 
 // ../cli/src/report/groups.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join19 } from "node:path";
 
 // ../cli/src/report/imports.ts
 import { realpathSync } from "node:fs";
-import { dirname as dirname8, join as join15, relative as relative6, resolve as resolve9 } from "node:path";
+import { dirname as dirname11, join as join18, relative as relative9, resolve as resolve12 } from "node:path";
 import ts from "typescript";
 var resolvers = /* @__PURE__ */ new Map();
 function resolverOf(root) {
@@ -2903,7 +3498,7 @@ function resolverOf(root) {
   if (!found) {
     const config = ts.findConfigFile(root, ts.sys.fileExists, "tsconfig.json") ?? ts.findConfigFile(root, ts.sys.fileExists, "jsconfig.json");
     const read = config ? ts.readConfigFile(config, ts.sys.readFile) : null;
-    const options = config && read && !read.error ? ts.parseJsonConfigFileContent(read.config, ts.sys, dirname8(config)).options : {};
+    const options = config && read && !read.error ? ts.parseJsonConfigFileContent(read.config, ts.sys, dirname11(config)).options : {};
     found = { options, cache: ts.createModuleResolutionCache(root, (name) => name, options) };
     resolvers.set(root, found);
   }
@@ -2914,13 +3509,13 @@ function clearImportCache() {
 }
 async function verifiedImport(root, keeper, from, suggested) {
   const { options, cache } = resolverOf(root);
-  let local = relative6(dirname8(join15(root, from)), join15(root, keeper)).replaceAll("\\", "/").replace(/\.(tsx?|jsx?|mjs)$/, "");
+  let local = relative9(dirname11(join18(root, from)), join18(root, keeper)).replaceAll("\\", "/").replace(/\.(tsx?|jsx?|mjs)$/, "");
   if (!local.startsWith(".")) local = `./${local}`;
   for (const specifier of /* @__PURE__ */ new Set([suggested, local])) {
-    const found = ts.resolveModuleName(specifier, resolve9(root, from), options, ts.sys, cache).resolvedModule?.resolvedFileName;
+    const found = ts.resolveModuleName(specifier, resolve12(root, from), options, ts.sys, cache).resolvedModule?.resolvedFileName;
     if (found) {
       try {
-        if (realpathSync(found) === realpathSync(join15(root, keeper))) return specifier;
+        if (realpathSync(found) === realpathSync(join18(root, keeper))) return specifier;
       } catch {
       }
     }
@@ -3033,7 +3628,7 @@ var NEAR_IDENTICAL = 0.5;
 var MIN_STRUCTURE = 6;
 var GENERIC_IDENTICAL = 0.85;
 var repoPath = (dir, file) => dir === "." ? file : `${dir}/${file}`;
-var kebab = (name) => name.replace(/[a-z0-9](?=[A-Z])/g, "$&-").toLowerCase();
+var kebab2 = (name) => name.replace(/[a-z0-9](?=[A-Z])/g, "$&-").toLowerCase();
 function shapeWords(shape) {
   const { height, paddingX, radius, fontSize } = shape;
   return [height !== null ? `${height}px high` : null, paddingX !== null ? `${paddingX}px side padding` : null, radius !== null ? radius === 9999 ? "pill-shaped" : `${radius}px corners` : null, fontSize !== null ? `${fontSize}px text` : null].filter(Boolean).join(", ");
@@ -3134,7 +3729,7 @@ async function nearDuplicateGroups(input) {
     const name = EXTRACT_NAMES[kind];
     const fileIn = (f, dir2) => {
       for (let n = 1; ; n++) {
-        const file = `${dir2 ? `${dir2}/` : ""}${kebab(name)}${n === 1 ? "" : `-${n}`}.tsx`;
+        const file = `${dir2 ? `${dir2}/` : ""}${kebab2(name)}${n === 1 ? "" : `-${n}`}.tsx`;
         if (![...defs.values()].some((d) => d.facts === f && d.def.file === file)) return file;
       }
     };
@@ -3328,22 +3923,22 @@ function factsOf(project2, id, modules, eligible, workspaceNames, dependencies,
     if (dirs.has(file.slice(0, at))) break;
     dirs.add(file.slice(0, at));
   }
-  const roots = [...dirs].filter((dir) => existsSync3(join16(project2.root, dir, "package.json"))).sort((a, b) => b.length - a.length);
+  const roots = [...dirs].filter((dir) => existsSync3(join19(project2.root, dir, "package.json"))).sort((a, b) => b.length - a.length);
   const nested = (file) => roots.find((dir) => file.startsWith(`${dir}/`)) ?? "";
   return { project: project2, id, dependencies, packageImports, jsxCounts, eligible, twins, dirs, importer, packageOf: nested };
 }
 
 // ../cli/src/report/projects.ts
-var import_yaml2 = __toESM(require_dist(), 1);
-import { readFile as readFile5 } from "node:fs/promises";
-import { basename as basename2, join as join17, resolve as resolve10 } from "node:path";
+var import_yaml3 = __toESM(require_dist(), 1);
+import { readFile as readFile7 } from "node:fs/promises";
+import { basename as basename4, join as join20, resolve as resolve13 } from "node:path";
 var UI_FILES = ["**/*.{tsx,jsx,astro,vue,svelte}"];
 var strings = (value) => Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
 async function workspaceGlobs(root, pkg) {
-  const pnpm = await readFile5(join17(root, "pnpm-workspace.yaml"), "utf8").catch(() => null);
+  const pnpm = await readFile7(join20(root, "pnpm-workspace.yaml"), "utf8").catch(() => null);
   if (pnpm !== null) {
     try {
-      const globs2 = strings((0, import_yaml2.parse)(pnpm)?.packages);
+      const globs2 = strings((0, import_yaml3.parse)(pnpm)?.packages);
       if (globs2.length > 0) return { globs: globs2, source: "pnpm-workspace.yaml" };
     } catch {
     }
@@ -3354,9 +3949,9 @@ async function workspaceGlobs(root, pkg) {
 }
 var hasUi = async (dir) => (await findFiles(dir, UI_FILES, DEFAULT_EXCLUDE)).length > 0;
 async function findProjects(dir) {
-  const root = resolve10(dir);
-  const pkg = await readJson(join17(root, "package.json"));
-  const name = typeof pkg?.name === "string" && pkg.name.trim() ? pkg.name.trim() : basename2(root);
+  const root = resolve13(dir);
+  const pkg = await readJson(join20(root, "package.json"));
+  const name = typeof pkg?.name === "string" && pkg.name.trim() ? pkg.name.trim() : basename4(root);
   const single = { dir: ".", root, name: typeof pkg?.name === "string" ? pkg.name : null };
   const workspace = await workspaceGlobs(root, pkg);
   if (!workspace) return { root, name, layout: "one project", projects: [single], skipped: [] };
@@ -3366,12 +3961,12 @@ async function findProjects(dir) {
   const projects = [];
   const skipped = [];
   for (const member of members) {
-    const memberRoot = join17(root, member);
+    const memberRoot = join20(root, member);
     if (!await hasUi(memberRoot)) {
       skipped.push(member);
       continue;
     }
-    const memberPkg = await readJson(join17(memberRoot, "package.json"));
+    const memberPkg = await readJson(join20(memberRoot, "package.json"));
     projects.push({ dir: member, root: memberRoot, name: typeof memberPkg?.name === "string" ? memberPkg.name : null });
   }
   if (projects.length === 0) return { root, name, layout: `one project (${workspace.source} names no package with UI files)`, projects: [single], skipped };
@@ -3398,7 +3993,7 @@ var Lines = class {
     if (!this.enabled) return { at };
     let lines = this.files.get(file);
     if (!lines) {
-      lines = (await readFile6(join18(this.root, file), "utf8").catch(() => "")).split("\n");
+      lines = (await readFile8(join21(this.root, file), "utf8").catch(() => "")).split("\n");
       this.files.set(file, lines);
     }
     const code = lines[line - 1]?.trim();
@@ -3413,15 +4008,15 @@ function hardcodedValue(finding3) {
   const value = bracket ?? (declaration ? `${declaration[2]} (${declaration[1]})` : finding3.text);
   return { word: word === "type" ? "text size" : word, value, tokens };
 }
-async function modulesOf(project2, target, failed) {
+async function modulesOf(project2, target, failed2) {
   const modules = [];
   for (const file of target.files) {
     if (isShowcase(file)) continue;
     try {
-      const module = await parseModule(file, await readFile6(join18(project2.root, file), "utf8"));
+      const module = await parseModule(file, await readFile8(join21(project2.root, file), "utf8"));
       if (module) modules.push(module);
     } catch (error) {
-      failed.push(`${repoPath(project2.dir, file)}: ${errorText(error)}`);
+      failed2.push(`${repoPath(project2.dir, file)}: ${errorText(error)}`);
     }
   }
   return modules;
@@ -3442,7 +4037,7 @@ async function grouped(project2, found, lines, describe) {
   return findings2.sort((a, b) => b.count - a.count || a.title.localeCompare(b.title));
 }
 async function analyseProject(project2, index, inventory, inventoryError, workspaceNames, lines) {
-  const failed = [];
+  const failed2 = [];
   const incomplete = [];
   const notes = [];
   const projectId = inventory?.projects[index]?.id;
@@ -3450,7 +4045,7 @@ async function analyseProject(project2, index, inventory, inventoryError, worksp
   let target = null;
   try {
     target = await loadInventoryTarget(project2.root);
-    modules = await modulesOf(project2, target, failed);
+    modules = await modulesOf(project2, target, failed2);
   } catch (error) {
     incomplete.push(`The code could not be read (${errorText(error)})`);
   }
@@ -3493,7 +4088,7 @@ async function analyseProject(project2, index, inventory, inventoryError, worksp
   const components = [...byComponent.values()].map((c) => ({ name: c.name, file: c.file, uses: c.roles.length, role: [...new Set(c.roles)].sort((a, b) => c.roles.filter((r) => r === b).length - c.roles.filter((r) => r === a).length)[0] })).sort((a, b) => b.uses - a.uses || a.name.localeCompare(b.name)).slice(0, TOP_COMPONENTS);
   const inventoryProject = inventory?.projects[index];
   if (inventoryError) incomplete.push(`The component inventory could not be built (${inventoryError}); run ${NPX} inventory --project ${project2.dir} to see why`);
-  for (const f of inventoryProject?.failed ?? []) failed.push(`${repoPath(project2.dir, f.file)}: ${f.reason}`);
+  for (const f of inventoryProject?.failed ?? []) failed2.push(`${repoPath(project2.dir, f.file)}: ${f.reason}`);
   let hardcoded = [];
   let offLibrary = [];
   const everyLine = () => true;
@@ -3522,7 +4117,7 @@ async function analyseProject(project2, index, inventory, inventoryError, worksp
       incomplete.push(`Library choices were not compared (${errorText(error)}); run ${NPX} detect ${project2.dir} to see why`);
     }
   }
-  const pkg = await readFile6(join18(project2.root, "package.json"), "utf8").then((text) => JSON.parse(text), () => null);
+  const pkg = await readFile8(join21(project2.root, "package.json"), "utf8").then((text) => JSON.parse(text), () => null);
   const dependencies = new Set(["dependencies", "devDependencies", "peerDependencies"].flatMap((key2) => Object.keys(pkg?.[key2] ?? {})));
   const importer = changeProject ? await importOf(changeProject) : () => "";
   const facts = factsOf(project2, projectId ?? null, modules, eligible, workspaceNames, dependencies, target?.files ?? [], importer);
@@ -3530,7 +4125,7 @@ async function analyseProject(project2, index, inventory, inventoryError, worksp
     dir: project2.dir,
     name: project2.name,
     files: inventoryProject?.files ?? modules.length,
-    failed,
+    failed: failed2,
     libraries,
     unused,
     definitions: inventory ? inventory.definitions.filter((d) => d.project === projectId && !isShowcase(d.file)).length : 0,
@@ -3966,36 +4561,36 @@ ${model.projects.map((p) => projectSection(p, many, looks)).join("\n")}
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync4, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname9, join as join19 } from "node:path";
+import { dirname as dirname12, join as join22 } from "node:path";
 var LOOKS_PER_PROJECT = 4;
 var DOWNLOAD_SIZE = "~100 MB";
 var DEPENDENCIES = "Install the repo's dependencies to see rendered looks";
 var UNDRAWABLE = /not installed|loads no stylesheet|drawn from (?:its|their) (?:tag and )?classes|did not render|bundle failed|unstyled|stub fallback/i;
-var playwrightDir = () => dirname9(playwrightCli());
+var playwrightDir = () => dirname12(playwrightCli());
 function browsersPath(env) {
   const set = env.PLAYWRIGHT_BROWSERS_PATH;
-  if (set === "0") return join19(playwrightDir(), ".local-browsers");
+  if (set === "0") return join22(playwrightDir(), ".local-browsers");
   if (set) return set;
-  if (process.platform === "darwin") return join19(homedir2(), "Library/Caches/ms-playwright");
-  if (process.platform === "win32") return join19(env.LOCALAPPDATA ?? join19(homedir2(), "AppData/Local"), "ms-playwright");
-  return join19(env.XDG_CACHE_HOME ?? join19(homedir2(), ".cache"), "ms-playwright");
+  if (process.platform === "darwin") return join22(homedir2(), "Library/Caches/ms-playwright");
+  if (process.platform === "win32") return join22(env.LOCALAPPDATA ?? join22(homedir2(), "AppData/Local"), "ms-playwright");
+  return join22(env.XDG_CACHE_HOME ?? join22(homedir2(), ".cache"), "ms-playwright");
 }
 function chromiumStatus(env = process.env) {
   if (env.YOUI_CHROMIUM) return { available: existsSync4(env.YOUI_CHROMIUM), where: env.YOUI_CHROMIUM };
   try {
-    const browsers = JSON.parse(readFileSync2(join19(playwrightDir(), "browsers.json"), "utf8"));
+    const browsers = JSON.parse(readFileSync2(join22(playwrightDir(), "browsers.json"), "utf8"));
     const revision2 = browsers.browsers.find((b) => b.name === "chromium-headless-shell")?.revision;
-    const dir = join19(browsersPath(env), `chromium_headless_shell-${revision2}`);
-    return { available: revision2 !== void 0 && existsSync4(join19(dir, "INSTALLATION_COMPLETE")), where: dir };
+    const dir = join22(browsersPath(env), `chromium_headless_shell-${revision2}`);
+    return { available: revision2 !== void 0 && existsSync4(join22(dir, "INSTALLATION_COMPLETE")), where: dir };
   } catch {
     return { available: false, where: "playwright-core is not installed" };
   }
 }
 function downloadChromium() {
-  return new Promise((resolve13) => {
-    const child = spawn2(process.execPath, [join19(playwrightDir(), "cli.js"), "install", "chromium-headless-shell"], { stdio: ["ignore", 2, 2] });
-    child.on("error", () => resolve13(false));
-    child.on("close", (code) => resolve13(code === 0));
+  return new Promise((resolve16) => {
+    const child = spawn2(process.execPath, [join22(playwrightDir(), "cli.js"), "install", "chromium-headless-shell"], { stdio: ["ignore", 2, 2] });
+    child.on("error", () => resolve16(false));
+    child.on("close", (code) => resolve16(code === 0));
   });
 }
 var dataUri = (file) => file && existsSync4(file) ? `data:image/png;base64,${readFileSync2(file).toString("base64")}` : null;
@@ -4009,24 +4604,24 @@ async function addLooks(model, repoRoot, options = {}) {
     const where2 = section.dir === "." ? "this repo" : section.dir;
     try {
       const installed = (name) => {
-        let dir = join19(repoRoot, section.dir);
+        let dir = join22(repoRoot, section.dir);
         while (true) {
-          if (existsSync4(join19(dir, "node_modules", name, "package.json"))) return true;
-          if (dir === repoRoot || dirname9(dir) === dir) return false;
-          dir = dirname9(dir);
+          if (existsSync4(join22(dir, "node_modules", name, "package.json"))) return true;
+          if (dir === repoRoot || dirname12(dir) === dir) return false;
+          dir = dirname12(dir);
         }
       };
       if (!installed("react") || !installed("react-dom")) {
         missing.push(where2);
         continue;
       }
-      const projectRoot = join19(repoRoot, section.dir);
+      const projectRoot = join22(repoRoot, section.dir);
       const target = await loadInventoryTarget(projectRoot);
       if (findStylesheets(projectRoot, target.files, { tsconfig: target.tsconfig, override: target.specimenCss, templates: target.templates }).found.length === 0) {
         missing.push(where2);
         continue;
       }
-      const report = await renderShots(join19(repoRoot, section.dir), names, { download: false, base: "HEAD", ...options.executablePath ? { executablePath: options.executablePath } : {}, ...options.cache ? { cache: options.cache } : {}, ...options.log ? { log: options.log } : {} });
+      const report = await renderShots(join22(repoRoot, section.dir), names, { download: false, base: "HEAD", ...options.executablePath ? { executablePath: options.executablePath } : {}, ...options.cache ? { cache: options.cache } : {}, ...options.log ? { log: options.log } : {} });
       const unavailable = report.notes.some((note) => UNDRAWABLE.test(note));
       if (unavailable) {
         missing.push(where2);
@@ -4096,9 +4691,9 @@ function renderMarkdown(model, reportFile) {
 
 // ../cli/src/report/safe.ts
 import { realpathSync as realpathSync2 } from "node:fs";
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 import { homedir as homedir3, userInfo as userInfo2 } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join23 } from "node:path";
 var REDACTED = "[redacted]";
 var OUTSIDE = "[path outside the repo]";
 var MIN_VALUE = 6;
@@ -4110,7 +4705,7 @@ async function dotenvValues(root) {
   const files = await findFiles(root, [".env", ".env.*", "**/.env", "**/.env.*"]).catch(() => []);
   const values = [];
   for (const file of files) {
-    const text = await readFile7(join20(root, file), "utf8").catch(() => "");
+    const text = await readFile9(join23(root, file), "utf8").catch(() => "");
     for (const line of text.split(/\r?\n/)) {
       const match = /^\s*(?:export\s+)?[A-Za-z_][A-Za-z0-9_.-]*\s*=\s*(.*)$/.exec(line);
       if (!match) continue;
@@ -4237,12 +4832,12 @@ async function askTerminal(question) {
   }
 }
 async function writeBinaryAtomic(file, bytes) {
-  const temp = `${file}.${process.pid}.${randomBytes2(6).toString("hex")}.tmp`;
+  const temp = `${file}.${process.pid}.${randomBytes3(6).toString("hex")}.tmp`;
   await writeFile2(temp, bytes);
-  await rename2(temp, file);
+  await rename3(temp, file);
 }
 var shown = (file) => {
-  const rel = relative7(process.cwd(), file);
+  const rel = relative10(process.cwd(), file);
   return rel && !rel.startsWith("..") ? rel : file;
 };
 async function runReport(options = {}, io = {}) {
@@ -4251,8 +4846,8 @@ async function runReport(options = {}, io = {}) {
   const error = io.error ?? ((text) => void process.stderr.write(`${text}
 `));
   const env = io.env ?? process.env;
-  const root = resolve11(options.path ?? process.cwd());
-  if (!(await stat2(root).catch(() => null))?.isDirectory()) {
+  const root = resolve14(options.path ?? process.cwd());
+  if (!(await stat3(root).catch(() => null))?.isDirectory()) {
     error(`\u2716 ${options.path ?? root} is not a directory: run ${NPX} in a repo, or pass its path (${NPX} path/to/repo)`);
     return { code: 2, files: null, model: null };
   }
@@ -4281,9 +4876,9 @@ async function runReport(options = {}, io = {}) {
   model.durationMs += Math.round(performance.now() - started);
   const redactor = await Redactor.forRepo(root, { includeCode: options.includeCode === true, env });
   const clean = redactor.model(model);
-  const outDir = resolve11(options.out ?? root);
-  await mkdir4(outDir, { recursive: true });
-  const files = { report: join21(outDir, REPORT_FILE), card: join21(outDir, CARD_FILE), summary: join21(outDir, SUMMARY_FILE) };
+  const outDir = resolve14(options.out ?? root);
+  await mkdir5(outDir, { recursive: true });
+  const files = { report: join24(outDir, REPORT_FILE), card: join24(outDir, CARD_FILE), summary: join24(outDir, SUMMARY_FILE) };
   const t = clean.totals;
   const card = {
     repo: redactor.scrub(clean.repo),
@@ -4367,6 +4962,23 @@ ${style.bold("Anywhere")}  ${style.dim("no design system needed")}
                            an unchanged component comes from the cache (YOUI_SPECIMEN_CACHE)
 
 ${style.bold("In a product repo")}
+  status [--json]          where the product stands with its design system, in a few lines: the System
+                           and its source, what a sync would change (a dry run, offline), local drift,
+                           errors and warnings (beyond the baseline), components used, open requests,
+                           and the one thing to do next. In a workspace (youi.workspace.json, or a repo
+                           holding several products), one block per product
+  adopt [--components dir] [--css file] [--system id] [--fork] [--dry-run]
+                           make this product's own UI its design system, kept in this repo: a draft
+                           contract per component in the components folder (the files stay where they
+                           are), the stylesheet's :root and dark variables as tokens (moved: the
+                           stylesheet imports the generated tokens.css, same names and values), three
+                           starter rules as warnings, then init and sync; --dry-run writes nothing.
+                           Variables youiyoux generated from another System are left to it (adopt says
+                           which); --fork takes them as the start of this product's own System
+  system extract <dir> [--package name] [--dry-run]
+                           move the System adopt keeps here into a design repo of its own at <dir>
+                           (contracts with their implementations, tokens, rules), for a second app to
+                           follow; this product then follows it by path, and sync vendors its components
   init --design <dir|package>   write youi.project.json pointing at a design repo checkout, or at
                            the npm package that holds it (named, so no machine's folder), then sync;
                            a git repository goes in its source: { "git": "github:acme/design", "ref": "v3" }
@@ -4458,7 +5070,8 @@ ${style.bold("Detect")}  ${style.dim("which UI libraries a repo or website uses
 
 ${style.bold("The hub")}
   ui [--design dir] [--project dir] [--config file] [--root dir] [--port n] [--watch] [--state dir] [--inventory file] [--detect file]
-                           open the web hub on a design system (default: the demo system);
+                           open the web hub on a design system (default: the demo system; beside a
+                           youi.workspace.json, its products, with Work > Workspace to switch);
                            --project adds that product's usage map (read-only scan) and the
                            rule editor (System > Rules, Work > Changes): drafts, impact preview,
                            approval, a review branch in the design repo (drafts kept in --state);
@@ -4528,6 +5141,8 @@ var OPTIONS = {
   dark: { type: "string" },
   state: { type: "string" },
   inventory: { type: "string" },
+  package: { type: "string" },
+  fork: { type: "boolean", default: false },
   cache: { type: "string" },
   role: { type: "string" },
   license: { type: "string" },
@@ -4551,7 +5166,7 @@ var UsageError = class extends Error {
 var run6 = promisify5(execFile5);
 var print = (text) => void process.stdout.write(`${text}
 `);
-var json = (value) => print(JSON.stringify(value, null, 2));
+var json3 = (value) => print(JSON.stringify(value, null, 2));
 function loadOptions(values) {
   return { ...values.config ? { configPath: values.config } : {}, ...values.design ? { designRoot: values.design } : {}, ...values.root !== void 0 ? { productRoot: values.root || "." } : {} };
 }
@@ -4559,17 +5174,17 @@ async function project(values) {
   return loadProject(values.project ?? process.cwd(), loadOptions(values));
 }
 async function readJsonOrFile(value) {
-  const text = value.trim().startsWith("{") ? value : await readFile8(value, "utf8");
+  const text = value.trim().startsWith("{") ? value : await readFile10(value, "utf8");
   return JSON.parse(text);
 }
 async function cmdScan(values) {
   const p = await project(values);
   const { report } = await scanProject(p);
-  const out = values.out ?? join22(p.root, ".youi/usage.json");
-  await writeFileAtomic(resolve12(out), `${JSON.stringify(report)}
+  const out = values.out ?? join25(p.root, ".youi/usage.json");
+  await writeFileAtomic(resolve15(out), `${JSON.stringify(report)}
 `);
-  const recorded = await recordUsage(values, p, report, resolve12(out));
-  if (values.json) json(report);
+  const recorded = await recordUsage(values, p, report, resolve15(out));
+  if (values.json) json3(report);
   else print([renderScan(report, out), ...recorded ? [recorded] : []].join("\n"));
   return 0;
 }
@@ -4577,7 +5192,7 @@ async function recordUsage(values, p, report, usage) {
   const { path, home } = indexOf(values);
   try {
     await recordProject(await sharedStore(path), p, report);
-    await noteSource(home, { project: { root: resolve12(values.project ?? process.cwd()), options: Object.fromEntries(Object.entries(loadOptions(values)).map(([key2, value]) => [key2, resolve12(value)])), usage } });
+    await noteSource(home, { project: { root: resolve15(values.project ?? process.cwd()), options: Object.fromEntries(Object.entries(loadOptions(values)).map(([key2, value]) => [key2, resolve15(value)])), usage } });
     return null;
   } catch (error) {
     return notRecorded(error);
@@ -4592,19 +5207,19 @@ function indexOf(values) {
 }
 async function cmdGaps(values) {
   const dirs = inventoryDirs(values);
-  const inventory = values.inventory ? InventoryReport.parse(JSON.parse(await readFile8(resolve12(values.inventory), "utf8"))) : await scanInventory(values, dirs);
-  const cwd = values.inventory ? dirname10(resolve12(values.inventory)) : process.cwd();
-  const project2 = await loadProject(resolve12(dirs[0]), loadOptions(values)).catch(() => null);
+  const inventory = values.inventory ? InventoryReport.parse(JSON.parse(await readFile10(resolve15(values.inventory), "utf8"))) : await scanInventory(values, dirs);
+  const cwd = values.inventory ? dirname13(resolve15(values.inventory)) : process.cwd();
+  const project2 = await loadProject(resolve15(dirs[0]), loadOptions(values)).catch(() => null);
   const system = project2 ? { name: project2.system.config.name, components: project2.system.components.map((c) => c.contract.name) } : null;
-  const store = await readCatalog(resolve12(discoverCacheDir(values.cache)), indexOf(values).path).catch((error) => {
+  const store = await readCatalog(resolve15(discoverCacheDir(values.cache)), indexOf(values).path).catch((error) => {
     if (error instanceof MissingIndexError) return null;
     throw error;
   });
-  const roots = new Map(inventory.projects.map((p) => [p.id, resolve12(cwd, p.root)]));
+  const roots = new Map(inventory.projects.map((p) => [p.id, resolve15(cwd, p.root)]));
   const report = await buildGaps({ inventory, system, dependencies: declaredPackages(roots) }, store);
-  if (values.out) await writeFileAtomic(resolve12(values.out), `${JSON.stringify(report, null, 2)}
+  if (values.out) await writeFileAtomic(resolve15(values.out), `${JSON.stringify(report, null, 2)}
 `);
-  if (values.json) json(report);
+  if (values.json) json3(report);
   else print(renderGaps(report));
   return 0;
 }
@@ -4612,12 +5227,12 @@ async function cmdInventory(values) {
   if (values.history) return cmdHistory(values, []);
   const dirs = inventoryDirs(values);
   const report = await scanInventory(values, dirs);
-  const out = resolve12(values.out ?? join22(dirs[0], ".youi/inventory.json"));
+  const out = resolve15(values.out ?? join25(dirs[0], ".youi/inventory.json"));
   await writeFileAtomic(out, `${JSON.stringify(report, null, 2)}
 `);
   const recorded = await recordScan(values, report, out);
-  if (values.json) json(report);
-  else print([renderInventory(report, relative8(process.cwd(), out).startsWith("..") ? out : relative8(process.cwd(), out)), recorded].join("\n"));
+  if (values.json) json3(report);
+  else print([renderInventory(report, relative11(process.cwd(), out).startsWith("..") ? out : relative11(process.cwd(), out)), recorded].join("\n"));
   return 0;
 }
 async function recordScan(values, report, out) {
@@ -4634,7 +5249,7 @@ async function recordScan(values, report, out) {
 async function cmdHistory(values, positionals) {
   const { path } = indexOf(values);
   const scans = await (await sharedStore(path, process.env, { readOnly: true })).history({ ...positionals[0] ? { project: positionals[0] } : {}, limit: positiveInt(values.limit, "--limit") ?? 50 });
-  if (values.json) json(scans);
+  if (values.json) json3(scans);
   else print(renderHistory(scans));
   return 0;
 }
@@ -4642,19 +5257,19 @@ async function cmdIndex(values, positionals) {
   const [action, ...rest] = positionals;
   const { path, home } = indexOf(values);
   if (action === "path") {
-    if (values.json) json({ store: storeLocation({ path }), sources: join22(home, SOURCES_FILE), scans: join22(home, SCANS_LOG) });
+    if (values.json) json3({ store: storeLocation({ path }), sources: join25(home, SOURCES_FILE), scans: join25(home, SCANS_LOG) });
     else print(storeLocation({ path }));
     return 0;
   }
   if (action === "stats") {
     const stats = await (await sharedStore(path, process.env, { readOnly: true })).stats();
-    if (values.json) json(stats);
+    if (values.json) json3(stats);
     else print([`${style.bold("index")} ${stats.location} ${style.dim(`\xB7 ${stats.engine} \xB7 schema ${stats.schema} \xB7 generation ${stats.generation ?? "not rebuilt"}`)}`, ...Object.entries(stats.tables).map(([table, n]) => `  ${table.padEnd(16)} ${n.toLocaleString("en-US")}`)].join("\n"));
     return 0;
   }
   if (action === "rebuild") {
-    const summary = await rebuildIndex(path, values.cache ? { discoverCache: resolve12(values.cache) } : {});
-    if (values.json) json(summary);
+    const summary = await rebuildIndex(path, values.cache ? { discoverCache: resolve15(values.cache) } : {});
+    if (values.json) json3(summary);
     else print(renderRebuild(summary));
     return 0;
   }
@@ -4668,7 +5283,7 @@ async function cmdWhere(values, positionals) {
   const { report } = await scanProject(p);
   const limit = values.all ? Number.MAX_SAFE_INTEGER : Number(values.limit ?? (values.json ? 20 : 24));
   const where2 = whereUsed(p, report, query, { ...values.route ? { route: values.route } : {}, limit });
-  if (values.json) json(where2);
+  if (values.json) json3(where2);
   else print(renderWhere(where2, report));
   return 0;
 }
@@ -4679,7 +5294,7 @@ async function cmdShow(values, positionals) {
   const contract = findContract(p, query);
   if (!contract) throw new Error(`no component "${query}"; known: ${p.system.components.map((c) => c.contract.name).join(", ")}`);
   const card = componentCard(p, contract, (await scanProject(p)).report);
-  if (values.json) json(card);
+  if (values.json) json3(card);
   else print(renderShow(card));
   return 0;
 }
@@ -4688,12 +5303,12 @@ async function cmdBom(values, positionals) {
   if (!route) throw new UsageError("youiyoux bom <route>");
   const p = await project(values);
   const bom = screenBom(p, (await scanProject(p)).report, route);
-  if (values.json) json(bom);
+  if (values.json) json3(bom);
   else print(renderBom(bom));
   return 0;
 }
 function baselineFile(values, p) {
-  if (values["baseline-file"]) return resolve12(values["baseline-file"]);
+  if (values["baseline-file"]) return resolve15(values["baseline-file"]);
   return values.baseline ? baselinePath(p, values.config) : null;
 }
 var checkScope = (values, positionals) => ({ ...positionals.length > 0 ? { files: positionals } : {}, ...values.rule ? { rule: values.rule } : {}, quiet: values.quiet });
@@ -4712,7 +5327,7 @@ async function cmdCheck(values, positionals) {
   const result = await runCheck(p, { ...checkScope(values, positionals), baseline: baselineFile(values, p) });
   if (format === "json") {
     const { report } = result.scan;
-    json({ errors: result.errors, incomplete: result.incomplete, identity: result.identity, unmatched: result.unmatched, notRun: result.notRun, violations: result.violations, baseline: result.baseline, lock: result.lock, suppressed: report.suppressed, coverage: report.coverage, status: report.status, checks: report.checks });
+    json3({ errors: result.errors, incomplete: result.incomplete, identity: result.identity, unmatched: result.unmatched, notRun: result.notRun, violations: result.violations, baseline: result.baseline, lock: result.lock, suppressed: report.suppressed, coverage: report.coverage, status: report.status, checks: report.checks });
   } else if (format === "github") {
     for (const line of githubAnnotations(result, await repoPrefix(p.root))) print(line);
     print(renderCheckText(result));
@@ -4724,7 +5339,7 @@ async function cmdCheckDiff(values, positionals, p, format) {
   if (values.baseline) throw new UsageError("youiyoux check --diff looks only at added lines, so a baseline does not apply; drop --baseline");
   const change = await workingTreeChange(p, values.base);
   const result = configured(p) ? await runCheck(p, { ...checkScope(values, positionals), diff: change }) : await runRepoCheck(p, change);
-  if (format === "json") json(diffJson(result));
+  if (format === "json") json3(diffJson(result));
   else if (format === "github") {
     for (const line of githubDiffAnnotations(result, await repoPrefix(p.root))) print(line);
     print(renderDiffText(result));
@@ -4748,9 +5363,9 @@ async function cmdBaseline(values) {
   const file = baselineFile(values, p) ?? baselinePath(p, values.config);
   const written = await writeBaseline(p, file, { force: values.force });
   const { totals } = written.baseline;
-  if (values.json) json({ file: written.file, action: written.action, totals, notAdded: written.notAdded, identity: written.baseline.identity });
+  if (values.json) json3({ file: written.file, action: written.action, totals, notAdded: written.notAdded, identity: written.baseline.identity });
   else {
-    print(`${style.ok(written.action)} ${relative8(process.cwd(), file) || file}: ${plural(totals.errors, "error")} \xB7 ${plural(totals.warnings, "warning")} accepted`);
+    print(`${style.ok(written.action)} ${relative11(process.cwd(), file) || file}: ${plural(totals.errors, "error")} \xB7 ${plural(totals.warnings, "warning")} accepted`);
     print(style.dim(`  rules ${describeIdentity(written.baseline.identity)}`));
     if (written.notAdded > 0) print(style.warn(`  ${plural(written.notAdded, "current violation")} not added: fix them, or accept them deliberately with --force`));
   }
@@ -4764,30 +5379,30 @@ async function cmdPlan(values, positionals) {
   else if (positionals[0] && values.patch) input = { element: positionals[0], patch: await readJsonOrFile(values.patch) };
   else throw new UsageError("youiyoux plan <component> --patch <json|file>   or   youiyoux plan --token <id> [--value v]");
   const plan = await planChange(p, scan, input);
-  if (values.json) json(plan);
+  if (values.json) json3(plan);
   else print(renderPlan(plan));
   return 0;
 }
 async function cmdRules(values) {
   const p = await project(values);
   if (values.preview) {
-    const draft = (0, import_yaml3.parse)(await readFile8(values.preview, "utf8"));
+    const draft = (0, import_yaml4.parse)(await readFile10(values.preview, "utf8"));
     const evaluation = evaluateRule(p, await scanProject(p), draft);
-    if (values.json) json(evaluation);
+    if (values.json) json3(evaluation);
     else print(renderRulePreview(evaluation));
     return evaluation.ok && evaluation.findings !== null ? 0 : 1;
   }
   const rules = p.system.rules.map((rule2) => ({ rule: rule2, execution: ruleCapability(rule2) }));
-  if (values.json) json({ capabilities: checkCapabilities(), rules: rules.map(({ rule: rule2, execution }) => ({ id: rule2.id, severity: rule2.severity, ...execution })) });
+  if (values.json) json3({ capabilities: checkCapabilities(), rules: rules.map(({ rule: rule2, execution }) => ({ id: rule2.id, severity: rule2.severity, ...execution })) });
   else print(renderRules(rules));
   return rules.some(({ execution }) => execution.state === "unsupported") ? 1 : 0;
 }
 async function cmdMigrate(values, positionals) {
   const file = positionals[0];
   if (!file) throw new UsageError("youiyoux migrate <migration.yaml> [--write] [--diff]");
-  const spec = MigrationSpec.parse((0, import_yaml3.parse)(await readFile8(file, "utf8")));
+  const spec = MigrationSpec.parse((0, import_yaml4.parse)(await readFile10(file, "utf8")));
   const result = await runMigration(await project(values), spec, { write: values.write });
-  if (values.json) json(result);
+  if (values.json) json3(result);
   else print(renderMigration(result, values.diff || !values.write));
   return result.status === "rejected" ? 1 : 0;
 }
@@ -4797,14 +5412,14 @@ async function cmdLibrary(values, positionals) {
     const p = await project(values);
     const words = positionals.slice(1).join(" ");
     const result = searchLibrary(await loadLibrary(p.repo.root), words, Number(values.limit ?? 20));
-    if (values.json) json(result);
+    if (values.json) json3(result);
     else print(renderLibrarySearch(result, words));
     return 0;
   }
   if (action === "request" && query && values.reason) {
     const p = await project(values);
     const request = adoptionRequest(p, await loadLibrary(p.repo.root), query, values.reason, await scanProject(p));
-    if (values.json) json(request);
+    if (values.json) json3(request);
     else print(renderAdoptionRequest(request));
     return 0;
   }
@@ -4813,7 +5428,7 @@ async function cmdLibrary(values, positionals) {
 async function cmdSync(values) {
   const p = await loadProject(values.project ?? process.cwd(), { ...loadOptions(values), refreshDesign: true });
   const result = await syncProject(p, { dryRun: values["dry-run"], adopt: values.adopt });
-  if (values.json) json(result);
+  if (values.json) json3(result);
   else print([renderSync(result, values["dry-run"]), ...p.linked ? [style.warn(`! linked: the design system is your checkout ${p.linked}, not the config's source (youiyoux unlink to undo)`)] : []].join("\n"));
   return result.actions.some((a) => a.action === "conflict") ? 1 : 0;
 }
@@ -4821,7 +5436,7 @@ async function cmdInit(values) {
   if (!values.design) throw new UsageError("youiyoux init --design <dir|package>   (a design repo checkout, the directory holding youi.config.json, or the npm package that holds it)");
   const root = values.project ?? process.cwd();
   const design = await designArg(values.design, root);
-  const result = await initProject({ root, ...design, schemaDir: join22(TOOL_ROOT, "schema"), ...values.system ? { system: values.system } : {}, ...values.components ? { componentsDir: values.components } : {}, force: values.force });
+  const result = await initProject({ root, ...design, schemaDir: join25(TOOL_ROOT, "schema"), ...values.system ? { system: values.system } : {}, ...values.components ? { componentsDir: values.components } : {}, force: values.force });
   if (!values.json) {
     print(`${style.ok("created")} ${result.file}`);
     for (const note of result.notes) print(style.dim(`  \xB7 ${note}`));
@@ -4830,6 +5445,82 @@ async function cmdInit(values) {
   const { design: _named, ...rest } = values;
   return cmdSync({ ...design.package ? rest : values, project: root });
 }
+async function cmdAdopt(values) {
+  const root = resolve15(values.project ?? process.cwd());
+  if (await exists(join25(root, PROJECT_FILE))) throw new Error(`${root} already has ${PROJECT_FILE}: it follows a design system already (youiyoux sync updates it)`);
+  const plan = await planAdoption({ root, ...values.components ? { componentsDir: values.components } : {}, ...values.css ? { css: values.css } : {}, ...values.system ? { system: values.system } : {}, fork: values.fork });
+  const taken = (await Promise.all(plan.files.map(async (f) => await exists(join25(root, f.path)) ? f.path : null))).filter((f) => f !== null);
+  if (taken.length > 0) throw new Error(`nothing was written: ${taken.slice(0, 5).join(", ")}${taken.length > 5 ? ` and ${taken.length - 5} more` : ""} already exist${taken.length === 1 ? "s" : ""}`);
+  if (values["dry-run"]) {
+    if (values.json) json3(plan);
+    else print([...adoptLines(plan, true), "", style.dim(`dry run: nothing written; would write ${plan.files.map((f) => f.path).join(", ")}${plan.stylesheet ? ` and change ${plan.stylesheet.path}` : ""}`)].join("\n"));
+    return 0;
+  }
+  const stylesheet = plan.stylesheet ? await readFile10(join25(root, plan.stylesheet.path), "utf8") : null;
+  try {
+    for (const file of plan.files) await writeFileAtomic(join25(root, file.path), file.content);
+    if (plan.stylesheet) await writeFileAtomic(join25(root, plan.stylesheet.path), plan.stylesheet.content);
+    await initProject({ root, design: root, schemaDir: join25(TOOL_ROOT, "schema"), system: plan.system.id, componentsDir: plan.componentsDir, outputs: { ...plan.outputs, targets: [...plan.outputs.targets], dark: [...plan.outputs.dark] }, tokenSources: plan.tokenSources });
+    await syncProject(await loadProject(root), { dryRun: true });
+  } catch (error) {
+    for (const file of [...plan.files.map((f) => f.path), PROJECT_FILE]) await rm6(join25(root, file), { force: true });
+    for (const folder of [...new Set(plan.files.map((f) => dirname13(f.path)))].sort((a, b) => b.length - a.length)) await rmdir3(join25(root, folder)).catch(() => void 0);
+    await rmdir3(join25(root, "design/components")).catch(() => void 0);
+    await rmdir3(join25(root, "design")).catch(() => void 0);
+    if (plan.stylesheet && stylesheet !== null) await writeFileAtomic(join25(root, plan.stylesheet.path), stylesheet);
+    throw new Error(`adopt was undone, nothing kept: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!values.json) print([...adoptLines(plan), ""].join("\n"));
+  const synced = await cmdSync({ ...values, project: root, components: void 0, css: void 0, system: void 0 });
+  if (!values.json) print(`Next: describe each component in design/components/<name>/<name>.contract.json (its summary, guidance and examples; agents read them), see what is left with youiyoux check, and when a second app needs this System, youiyoux system extract <dir> moves it into its own repo`);
+  return synced;
+}
+function adoptLines(plan, dryRun = false) {
+  const { tokens } = plan;
+  const shown2 = plan.components.slice(0, 6).join(", ") + (plan.components.length > 6 ? `, \u2026 ${plan.components.length - 6} more` : "");
+  return [
+    `${style.ok(dryRun ? "would adopt" : "adopted")} ${plan.system.name} ${style.dim(`(system ${plan.system.id}) from this product's own UI`)}`,
+    `  components  ${plural(plan.components.length, "component")} in ${plan.componentsDir} (${shown2}): a draft contract each in design/components; the files stay where they are${plan.support.length > 0 ? ` (${plan.support.join(", ")} as support)` : ""}`,
+    tokens.stylesheet ? `  tokens      ${plural(tokens.count, "variable")}${tokens.dark ? ", light and dark," : ""} from ${tokens.stylesheet} \u2192 design/tokens${tokens.left.length > 0 ? `; ${tokens.left.length} left in the stylesheet, not typed: ${tokens.left.slice(0, 4).map((l) => `--${l.name} (${l.value})`).join(", ")}${tokens.left.length > 4 ? ", \u2026" : ""}` : ""}` : `  tokens      none: no stylesheet defines :root variables (--css <file> names one)`,
+    ...plan.stylesheet ? [`  stylesheet  ${plan.stylesheet.path}: their ${plural(plan.stylesheet.moved, "declaration")}${tokens.dark ? " (light and dark)" : ""} moved into the System; it imports ${plan.outputs.dir}/tokens.css (same names, same values)`] : [],
+    `  rules       3 starter rules, as warnings: design/rules`,
+    `  config      youi.config.json (the System) and youi.project.json (this product follows it)`,
+    ...plan.notes.map((n) => style.warn(`  ! ${n}`)),
+    // The product follows a System already: its values were left to it, and here is how to keep one System, or fork it.
+    ...plan.follows.map((g) => {
+      const system = g.system ?? "a System";
+      return style.warn(`  ! ${g.file} holds ${plural(g.count, "variable")} youiyoux generated from ${system}${g.version ? ` v${g.version}` : ""}: this product already uses ${g.system ? "that System" : "one"}, so they were left to it. To manage the product with ${system}, run youiyoux init --design <${system}'s repo or package>; to make a System of the product's own from them, run youiyoux adopt --fork`);
+    })
+  ];
+}
+async function cmdStatus(values) {
+  const report = await workspaceStatus(process.cwd(), values.project);
+  if (values.json) json3(report);
+  else print(renderStatus(report));
+  return report.projects.length === 0 ? 1 : statusExitCode(report);
+}
+async function cmdSystem(values, positionals) {
+  const [action, dir, ...extra] = positionals;
+  if (action !== "extract" || dir === void 0 || extra.length > 0) throw new UsageError("youiyoux system extract <dir> [--package <name>] [--dry-run]   (move the System youiyoux adopt keeps in this product into a design repo of its own)");
+  if (values.package !== void 0 && !PACKAGE_NAME.test(values.package)) throw new UsageError(`--package ${JSON.stringify(values.package)}: expected an npm package name such as @acme/design`);
+  const p = await project(values);
+  const result = await extractSystem(p, dir, { ...values.package ? { package: values.package } : {}, dryRun: values["dry-run"] });
+  const contracts = result.written.filter((f) => f.endsWith(".contract.json")).length;
+  const lines = [
+    `${style.ok(values["dry-run"] ? "would extract" : "extracted")} ${p.system.config.name} ${style.dim(`(system ${result.system.id})`)} \u2192 ${result.target}`,
+    `  repo        ${plural(result.written.length, "file")}: youi.config.json, ${plural(contracts, "contract")} with their implementations beside them, the tokens, rules${result.system.design ? " and design.md" : ""}${values.package ? `, and package.json (${values.package})` : ""}`,
+    `  product     youi.project.json follows it (source: ${JSON.stringify(result.source)}); ${values["dry-run"] ? "would remove" : "removed"} its System files: ${result.removed.join(", ")}`
+  ];
+  if (values["dry-run"]) {
+    print([...lines, "", style.dim("dry run: nothing written or removed")].join("\n"));
+    return 0;
+  }
+  print([...lines, ""].join("\n"));
+  const synced = await cmdSync({ ...values, project: p.root, package: void 0 });
+  const git3 = `push it and set source to { "git": "<its url>", "ref": "v${result.system.version}" }`;
+  print(`Next: make ${relative11(process.cwd(), result.target) || "."} a repository of its own and commit it. For each app to follow it, ${values.package ? `publish ${values.package}, add it as a dependency and set source to { "package": "${values.package}" }, or ${git3}` : `${git3}, or publish it as an npm package (--package names it)`}. Change components there from now on: youiyoux sync merges them into each product`);
+  return synced;
+}
 async function cmdLink(values, positionals) {
   const [dir] = positionals;
   const p = await loadProject(values.project ?? process.cwd(), { ...loadOptions(values), ...dir !== void 0 ? { designRoot: dir } : {} });
@@ -4845,37 +5536,37 @@ async function cmdUnlink(values) {
   const root = values.project ?? process.cwd();
   const linked = await linkedDesign(root);
   if (linked !== null) await setLink(root, null);
-  print(linked ? `${style.ok("unlinked")} ${resolve12(root)} uses its config's source again` : `${resolve12(root)} was not linked`);
+  print(linked ? `${style.ok("unlinked")} ${resolve15(root)} uses its config's source again` : `${resolve15(root)} was not linked`);
   return 0;
 }
 async function designArg(value, root) {
-  if (existsSync5(resolve12(value)) || !PACKAGE_NAME.test(value)) return { design: value };
-  return { design: await designRootOf({ package: value }, join22(resolve12(root), PROJECT_FILE), root), package: value };
+  if (existsSync5(resolve15(value)) || !PACKAGE_NAME.test(value)) return { design: value };
+  return { design: await designRootOf({ package: value }, join25(resolve15(root), PROJECT_FILE), root), package: value };
 }
 async function cmdBuild(values) {
-  const root = resolve12(values.design ?? process.cwd());
+  const root = resolve15(values.design ?? process.cwd());
   const system = getSystem(await loadDesignRepo(root), values.system);
   if (safeId(system.config.id) === null) throw new Error(`Cannot build system ${JSON.stringify(system.config.id)}: the id must be a plain name without ".." or path separators.`);
   const output = OutputConfig.parse({ cssVarPrefix: values.prefix ?? "youi", targets: ["css-vars", "tailwind-v4", "ts", "react-native"] });
   const started = performance.now();
   const built = await buildTokens(root, system.config, output, { contracts: system.components.map((c) => c.contract) });
-  const out = resolve12(values.out ?? join22(root, "build", system.config.id));
-  const boundary = values.out ? out : join22(root, "build");
-  if (!within(boundary, out) || built.files.some((file) => !within(out, join22(out, file.path)))) throw new Error(`Cannot build system ${JSON.stringify(system.config.id)}: an output path leaves the output directory.`);
-  for (const file of built.files) await writeFileAtomic(join22(out, file.path), file.content);
-  if (values.json) json({ out, files: built.files.map((f) => f.path), tokens: built.tokens.length });
+  const out = resolve15(values.out ?? join25(root, "build", system.config.id));
+  const boundary = values.out ? out : join25(root, "build");
+  if (!within(boundary, out) || built.files.some((file) => !within(out, join25(out, file.path)))) throw new Error(`Cannot build system ${JSON.stringify(system.config.id)}: an output path leaves the output directory.`);
+  for (const file of built.files) await writeFileAtomic(join25(out, file.path), file.content);
+  if (values.json) json3({ out, files: built.files.map((f) => f.path), tokens: built.tokens.length });
   else print(`${style.ok("built")} ${plural(built.tokens.length, "token")} \u2192 ${built.files.map((f) => f.path).join(", ")} ${style.dim(`in ${out} (${ms(performance.now() - started)})`)}`);
   return 0;
 }
 async function cmdParity(values) {
   if (!values.css) throw new UsageError("youiyoux parity --css <file> [--prefix p]");
-  const root = resolve12(values.design ?? process.cwd());
+  const root = resolve15(values.design ?? process.cwd());
   const system = getSystem(await loadDesignRepo(root), values.system);
   const prefix = values.prefix ?? "youi";
   const dark = { selector: values.dark ?? ':root[data-theme="dark"]' };
   const built = await buildTokens(root, system.config, OutputConfig.parse({ cssVarPrefix: prefix, dark: [dark], targets: ["css-vars"] }));
-  const report = compareParity(await readFile8(values.css, "utf8"), { light: { selector: values.light ?? ":root" }, dark }, built.files[0].content, { light: { selector: ":root" }, dark }, prefix);
-  if (values.json) json(report);
+  const report = compareParity(await readFile10(values.css, "utf8"), { light: { selector: values.light ?? ":root" }, dark }, built.files[0].content, { light: { selector: ":root" }, dark }, prefix);
+  if (values.json) json3(report);
   else {
     const ok = report.different.length === 0 && report.missing.length === 0;
     print(`${ok ? style.ok("\u2713 parity") : style.error("\u2716 parity")}  ${report.matched} matched \xB7 ${report.different.length} different \xB7 ${report.missing.length} missing \xB7 ${style.dim(`${report.added.length} new in the build`)}`);
@@ -4887,18 +5578,18 @@ async function cmdParity(values) {
 async function cmdSchema(values) {
   const schemas = renderJsonSchemas();
   if (values.check) {
-    const dir = join22(values.design ? resolve12(values.design) : TOOL_ROOT, "schema");
+    const dir = join25(values.design ? resolve15(values.design) : TOOL_ROOT, "schema");
     const stale = [];
-    for (const { file, content } of schemas) if (await readFile8(join22(dir, file), "utf8").catch(() => null) !== content) stale.push(file);
-    if (values.json) json({ dir, stale });
+    for (const { file, content } of schemas) if (await readFile10(join25(dir, file), "utf8").catch(() => null) !== content) stale.push(file);
+    if (values.json) json3({ dir, stale });
     else print(stale.length === 0 ? `${style.ok("\u2713")} ${dir} matches this youi's schemas` : `${style.error("\u2716")} out of date in ${dir}: ${stale.join(", ")}; run youiyoux schema --write${values.design ? " --design <dir>" : ""}`);
     return stale.length === 0 ? 0 : 1;
   }
   if (values.write) {
-    const root = values.design ? resolve12(values.design) : TOOL_ROOT;
-    for (const { file, content } of schemas) await writeFileAtomic(join22(root, "schema", file), content);
+    const root = values.design ? resolve15(values.design) : TOOL_ROOT;
+    for (const { file, content } of schemas) await writeFileAtomic(join25(root, "schema", file), content);
     print(`${style.ok("wrote")} ${schemas.map((s) => s.file).join(", ")}`);
-  } else json(Object.fromEntries(schemas.map((s) => [s.file, JSON.parse(s.content)])));
+  } else json3(Object.fromEntries(schemas.map((s) => [s.file, JSON.parse(s.content)])));
   return 0;
 }
 function hookTarget(values) {
@@ -4919,14 +5610,14 @@ async function cmdHooks(values, positionals) {
   if (action !== "install") throw new UsageError("youiyoux hooks install [--claude] [--git] [--ci [--diff]] [--strict]   or   youiyoux hooks run claude|pre-commit");
   const p = await loadCheckProject(values.project ?? process.cwd(), loadOptions(values), !values.project);
   if (values.ci && !configured(p)) throw new UsageError("Run youiyoux init --design <dir> before installing the pinned CI workflow; repo-mode CI can run youiyoux check --diff <base> --strict directly");
-  const target = { ...hookTarget(values), project: p.root, ...configured(p) && p.configFile && p.configFile !== join22(p.root, PROJECT_FILE) ? { config: p.configFile } : {}, ...values.root !== void 0 ? { root: p.root } : {} };
+  const target = { ...hookTarget(values), project: p.root, ...configured(p) && p.configFile && p.configFile !== join25(p.root, PROJECT_FILE) ? { config: p.configFile } : {}, ...values.root !== void 0 ? { root: p.root } : {} };
   const all = !values.claude && !values.git && !values.ci;
   const results = [];
   if (values.claude || all) results.push({ kind: "Claude Code", ...await installClaudeHook(await repoRootOf(p.root), hookCommand(TOOL_ROOT, "claude", target)) });
   if (values.git || all) results.push({ kind: "git pre-commit", ...await installPreCommit(p.root, hookCommand(TOOL_ROOT, "pre-commit", target, values.strict ? ["--strict"] : []), values.strict) });
   if (values.git || all) results.push({ kind: "Codex", ...configured(p) ? codexFallback(p.root, p.config.agents.agentsMd) : await installRepoAgentInstructions(p.root) });
   if (values.ci && configured(p)) results.push({ kind: "CI", ...await installWorkflow(p, TOOL_ROOT, target, values.force, { diff: values.diff }) });
-  if (values.json) json(results);
+  if (values.json) json3(results);
   else for (const r of results) print(`${r.action === "unchanged" || r.action === "skipped" ? style.dim(r.action) : style.ok(r.action)} ${r.kind}: ${r.file}
   ${style.dim(r.guarantee)}`);
   return 0;
@@ -4934,11 +5625,11 @@ async function cmdHooks(values, positionals) {
 async function cmdAgents(values, positionals) {
   const [action] = positionals;
   if (action !== "install" && action !== "remove") throw new UsageError("youiyoux agents install|remove [--claude] [--codex] [--json]");
-  const projectRoot = resolve12(values.project ?? process.cwd());
+  const projectRoot = resolve15(values.project ?? process.cwd());
   const repoRoot = await repoRootOf(projectRoot);
-  const target = { project: projectRoot, ...values.config ? { config: resolve12(values.config) } : {}, ...values.design ? { design: resolve12(values.design) } : {}, ...values.root !== void 0 ? { root: resolve12(values.root || ".") } : {} };
+  const target = { project: projectRoot, ...values.config ? { config: resolve15(values.config) } : {}, ...values.design ? { design: resolve15(values.design) } : {}, ...values.root !== void 0 ? { root: resolve15(values.root || ".") } : {} };
   const server = mcpCommand(TOOL_ROOT, target);
-  const system = existsSync5(resolve12(values.config ?? join22(projectRoot, PROJECT_FILE))) ? await project(values) : null;
+  const system = existsSync5(resolve15(values.config ?? join25(projectRoot, PROJECT_FILE))) ? await project(values) : null;
   const claudeServer = system && system.root === repoRoot ? { command: "node", args: mcpArgs(system) } : relativeTo(repoRoot, server);
   const both = !values.claude && !values.codex;
   const results = [];
@@ -4946,7 +5637,7 @@ async function cmdAgents(values, positionals) {
   results.push(...rule2.map((r) => ({ kind: "agent rule", ...r })));
   if (values.claude || both) results.push({ kind: "Claude Code MCP", ...action === "install" ? await installClaudeMcp(repoRoot, claudeServer) : await removeClaudeMcp(repoRoot) });
   if (values.codex || both) results.push({ kind: "Codex MCP", ...action === "install" ? await installCodexMcp(repoRoot, server) : await removeCodexMcp(repoRoot) });
-  if (values.json) json(results);
+  if (values.json) json3(results);
   else {
     for (const r of results) print(`${r.action === "unchanged" ? style.dim("unchanged") : style.ok(r.action)} ${r.kind}: ${r.file}
   ${style.dim(r.guarantee)}`);
@@ -5009,7 +5700,32 @@ async function startEditor(values, port) {
     return null;
   }
 }
+async function workspaceUi(values) {
+  if (values.design || values.project || values.config || values.root) return null;
+  const { roots, workspace } = await statusTargets(process.cwd());
+  if (workspace === null || roots.length === 0) return null;
+  print(style.dim(`reading the status of ${plural(roots.length, "product")}\u2026`));
+  const report = await workspaceStatus(process.cwd());
+  const first = report.projects.findIndex((p) => !("error" in p));
+  if (first < 0) {
+    print(renderStatus(report));
+    throw new Error("no product in this workspace could be read: see each one's Next above");
+  }
+  const port = values.port ?? DEFAULT_HUB_PORT;
+  let open = null;
+  const hub = await startWorkspaceHub({ roots, current: first, status: () => workspaceStatus(process.cwd()), open: (root) => open ? open(root) : Promise.resolve(1) });
+  print(`${style.ok("workspace hub")} http://localhost:${port}/workspace#key=${hub.key}`);
+  print(style.dim(`  ${plural(roots.length, "product")}; showing ${report.projects[first].root} first. Open the link: it carries this run's key, which switching needs`));
+  print(style.dim("  Rules and Changes are read-only here; youiyoux ui --project <dir> opens the rule editor on one product"));
+  try {
+    return await runHub(TOOL_ROOT, { project: roots[first], port, api: hub.url, workspace: (snapshot) => open = snapshot, ...values.inventory ? { inventory: values.inventory } : {}, ...values.detect ? { detect: values.detect } : {} });
+  } finally {
+    await hub.close();
+  }
+}
 async function cmdUi(values) {
+  const workspace = await workspaceUi(values);
+  if (workspace !== null) return workspace;
   const port = values.port ?? DEFAULT_HUB_PORT;
   const editor = await startEditor(values, port);
   try {
@@ -5021,23 +5737,23 @@ async function cmdUi(values) {
 async function cmdDetect(values, positionals) {
   const target = detectTarget(positionals);
   if (!target) throw new UsageError("youiyoux detect <repo-path>   or   youiyoux detect <url\u2026> [--expose]   (one repo, or one or more URLs; not both)");
-  const { repoReport, siteReport, writeReport } = await import("./src-YYI52B5R.js");
-  const out = resolve12(values.out ?? ".youi/detect");
+  const { repoReport, siteReport, writeReport } = await import("./src-ZG7JU6YJ.js");
+  const out = resolve15(values.out ?? ".youi/detect");
   const report = target.kind === "repo" ? await repoReport(target.path) : await siteReport(target.urls, { out, expose: values.expose, ...process.env.YOUI_CHROMIUM ? { executablePath: process.env.YOUI_CHROMIUM } : {} });
   const file = await writeReport(report, out);
-  if (values.json) json(report);
+  if (values.json) json3(report);
   else {
-    const shown2 = relative8(process.cwd(), file);
+    const shown2 = relative11(process.cwd(), file);
     print(renderDetect(report, shown2 && !shown2.startsWith("..") ? shown2 : file));
   }
   return 0;
 }
 async function cmdRender(values, positionals, io) {
-  const root = resolve12(values.root ?? values.project ?? process.cwd());
-  const targets = positionals.map((t) => existsSync5(resolve12(t)) ? resolve12(t) : t);
+  const root = resolve15(values.root ?? values.project ?? process.cwd());
+  const targets = positionals.map((t) => existsSync5(resolve15(t)) ? resolve15(t) : t);
   try {
     const report = await renderShots(root, targets, { ...values.base ? { base: values.base } : {}, ...process.env.YOUI_CHROMIUM ? { executablePath: process.env.YOUI_CHROMIUM } : {}, ...io.render });
-    if (values.json) json({ ...report, next: shotsNext(report, (t) => `run youiyoux render${t ? ` ${t}` : ""} again`) });
+    if (values.json) json3({ ...report, next: shotsNext(report, (t) => `run youiyoux render${t ? ` ${t}` : ""} again`) });
     else print(renderShots2(report));
     return targets.length > 0 && report.components.every((c) => c.shots.length === 0) ? 1 : 0;
   } catch (error) {
@@ -5048,20 +5764,20 @@ async function cmdRender(values, positionals, io) {
   }
 }
 async function product(values) {
-  const project2 = await loadProject(resolve12(values.project ?? process.cwd()), loadOptions(values)).catch(() => null);
-  return { project: project2, root: project2?.root ?? resolve12(values.root ?? values.project ?? process.cwd()) };
+  const project2 = await loadProject(resolve15(values.project ?? process.cwd()), loadOptions(values)).catch(() => null);
+  return { project: project2, root: project2?.root ?? resolve15(values.root ?? values.project ?? process.cwd()) };
 }
 async function cmdRequests(values, positionals) {
   const usage = "youiyoux requests [--status open|addressed|closed|all] [--route r]   or   youiyoux requests show <id> | reply <id> --message <text> | addressed <id> --message <what you changed>";
   const [action, id, ...rest] = positionals;
   if (rest.length > 0) throw new UsageError(usage);
-  const { RequestStore, requestBrief } = await import("./src-VKQJF7KR.js");
+  const { RequestStore, requestBrief } = await import("./src-EUVBYTKY.js");
   const { project: project2, root } = await product(values);
-  const store = new RequestStore(root, project2?.config.id ?? basename3(root));
+  const store = new RequestStore(root, project2?.config.id ?? basename5(root));
   const agent = { kind: "agent", name: "youiyoux CLI" };
   const one = (request) => {
     const brief = requestBrief(request, root);
-    if (values.json) json(brief);
+    if (values.json) json3(brief);
     else print(renderBrief(brief, true));
     return 0;
   };
@@ -5071,7 +5787,7 @@ async function cmdRequests(values, positionals) {
     if (!["open", "addressed", "closed", "all"].includes(status)) throw new UsageError("--status takes open, addressed, closed or all");
     const { requests, unreadable } = await store.list();
     const briefs = requests.filter((r) => (status === "all" || r.status === status) && (!values.route || r.target.route === values.route)).map((r) => requestBrief(r, root));
-    if (values.json) json({ requests: briefs, unreadable });
+    if (values.json) json3({ requests: briefs, unreadable });
     else print(renderRequests(briefs, status, unreadable));
     return unreadable.length ? 1 : 0;
   }
@@ -5087,22 +5803,22 @@ async function cmdScreens(values, positionals, io) {
   const usage = "youiyoux screens capture --base <url of the app in development> [--route <one route>] [--project dir] [--out <screens dir>] [--storage-state <signed-in session>] [--json]   or   youiyoux screens login --base <url> [--project dir] [--storage-state <file>]";
   if (!["capture", "login"].includes(positionals[0] ?? "") || positionals.length > 1 || !values.base) throw new UsageError(usage);
   const { root } = await product(values);
-  if (positionals[0] === "login") return screensLogin(values.base, values["storage-state"] ? resolve12(values["storage-state"]) : sessionFile(root), io);
-  const dir = resolve12(values.out ?? join22(root, ".youi/screens"));
-  if (!existsSync5(join22(dir, "screens.json"))) {
+  if (positionals[0] === "login") return screensLogin(values.base, values["storage-state"] ? resolve15(values["storage-state"]) : sessionFile(root), io);
+  const dir = resolve15(values.out ?? join25(root, ".youi/screens"));
+  if (!existsSync5(join25(dir, "screens.json"))) {
     process.stderr.write(`${style.error("\u2716")} no screens.json in ${dir}: list the routes to capture there, as {"schema":"youiyoux.screens/v1","project":"<name>","source":"<what the app is>","capturedAt":"","viewport":{"width":1440,"height":900},"screens":[{"route":"/","path":"/"}]}
 `);
     return 1;
   }
-  const session = chosenSession(root, values["storage-state"] ? resolve12(values["storage-state"]) : void 0);
+  const session = chosenSession(root, values["storage-state"] ? resolve15(values["storage-state"]) : void 0);
   if (session?.saved) process.stderr.write(`${style.dim(`signed in with the session youiyoux screens login saved (${session.file}); delete it to capture signed out`)}
 `);
-  const { launchBrowser } = await import("./src-YYI52B5R.js");
+  const { launchBrowser } = await import("./src-ZG7JU6YJ.js");
   const browser = await launchBrowser(process.env.YOUI_CHROMIUM, { purpose: { what: "youiyoux screens capture", command: "youiyoux screens capture" } });
   try {
     const report = await captureScreens(dir, { base: values.base, root, browser, ...values.route ? { routes: [values.route] } : {}, ...session ? { storageState: session.file } : {}, log: (line) => process.stderr.write(`${style.dim(line)}
 `) });
-    if (values.json) json(report);
+    if (values.json) json3(report);
     else print(captureText(report));
     return report.screens.every((s) => s.error) ? 1 : 0;
   } finally {
@@ -5154,7 +5870,7 @@ async function cmdReport(values, positionals, io) {
   return result.code;
 }
 async function cmdMcp(values) {
-  const { startStdioServer } = await import("./src-DZWWMUDR.js");
+  const { startStdioServer } = await import("./src-YKPJ3PII.js");
   await startStdioServer({ projectRoot: values.project ?? process.cwd(), ...loadOptions(values), ...values.cache ? { discoverCache: values.cache } : {} });
   return -1;
 }
@@ -5165,13 +5881,13 @@ function positiveInt(value, flag) {
   return n;
 }
 async function cmdDiscover(values, positionals, io) {
-  const cacheDir = resolve12(discoverCacheDir(values.cache));
+  const cacheDir = resolve15(discoverCacheDir(values.cache));
   const { path, home } = indexOf(values);
   const catalog = () => readCatalog(cacheDir, path);
   const [action, ...rest] = positionals;
   if (action === "sources") {
     const names = await selectSources(cacheDir, rest[0], rest[1]);
-    if (values.json) json(names);
+    if (values.json) json3(names);
     else print(names.join("\n"));
     return 0;
   }
@@ -5181,7 +5897,7 @@ async function cmdDiscover(values, positionals, io) {
     const summary = await syncIndex({ ...io.sleep ? { sleep: io.sleep } : {}, cacheDir, icons: values.icons ?? false, ...io.fetcher ? { fetcher: io.fetcher } : {}, ...io.timeoutMs ? { timeoutMs: io.timeoutMs } : {}, ...token ? { token } : {}, ...maxRegistries !== void 0 ? { maxRegistries } : {} });
     const loaded = await ingestCatalog(await sharedStore(path), cacheDir);
     await noteSource(home, { discover: cacheDir });
-    if (values.json) json(summary);
+    if (values.json) json3(summary);
     else print(`${renderDiscoverSync(summary)}
 ${style.dim(`store \u2192 ${storeLocation({ path })} (${plural(loaded.chosen, "listing")})`)}`);
     return 0;
@@ -5194,11 +5910,11 @@ ${style.dim(`store \u2192 ${storeLocation({ path })} (${plural(loaded.chosen, "l
   if (action === "show") {
     if (!rest[0]) throw new UsageError("youiyoux discover show <id|ref>");
     if (values.source) {
-      json(await candidateSource(cacheDir, rest.join(" "), io));
+      json3(await candidateSource(cacheDir, rest.join(" "), io));
       return 0;
     }
     const shown2 = await showFromCatalog(await catalog(), rest.join(" "));
-    if (values.json) json(shown2);
+    if (values.json) json3(shown2);
     else print(renderDiscoverShow(shown2));
     return 0;
   }
@@ -5211,11 +5927,14 @@ ${style.dim(`store \u2192 ${storeLocation({ path })} (${plural(loaded.chosen, "l
     await noteSource(home, { discover: cacheDir });
   }
   const result = await searchCatalog(await catalog(), need, { ...values.role ? { role: values.role } : {}, ...licenses?.length ? { constraints: { licenses } } : {}, limit: positiveInt(values.limit, "--limit") ?? 10, offset: positiveInt(values.offset, "--offset") ?? 0, all: values.all, facets: true });
-  if (values.json) json(result);
+  if (values.json) json3(result);
   else print(renderDiscoverSearch(result));
   return 0;
 }
 var COMMANDS = {
+  adopt: cmdAdopt,
+  status: cmdStatus,
+  system: cmdSystem,
   link: cmdLink,
   unlink: cmdUnlink,
   show: cmdShow,
@@ -5277,7 +5996,7 @@ ${HELP}
   }
   return guarded(() => handler(located(command2, parsed.values), rest, io));
 }
-var IN_A_PRODUCT = /* @__PURE__ */ new Set(["link", "unlink", "show", "where", "bom", "check", "baseline", "rules", "plan", "migrate", "sync", "scan", "watch", "hooks", "agents", "mcp", "ui", "library", "render", "screens", "requests"]);
+var IN_A_PRODUCT = /* @__PURE__ */ new Set(["system", "link", "unlink", "show", "where", "bom", "check", "baseline", "rules", "plan", "migrate", "sync", "scan", "watch", "hooks", "agents", "mcp", "ui", "library", "render", "screens", "requests"]);
 var IN_A_DESIGN_REPO = /* @__PURE__ */ new Set(["build", "parity"]);
 function located(command2, values, cwd = process.cwd()) {
   if (IN_A_PRODUCT.has(command2) && values.project === void 0 && values.config === void 0 && values.root === void 0) {