teamix-evo 0.3.1 → 0.4.1

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command24 } from "commander";
-import { createRequire as createRequire5 } from "module";
+import { Command as Command29 } from "commander";
+import { createRequire as createRequire7 } from "module";
 
-// src/commands/design/index.ts
+// src/commands/tokens/index.ts
 import { Command as Command6 } from "commander";
 
-// src/commands/design/init.ts
+// src/commands/tokens/init.ts
 import { Command } from "commander";
 
 // src/ide/QoderAdapter.ts
@@ -66,14 +66,13 @@ function detectIde() {
   return new QoderAdapter();
 }
 
-// src/core/design-init.ts
+// src/core/tokens-init.ts
 import * as path9 from "path";
 import * as fs6 from "fs/promises";
 import { createRequire as createRequire2 } from "module";
 import {
-  loadDesignPack,
-  loadDesignPackageManifest,
-  mergeDefaultAndVariant
+  loadTokensPackageManifest,
+  getVariantEntry
 } from "@teamix-evo/registry";
 
 // src/utils/fs.ts
@@ -158,71 +157,22 @@ function computeHash(content) {
   return `sha256:${hash}`;
 }
 
-// src/core/design-pack-classify.ts
-import * as path4 from "path";
-var TEAMIX_DIR = ".teamix-evo/design";
-var TOKENS_DIR = ".teamix-evo/tokens";
-var TOKENS_PACK_PREFIX = "foundations/tokens/";
-var ROOT_MANAGED_FILES = {
-  "DESIGN.md": { target: "DESIGN.md", managedRegions: ["core"] },
-  "AGENTS.md": { target: "AGENTS.md", managedRegions: ["teamix-evo"] },
-  "CLAUDE.md": { target: "CLAUDE.md", managedRegions: ["teamix-evo"] }
-};
-var FROZEN_FILES = /* @__PURE__ */ new Set([
-  "foundations/tokens/tokens.overrides.css"
-]);
-function classifyPackFile(relPath) {
-  if (path4.basename(relPath) === "README.md") {
-    return null;
-  }
-  const rootManaged = ROOT_MANAGED_FILES[relPath];
-  if (rootManaged) {
-    return {
-      target: rootManaged.target,
-      strategy: "managed",
-      managedRegions: rootManaged.managedRegions,
-      isFrozen: false
-    };
-  }
-  if (relPath.startsWith(TOKENS_PACK_PREFIX)) {
-    const rel2 = relPath.slice(TOKENS_PACK_PREFIX.length);
-    const target = path4.posix.join(TOKENS_DIR, rel2);
-    if (FROZEN_FILES.has(relPath)) {
-      return { target, strategy: "frozen", isFrozen: true };
-    }
-    return { target, strategy: "regenerable", isFrozen: false };
-  }
-  if (FROZEN_FILES.has(relPath)) {
-    return {
-      target: path4.posix.join(TEAMIX_DIR, relPath),
-      strategy: "frozen",
-      isFrozen: true
-    };
-  }
-  return {
-    target: path4.posix.join(TEAMIX_DIR, relPath),
-    strategy: "regenerable",
-    isFrozen: false
-  };
-}
-
 // src/core/state.ts
-import * as path5 from "path";
+import * as path4 from "path";
 import {
   validateConfig,
   validateInstalled,
   validateSkillsLock,
-  DesignPackLockSchema
+  TokensPackLockSchema
 } from "@teamix-evo/registry";
-var TEAMIX_DIR2 = ".teamix-evo";
+var TEAMIX_DIR = ".teamix-evo";
 var CONFIG_FILE = "config.json";
 var MANIFEST_FILE = "manifest.json";
-var DESIGN_DIR = "design";
-var DESIGN_LOCK_FILE = "pack.lock.json";
+var TOKENS_LOCK_FILE = "tokens-lock.json";
 var SKILLS_DIR = "skills";
 var SKILLS_LOCK_FILE = "manifest.lock.json";
 function getTeamixDir(projectRoot) {
-  return path5.join(projectRoot, TEAMIX_DIR2);
+  return path4.join(projectRoot, TEAMIX_DIR);
 }
 async function ensureTeamixDir(projectRoot) {
   const dir = getTeamixDir(projectRoot);
@@ -230,84 +180,85 @@ async function ensureTeamixDir(projectRoot) {
   return dir;
 }
 async function readProjectConfig(projectRoot) {
-  const configPath = path5.join(projectRoot, TEAMIX_DIR2, CONFIG_FILE);
+  const configPath = path4.join(projectRoot, TEAMIX_DIR, CONFIG_FILE);
   const raw = await readFileOrNull(configPath);
   if (raw === null) return null;
+  let data;
   try {
-    const data = JSON.parse(raw);
-    const result = validateConfig(data);
-    if (!result.success) {
-      logger.warn(`Invalid config.json: ${result.error}`);
-      return null;
-    }
-    return result.data;
+    data = JSON.parse(raw);
   } catch (err) {
-    logger.warn(`Failed to parse config.json: ${err.message}`);
-    return null;
+    throw new Error(
+      `Corrupted config.json (${err.message}). Fix the JSON manually or remove the file to start fresh; refusing to clobber prior config.`
+    );
+  }
+  const result = validateConfig(data);
+  if (!result.success) {
+    throw new Error(
+      `Invalid config.json schema: ${result.error}. Fix the file manually or remove it to start fresh.`
+    );
   }
+  return result.data;
 }
 async function writeProjectConfig(projectRoot, config) {
-  const configPath = path5.join(projectRoot, TEAMIX_DIR2, CONFIG_FILE);
+  const configPath = path4.join(projectRoot, TEAMIX_DIR, CONFIG_FILE);
   await writeFileSafe(configPath, JSON.stringify(config, null, 2) + "\n");
   logger.debug(`Wrote config \u2192 ${configPath}`);
 }
 async function readInstalledManifest(projectRoot) {
-  const manifestPath = path5.join(projectRoot, TEAMIX_DIR2, MANIFEST_FILE);
+  const manifestPath = path4.join(projectRoot, TEAMIX_DIR, MANIFEST_FILE);
   const raw = await readFileOrNull(manifestPath);
   if (raw === null) return null;
+  let data;
   try {
-    const data = JSON.parse(raw);
-    const result = validateInstalled(data);
-    if (!result.success) {
-      logger.warn(`Invalid manifest.json: ${result.error}`);
-      return null;
-    }
-    return result.data;
+    data = JSON.parse(raw);
   } catch (err) {
-    logger.warn(`Failed to parse manifest.json: ${err.message}`);
-    return null;
+    throw new Error(
+      `Corrupted manifest.json (${err.message}). Fix the JSON manually or remove the file to start fresh; refusing to clobber prior install records.`
+    );
+  }
+  const result = validateInstalled(data);
+  if (!result.success) {
+    throw new Error(
+      `Invalid manifest.json schema: ${result.error}. Fix the file manually or remove it to start fresh.`
+    );
   }
+  return result.data;
 }
 async function writeInstalledManifest(projectRoot, manifest) {
-  const manifestPath = path5.join(projectRoot, TEAMIX_DIR2, MANIFEST_FILE);
+  const manifestPath = path4.join(projectRoot, TEAMIX_DIR, MANIFEST_FILE);
   await writeFileSafe(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
   logger.debug(`Wrote manifest \u2192 ${manifestPath}`);
 }
-async function readDesignPackLock(projectRoot) {
-  const lockPath = path5.join(
-    projectRoot,
-    TEAMIX_DIR2,
-    DESIGN_DIR,
-    DESIGN_LOCK_FILE
-  );
+async function readTokensLock(projectRoot) {
+  const lockPath = path4.join(projectRoot, TEAMIX_DIR, TOKENS_LOCK_FILE);
   const raw = await readFileOrNull(lockPath);
   if (raw === null) return null;
   try {
-    const parsed = DesignPackLockSchema.safeParse(JSON.parse(raw));
+    const parsed = TokensPackLockSchema.safeParse(JSON.parse(raw));
     if (!parsed.success) {
-      logger.warn(`Invalid design pack.lock.json: ${parsed.error.message}`);
+      logger.warn(`Invalid tokens-lock.json: ${parsed.error.message}`);
       return null;
     }
     return parsed.data;
   } catch (err) {
     logger.warn(
-      `Failed to parse design pack.lock.json: ${err.message}`
+      `Failed to parse tokens-lock.json: ${err.message}`
     );
     return null;
   }
 }
-async function readDesignVariant(projectRoot) {
-  const lock = await readDesignPackLock(projectRoot);
+async function readTokensVariant(projectRoot) {
+  const lock = await readTokensLock(projectRoot);
   return lock?.variant.name ?? null;
 }
 function getSkillsSourceDir(projectRoot, skillName) {
-  const base = path5.join(projectRoot, TEAMIX_DIR2, SKILLS_DIR);
-  return skillName ? path5.join(base, skillName) : base;
+  const base = path4.join(projectRoot, TEAMIX_DIR, SKILLS_DIR);
+  return skillName ? path4.join(base, skillName) : base;
 }
 async function readSkillsLock(projectRoot) {
-  const lockPath = path5.join(
+  const lockPath = path4.join(
     projectRoot,
-    TEAMIX_DIR2,
+    TEAMIX_DIR,
     SKILLS_DIR,
     SKILLS_LOCK_FILE
   );
@@ -329,9 +280,9 @@ async function readSkillsLock(projectRoot) {
   }
 }
 async function writeSkillsLock(projectRoot, lock) {
-  const lockPath = path5.join(
+  const lockPath = path4.join(
     projectRoot,
-    TEAMIX_DIR2,
+    TEAMIX_DIR,
     SKILLS_DIR,
     SKILLS_LOCK_FILE
   );
@@ -340,21 +291,21 @@ async function writeSkillsLock(projectRoot, lock) {
 }
 
 // src/core/skills-client.ts
-import * as path6 from "path";
+import * as path5 from "path";
 import * as fs2 from "fs/promises";
 import { createRequire } from "module";
 import { loadSkillsPackageManifest } from "@teamix-evo/registry";
 var require2 = createRequire(import.meta.url);
 function resolvePackageRoot(packageName) {
   const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
-  return path6.dirname(pkgJsonPath);
+  return path5.dirname(pkgJsonPath);
 }
 async function loadSkillsData(packageName) {
   const packageRoot = resolvePackageRoot(packageName);
   logger.debug(`Resolved skills package root: ${packageRoot}`);
   const manifest = await loadSkillsPackageManifest(packageRoot);
   let data = {};
-  const dataPath = path6.join(packageRoot, "_data.json");
+  const dataPath = path5.join(packageRoot, "_data.json");
   try {
     const raw = await fs2.readFile(dataPath, "utf-8");
     data = JSON.parse(raw);
@@ -368,9 +319,12 @@ async function loadSkillsData(packageName) {
 }
 
 // src/core/skills-installer.ts
-import * as path8 from "path";
+import * as path7 from "path";
 import * as fs5 from "fs/promises";
-import { replaceManagedRegion } from "@teamix-evo/registry";
+import {
+  replaceManagedRegion,
+  hasManagedRegion
+} from "@teamix-evo/registry";
 
 // src/utils/template.ts
 import Handlebars from "handlebars";
@@ -401,13 +355,13 @@ async function loadTemplateFile(filePath) {
 }
 
 // src/utils/path.ts
-import * as path7 from "path";
+import * as path6 from "path";
 import * as fs4 from "fs/promises";
 async function walkDir(dir) {
   const files = [];
   const entries = await fs4.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path7.join(dir, entry.name);
+    const fullPath = path6.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walkDir(fullPath));
     } else if (entry.isFile()) {
@@ -450,12 +404,12 @@ async function installSkills(options) {
 }
 async function writeSkillSource(skill, options) {
   const { data, packageRoot, projectRoot } = options;
-  const sourceAbs = path8.resolve(packageRoot, skill.source);
+  const sourceAbs = path7.resolve(packageRoot, skill.source);
   const targetDir = getSkillsSourceDir(projectRoot, skill.name);
   const stat4 = await fs5.stat(sourceAbs);
   const records = [];
   if (stat4.isFile()) {
-    const targetFile = path8.join(targetDir, "SKILL.md");
+    const targetFile = path7.join(targetDir, "SKILL.md");
     const content = await renderSkillContent(sourceAbs, skill, data);
     await writeFileSafe(targetFile, content);
     records.push(makeSourceRecord(skill, targetFile, content));
@@ -465,14 +419,14 @@ async function writeSkillSource(skill, options) {
   await ensureDir(targetDir);
   const entries = await walkDir(sourceAbs);
   for (const entry of entries) {
-    const rel2 = path8.relative(sourceAbs, entry);
-    let targetFile = path8.join(targetDir, rel2);
+    const rel2 = path7.relative(sourceAbs, entry);
+    let targetFile = path7.join(targetDir, rel2);
     if (skill.template && targetFile.endsWith(".hbs")) {
       targetFile = targetFile.slice(0, -4);
     }
     const content = skill.template && entry.endsWith(".hbs") ? renderTemplate(await loadTemplateFile(entry), { ...data, skill }) : await fs5.readFile(entry, "utf-8");
     await writeFileSafe(targetFile, content);
-    const relWritten = path8.relative(targetDir, targetFile);
+    const relWritten = path7.relative(targetDir, targetFile);
     records.push(makeSourceRecord(skill, targetFile, content, relWritten));
     logger.debug(`  Wrote source: ${targetFile}`);
   }
@@ -486,15 +440,66 @@ async function mirrorSkillToIde(skill, ide, scope, projectRoot) {
   const sourceFiles = await walkDir(sourceDir);
   await ensureDir(targetDir);
   for (const src of sourceFiles) {
-    const rel2 = path8.relative(sourceDir, src);
-    const targetFile = path8.join(targetDir, rel2);
-    const content = await fs5.readFile(src, "utf-8");
-    await writeFileSafe(targetFile, content);
-    records.push(makeMirrorRecord(skill, targetFile, content, ide, scope, rel2));
+    const rel2 = path7.relative(sourceDir, src);
+    const targetFile = path7.join(targetDir, rel2);
+    const sourceContent = await fs5.readFile(src, "utf-8");
+    const writtenContent = await writeMirrorContent(
+      targetFile,
+      sourceContent,
+      skill.managedRegions,
+      src
+    );
+    records.push(
+      makeMirrorRecord(skill, targetFile, writtenContent, ide, scope, rel2)
+    );
     logger.debug(`  Mirrored ${ide}:${scope}: ${targetFile}`);
   }
   return records;
 }
+async function writeMirrorContent(targetFile, sourceContent, managedRegions, sourceFile) {
+  const existing = await readFileOrNull(targetFile);
+  if (existing === null) {
+    await writeFileSafe(targetFile, sourceContent);
+    return sourceContent;
+  }
+  const regions = managedRegions ?? [];
+  const matchedRegions = regions.filter((id) => hasManagedRegion(existing, id));
+  if (matchedRegions.length === 0) {
+    if (existing !== sourceContent) {
+      logger.warn(
+        `Mirror drift detected at ${targetFile} \u2014 overwriting from source. Edit ${sourceFile} (not the mirror) and re-run \`teamix-evo skills sync\`.`
+      );
+      await writeFileSafe(targetFile, sourceContent);
+      return sourceContent;
+    }
+    return existing;
+  }
+  let merged = existing;
+  for (const id of matchedRegions) {
+    const newRegion = extractRegionBody(sourceContent, id);
+    if (newRegion === null) continue;
+    try {
+      merged = replaceManagedRegion(merged, id, newRegion);
+    } catch {
+    }
+  }
+  if (merged !== existing) {
+    await writeFileSafe(targetFile, merged);
+  }
+  return merged;
+}
+function extractRegionBody(content, id) {
+  const re = new RegExp(
+    `<!-- teamix-evo:managed:start id="${escapeRegExp(
+      id
+    )}" -->([\\s\\S]*?)<!-- teamix-evo:managed:end id="${escapeRegExp(
+      id
+    )}" -->`
+  );
+  const m = content.match(re);
+  if (!m) return null;
+  return m[1].replace(/^\n/, "").replace(/\n$/, "");
+}
 async function renderSkillContent(sourceAbs, skill, data) {
   if (skill.template ?? sourceAbs.endsWith(".hbs")) {
     const tpl = await loadTemplateFile(sourceAbs);
@@ -549,7 +554,7 @@ async function updateSkills(options) {
 }
 async function rewriteSkillSource(skill, options, summary) {
   const { data, packageRoot, projectRoot } = options;
-  const sourceAbs = path8.resolve(packageRoot, skill.source);
+  const sourceAbs = path7.resolve(packageRoot, skill.source);
   const targetDir = getSkillsSourceDir(projectRoot, skill.name);
   const stat4 = await fs5.stat(sourceAbs);
   if (!stat4.isFile()) {
@@ -557,8 +562,8 @@ async function rewriteSkillSource(skill, options, summary) {
     const entries = await walkDir(sourceAbs);
     const records = [];
     for (const entry of entries) {
-      const rel2 = path8.relative(sourceAbs, entry);
-      let targetFile2 = path8.join(targetDir, rel2);
+      const rel2 = path7.relative(sourceAbs, entry);
+      let targetFile2 = path7.join(targetDir, rel2);
       if (skill.template && targetFile2.endsWith(".hbs")) {
         targetFile2 = targetFile2.slice(0, -4);
       }
@@ -571,12 +576,12 @@ async function rewriteSkillSource(skill, options, summary) {
         summary.created++;
       }
       await writeFileSafe(targetFile2, content);
-      const relWritten = path8.relative(targetDir, targetFile2);
+      const relWritten = path7.relative(targetDir, targetFile2);
       records.push(makeSourceRecord(skill, targetFile2, content, relWritten));
     }
     return records;
   }
-  const targetFile = path8.join(targetDir, "SKILL.md");
+  const targetFile = path7.join(targetDir, "SKILL.md");
   const newContent = await renderSkillContent(sourceAbs, skill, data);
   const exists = await fileExists(targetFile);
   if (skill.updateStrategy === "frozen") {
@@ -651,14 +656,19 @@ async function syncSkillsToIdes(options) {
       await ensureDir(targetDir);
       const sourceFiles = await walkDir(sourceDir);
       for (const src of sourceFiles) {
-        const rel2 = path8.relative(sourceDir, src);
-        const targetFile = path8.join(targetDir, rel2);
-        const content = await fs5.readFile(src, "utf-8");
-        await writeFileSafe(targetFile, content);
+        const rel2 = path7.relative(sourceDir, src);
+        const targetFile = path7.join(targetDir, rel2);
+        const sourceContent = await fs5.readFile(src, "utf-8");
+        const writtenContent = await writeMirrorContent(
+          targetFile,
+          sourceContent,
+          skill.managedRegions,
+          src
+        );
         out.push({
           id: rel2 === "SKILL.md" ? skill.id : `${skill.id}:${rel2}`,
           target: targetFile,
-          hash: computeHash(content),
+          hash: computeHash(writtenContent),
           strategy: skill.updateStrategy,
           ide,
           scope
@@ -680,17 +690,46 @@ async function removeSkillFiles(records) {
       }
     }
   }
-  const parents = new Set(records.map((r) => path8.dirname(r.target)));
-  for (const dir of parents) {
-    try {
-      const entries = await fs5.readdir(dir);
-      if (entries.length === 0) await fs5.rmdir(dir);
-    } catch {
+  const startDirs = new Set(records.map((r) => path7.dirname(r.target)));
+  for (const startDir of startDirs) {
+    let dir = startDir;
+    for (let depth = 0; depth < 8; depth++) {
+      try {
+        const entries = await fs5.readdir(dir);
+        if (entries.length !== 0) break;
+        await fs5.rmdir(dir);
+      } catch {
+        break;
+      }
+      dir = path7.dirname(dir);
     }
   }
   return removed;
 }
 
+// src/utils/mcp.ts
+import * as path8 from "path";
+var MCP_JSON_CONTENT = {
+  mcpServers: {
+    "teamix-evo": {
+      command: "npx",
+      args: ["-y", "@teamix-evo/mcp"]
+    }
+  }
+};
+async function ensureMcpJson(projectRoot) {
+  const mcpPath = path8.join(projectRoot, ".mcp.json");
+  if (await fileExists(mcpPath)) return "exists";
+  try {
+    await writeFileSafe(mcpPath, JSON.stringify(MCP_JSON_CONTENT, null, 2) + "\n");
+    logger.debug(`Wrote .mcp.json \u2192 ${mcpPath}`);
+    return "created";
+  } catch (err) {
+    logger.warn(`Failed to write .mcp.json: ${err.message}`);
+    return "failed";
+  }
+}
+
 // src/core/skills-add.ts
 var DEFAULT_SKILLS_PACKAGE = "@teamix-evo/skills";
 var FLAT_VARIANT = "_flat";
@@ -702,9 +741,6 @@ async function runSkillsAdd(options) {
   await ensureTeamixDir(projectRoot);
   const existingConfig = await readProjectConfig(projectRoot);
   const existingSkillsCfg = existingConfig?.packages?.skills;
-  if (!isIncremental && existingSkillsCfg) {
-    return { status: "already-added" };
-  }
   const ides = options.ides && options.ides.length > 0 ? [...options.ides] : existingSkillsCfg?.ides ? [...existingSkillsCfg.ides] : [];
   const scope = options.scope ?? existingSkillsCfg?.scope;
   if (ides.length === 0) {
@@ -714,7 +750,7 @@ async function runSkillsAdd(options) {
     throw new Error("Scope must be specified (project | global).");
   }
   const { manifest, data, packageRoot } = await loadSkillsData(packageName);
-  const currentDesignVariant = await readDesignVariant(projectRoot);
+  const currentTokensVariant = await readTokensVariant(projectRoot);
   if (isIncremental) {
     const known = new Set(manifest.skills.map((s) => s.id));
     const unknown = requestedNames.filter((n) => !known.has(n));
@@ -742,23 +778,27 @@ async function runSkillsAdd(options) {
     skippedSkillIds = requestedNames.filter((n) => existingSkillIds.has(n));
     onlyIds = requestedNames.filter((n) => !existingSkillIds.has(n));
   } else {
-    skippedSkillIds = [];
-    onlyIds = manifest.skills.filter((s) => {
+    const candidateIds = manifest.skills.filter((s) => {
       if (!s.variant) return true;
-      if (!currentDesignVariant) {
+      if (!currentTokensVariant) {
         logger.debug(
-          `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): no design pack installed; will be picked up when "design init" runs.`
+          `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): no tokens variant installed; will be picked up when "tokens init" runs.`
         );
         return false;
       }
-      if (s.variant !== currentDesignVariant) {
+      if (s.variant !== currentTokensVariant) {
         logger.debug(
-          `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): current design variant is "${currentDesignVariant}".`
+          `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): current tokens variant is "${currentTokensVariant}".`
         );
         return false;
       }
       return true;
     }).map((s) => s.id);
+    skippedSkillIds = candidateIds.filter((id) => existingSkillIds.has(id));
+    onlyIds = candidateIds.filter((id) => !existingSkillIds.has(id));
+  }
+  if (!isIncremental && existingSkillsCfg && onlyIds.length === 0) {
+    return { status: "already-added" };
   }
   if (isIncremental && onlyIds.length === 0) {
     return {
@@ -835,6 +875,7 @@ async function runSkillsAdd(options) {
     };
   }
   await writeSkillsLock(projectRoot, lock);
+  await ensureMcpJson(projectRoot);
   return {
     status: "installed",
     packageName,
@@ -856,85 +897,110 @@ function mergeInstalledResources(existing, next) {
   return [...map.values()];
 }
 
-// src/core/design-init.ts
-var BASELINE_DESIGN_RULES_SKILL = "teamix-evo-design-rules";
+// src/core/tokens-init.ts
 var DEFAULT_SKILLS_PACKAGE2 = "@teamix-evo/skills";
 var DEFAULT_AUTO_SKILL_IDES = ["qoder", "claude"];
 var DEFAULT_AUTO_SKILL_SCOPE = "project";
-var DEFAULT_DESIGN_PACKAGE = "@teamix-evo/design";
+var DEFAULT_TOKENS_PACKAGE = "@teamix-evo/tokens";
+var CONSUMER_TOKENS_DIR = "tokens";
+var CONSUMER_THEME_FILE = "tokens.theme.css";
+var CONSUMER_OVERRIDES_FILE = "tokens.overrides.css";
+var EMPTY_OVERRIDES_TEMPLATE = `/* User-owned token overrides \u2014 frozen on subsequent installs. */
+/* See @teamix-evo/tokens variant theme.css for available CSS custom properties. */
+`;
 var require3 = createRequire2(import.meta.url);
-async function runDesignInit(options) {
+async function runTokensInit(options) {
   const { projectRoot, variant, ide } = options;
-  const packageName = options.packageName ?? DEFAULT_DESIGN_PACKAGE;
+  const packageName = options.packageName ?? DEFAULT_TOKENS_PACKAGE;
   await ensureTeamixDir(projectRoot);
-  const existingConfig = await readProjectConfig(projectRoot);
-  if (existingConfig?.packages?.design) {
-    return {
-      status: "already-initialized",
-      existingVariant: existingConfig.packages.design.variant
-    };
-  }
-  const packageRoot = options.packageRoot ?? resolveDesignPackageRoot(packageName);
-  const catalog = await loadDesignPackageManifest(packageRoot);
-  const variantEntry = catalog.variants.find((v) => v.name === variant);
+  const packageRoot = options.packageRoot ?? resolveTokensPackageRoot(packageName);
+  const catalog = await loadTokensPackageManifest(packageRoot);
+  const variantEntry = getVariantEntry(catalog, variant);
   if (!variantEntry) {
     const known = catalog.variants.map((v) => v.name).join(", ");
     throw new Error(
-      `Design variant not found: "${variant}". Known variants: ${known || "(none)"}. Hint: run "teamix-evo design list-variants" to see all.`
+      `Unknown variant "${variant}". Available variants: ${known || "(none)"}.
+Run \`teamix-evo tokens list-variants\` to see all options.`
     );
   }
-  const defaultDir = path9.join(packageRoot, "default");
-  const variantDir = path9.join(packageRoot, "variants", variant);
-  const defaultPack = await loadDesignPack(defaultDir);
-  const variantPack = await loadDesignPack(variantDir);
-  const merge = await mergeDefaultAndVariant(defaultDir, variantDir);
+  const existingConfig = await readProjectConfig(projectRoot);
+  if (existingConfig?.packages?.tokens) {
+    const existingVariant = existingConfig.packages.tokens.variant;
+    if (existingVariant === variant) {
+      return { status: "already-initialized", existingVariant };
+    }
+    return {
+      status: "variant-mismatch",
+      existingVariant,
+      requestedVariant: variant
+    };
+  }
   const installed = [];
-  for (const file of merge.files) {
-    const result = await installPackFile(file, projectRoot);
+  for (const fileRel of variantEntry.files) {
+    const result = await installVariantFile(fileRel, packageRoot, projectRoot);
     if (result) installed.push(result);
   }
+  const overridesAbs = path9.join(
+    projectRoot,
+    CONSUMER_TOKENS_DIR,
+    CONSUMER_OVERRIDES_FILE
+  );
+  if (!await fileExists(overridesAbs)) {
+    await writeFileSafe(overridesAbs, EMPTY_OVERRIDES_TEMPLATE);
+  }
+  const overridesContent = await fs6.readFile(overridesAbs, "utf-8");
+  installed.push({
+    id: `tokens:${CONSUMER_OVERRIDES_FILE}`,
+    target: path9.posix.join(CONSUMER_TOKENS_DIR, CONSUMER_OVERRIDES_FILE),
+    hash: computeHash(overridesContent),
+    strategy: "frozen"
+  });
   const lock = {
     schemaVersion: 1,
-    default: { version: defaultPack.version, from: packageName },
     variant: {
-      name: variantPack.name,
-      displayName: variantPack.displayName,
-      version: variantPack.version,
+      name: variantEntry.name,
+      displayName: variantEntry.displayName,
+      version: variantEntry.version,
       from: packageName
     },
-    linked: variantPack.linked,
+    packageVersion: catalog.version,
+    linked: variantEntry.linked,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   await writeFileSafe(
-    path9.join(projectRoot, ".teamix-evo", "design", "pack.lock.json"),
+    path9.join(projectRoot, ".teamix-evo", "tokens-lock.json"),
     JSON.stringify(lock, null, 2) + "\n"
   );
   const config = {
     $schema: "https://teamix-evo.dev/schema/config/v1.json",
     schemaVersion: 1,
-    ide,
+    ide: existingConfig?.ide ?? ide,
     packages: {
-      design: {
+      ...existingConfig?.packages ?? {},
+      tokens: {
         variant,
-        version: variantPack.version,
+        version: variantEntry.version,
         tailwind: "v4"
       }
     }
   };
   await writeProjectConfig(projectRoot, config);
-  const installedManifest = {
+  const prior = await readInstalledManifest(projectRoot) ?? {
     schemaVersion: 1,
-    installed: [
-      {
-        package: packageName,
-        variant,
-        version: variantPack.version,
-        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        resources: installed
-      }
-    ]
+    installed: []
   };
-  await writeInstalledManifest(projectRoot, installedManifest);
+  const tokensIdx = prior.installed.findIndex((p) => p.package === packageName);
+  const tokensEntry = {
+    package: packageName,
+    variant,
+    version: variantEntry.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resources: installed
+  };
+  if (tokensIdx >= 0) prior.installed[tokensIdx] = tokensEntry;
+  else prior.installed.push(tokensEntry);
+  await writeInstalledManifest(projectRoot, prior);
+  await ensureMcpJson(projectRoot);
   const skills = await tryAutoInstallVariantSkills({
     projectRoot,
     variant,
@@ -944,21 +1010,16 @@ async function runDesignInit(options) {
     status: "installed",
     packageName,
     variant,
-    version: variantPack.version,
+    version: variantEntry.version,
     count: installed.length,
     resources: installed,
-    merge: {
-      overrides: merge.overrides,
-      variantAdds: merge.variantAdds,
-      defaultPassThrough: merge.defaultPassThrough
-    },
     skills
   };
 }
 async function tryAutoInstallVariantSkills(args) {
   const { projectRoot, variant, ide } = args;
-  const variantSkillId = `${BASELINE_DESIGN_RULES_SKILL}-${variant}`;
-  const desired = [BASELINE_DESIGN_RULES_SKILL, variantSkillId];
+  const variantSkillId = `teamix-evo-design-${variant}`;
+  const desired = [variantSkillId];
   let manifestSkillIds;
   try {
     const { manifest } = await loadSkillsData(DEFAULT_SKILLS_PACKAGE2);
@@ -978,7 +1039,9 @@ async function tryAutoInstallVariantSkills(args) {
   const missing = desired.filter((id) => !manifestSkillIds.has(id));
   if (missing.length > 0) {
     logger.warn(
-      `Skills auto-install: not found in manifest, skipping: ${missing.join(", ")}.`
+      `Skills auto-install: not found in manifest, skipping: ${missing.join(
+        ", "
+      )}.`
     );
   }
   if (present.length === 0) {
@@ -1023,38 +1086,60 @@ async function tryAutoInstallVariantSkills(args) {
     };
   }
 }
-async function installPackFile(file, projectRoot) {
-  const cls = classifyPackFile(file.relPath);
-  if (cls === null) return null;
-  const targetAbs = path9.join(projectRoot, cls.target);
-  if (cls.isFrozen && await fileExists(targetAbs)) {
-    const existing = await fs6.readFile(targetAbs, "utf-8");
+async function installVariantFile(fileRelToPackage, packageRoot, projectRoot) {
+  const sourceAbs = path9.join(packageRoot, fileRelToPackage);
+  const base = path9.basename(fileRelToPackage);
+  if (base === "theme.css") {
+    const targetRel = path9.posix.join(
+      CONSUMER_TOKENS_DIR,
+      CONSUMER_THEME_FILE
+    );
+    const targetAbs = path9.join(projectRoot, targetRel);
+    const content = await fs6.readFile(sourceAbs, "utf-8");
+    await writeFileSafe(targetAbs, content);
     return {
-      id: `pack:${file.relPath}`,
-      target: cls.target,
-      hash: computeHash(existing),
-      strategy: cls.strategy
+      id: `tokens:${CONSUMER_THEME_FILE}`,
+      target: targetRel,
+      hash: computeHash(content),
+      strategy: "regenerable"
     };
   }
-  const content = await fs6.readFile(file.sourcePath, "utf-8");
-  await writeFileSafe(targetAbs, content);
-  return {
-    id: `pack:${file.relPath}`,
-    target: cls.target,
-    hash: computeHash(content),
-    strategy: cls.strategy
-  };
+  if (base === "overrides.css" || base === "tokens.overrides.css") {
+    const targetRel = path9.posix.join(
+      CONSUMER_TOKENS_DIR,
+      CONSUMER_OVERRIDES_FILE
+    );
+    const targetAbs = path9.join(projectRoot, targetRel);
+    if (await fileExists(targetAbs)) {
+      const existing = await fs6.readFile(targetAbs, "utf-8");
+      return {
+        id: `tokens:${CONSUMER_OVERRIDES_FILE}`,
+        target: targetRel,
+        hash: computeHash(existing),
+        strategy: "frozen"
+      };
+    }
+    const content = await fs6.readFile(sourceAbs, "utf-8");
+    await writeFileSafe(targetAbs, content);
+    return {
+      id: `tokens:${CONSUMER_OVERRIDES_FILE}`,
+      target: targetRel,
+      hash: computeHash(content),
+      strategy: "frozen"
+    };
+  }
+  return null;
 }
-function resolveDesignPackageRoot(packageName) {
+function resolveTokensPackageRoot(packageName) {
   const pkgJson = require3.resolve(`${packageName}/package.json`);
   return path9.dirname(pkgJson);
 }
-async function listDesignVariants(packageName = DEFAULT_DESIGN_PACKAGE, packageRoot) {
-  const root = packageRoot ?? resolveDesignPackageRoot(packageName);
-  const catalog = await loadDesignPackageManifest(root);
+async function listTokenVariants(packageName = DEFAULT_TOKENS_PACKAGE, packageRoot) {
+  const root = packageRoot ?? resolveTokensPackageRoot(packageName);
+  const catalog = await loadTokensPackageManifest(root);
   return {
     packageName,
-    defaultDescription: catalog.default.description,
+    packageVersion: catalog.version,
     variants: catalog.variants.map((v) => ({
       name: v.name,
       displayName: v.displayName,
@@ -1065,25 +1150,73 @@ async function listDesignVariants(packageName = DEFAULT_DESIGN_PACKAGE, packageR
   };
 }
 
-// src/commands/design/init.ts
+// src/utils/global-root.ts
+import { existsSync } from "fs";
+import * as fs7 from "fs/promises";
+import * as os3 from "os";
+import * as path10 from "path";
+var GLOBAL_META_DIR = ".teamix-evo-global";
+var TEAMIX_DIR2 = ".teamix-evo";
+var CONFIG_FILE2 = "config.json";
+function getGlobalMetaRoot() {
+  return path10.join(os3.homedir(), GLOBAL_META_DIR);
+}
+function isTeamixEvoProject(dir) {
+  return existsSync(path10.join(dir, TEAMIX_DIR2, CONFIG_FILE2));
+}
+async function ensureGlobalMetaRoot() {
+  const root = getGlobalMetaRoot();
+  await fs7.mkdir(root, { recursive: true });
+  return root;
+}
+function hasPackageJson(projectRoot) {
+  return existsSync(path10.join(projectRoot, "package.json"));
+}
+function resolveSkillsMaintenanceRoot(cwd) {
+  if (isTeamixEvoProject(cwd)) return cwd;
+  const globalRoot = getGlobalMetaRoot();
+  if (isTeamixEvoProject(globalRoot)) return globalRoot;
+  return cwd;
+}
+
+// src/commands/tokens/init.ts
 var initCommand = new Command("init").description("\u521D\u59CB\u5316\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90\uFF08\u5FC5\u987B\u663E\u5F0F\u6307\u5B9A\u4E1A\u52A1\u53D8\u4F53\uFF09").argument("<variant>", '\u4E1A\u52A1\u53D8\u4F53\u540D\u79F0\uFF08\u5982 "opentrek"\u3001"uni-manager"\uFF09').action(async (variant) => {
   try {
     const ide = detectIde();
     const projectRoot = ide.getProjectRoot();
+    if (!hasPackageJson(projectRoot)) {
+      logger.error(
+        "No package.json found in current directory. Please run this command in a valid project root."
+      );
+      process.exit(1);
+    }
     logger.info(`Initializing design system: variant="${variant}"`);
     logger.debug(`Project root: ${projectRoot}`);
     logger.debug(`IDE: ${ide.name}`);
     logger.info(`Loading variant "${variant}"...`);
     logger.info("Installing resources...");
-    const result = await runDesignInit({
+    const result = await runTokensInit({
       projectRoot,
       variant,
       ide: ide.name
     });
     if (result.status === "already-initialized") {
-      logger.warn(
-        `Design system already initialized (variant: ${result.existingVariant}). Use "teamix-evo design update" to update.`
+      logger.info(
+        `Design system already initialized (variant: ${result.existingVariant}). Use "teamix-evo tokens update" to refresh resources.`
+      );
+      return;
+    }
+    if (result.status === "variant-mismatch") {
+      logger.error(
+        `Cannot switch tokens variant in place. Currently installed: "${result.existingVariant}"; requested: "${result.requestedVariant}".`
+      );
+      logger.info("To switch variants:");
+      logger.info("  1. teamix-evo tokens uninstall --yes");
+      logger.info(`  2. teamix-evo tokens init ${result.requestedVariant}`);
+      logger.info(
+        "Note: tokens.overrides.css (frozen) is preserved across uninstall/init by default."
       );
+      process.exitCode = 1;
       return;
     }
     logger.success(
@@ -1092,9 +1225,6 @@ var initCommand = new Command("init").description("\u521D\u59CB\u5316\u8BBE\u8BA
     logger.info(`  Variant:  ${result.variant}`);
     logger.info(`  Tailwind: v4`);
     logger.info(`  Resources: ${result.count} files installed`);
-    logger.info(
-      `  Merge:    ${result.merge.overrides.length} overrides / ${result.merge.variantAdds.length} variant-only / ${result.merge.defaultPassThrough.length} default-passthrough`
-    );
     if (result.skills) {
       const { addedSkillIds, skippedSkillIds, missing } = result.skills;
       if (addedSkillIds.length > 0) {
@@ -1114,9 +1244,9 @@ var initCommand = new Command("init").description("\u521D\u59CB\u5316\u8BBE\u8BA
       }
     }
     logger.info("");
-    logger.info('Run "teamix-evo design update" to update resources later.');
+    logger.info('Run "teamix-evo tokens update" to update resources later.');
     logger.info(
-      'Run "teamix-evo design list-variants" to see all available variants.'
+      'Run "teamix-evo tokens list-variants" to see all available variants.'
     );
   } catch (err) {
     logger.error(`Failed to initialize: ${err.message}`);
@@ -1125,43 +1255,191 @@ var initCommand = new Command("init").description("\u521D\u59CB\u5316\u8BBE\u8BA
   }
 });
 
-// src/commands/design/update.ts
+// src/commands/tokens/update.ts
 import { Command as Command2 } from "commander";
-var updateCommand = new Command2("update").description("(v0.7) \u66F4\u65B0\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90 \u2014 \u5F53\u524D\u672A\u5B9E\u73B0,\u89C1 ADR 0010 / PLAN \xA712.6").action(() => {
-  logger.warn(
-    "design update is not yet implemented for the design pack model (default + variants/, ADR 0010)."
+
+// src/core/tokens-update.ts
+import * as path11 from "path";
+import * as fs8 from "fs/promises";
+import { createRequire as createRequire3 } from "module";
+import {
+  loadTokensPackageManifest as loadTokensPackageManifest2,
+  getVariantEntry as getVariantEntry2
+} from "@teamix-evo/registry";
+var DEFAULT_TOKENS_PACKAGE2 = "@teamix-evo/tokens";
+var CONSUMER_TOKENS_DIR2 = "tokens";
+var CONSUMER_THEME_FILE2 = "tokens.theme.css";
+var require4 = createRequire3(import.meta.url);
+async function runTokensUpdate(options) {
+  const { projectRoot } = options;
+  const packageName = options.packageName ?? DEFAULT_TOKENS_PACKAGE2;
+  const config = await readProjectConfig(projectRoot);
+  if (!config?.packages?.tokens) {
+    return { status: "not-initialized" };
+  }
+  const currentVariant = config.packages.tokens.variant;
+  const currentVersion = config.packages.tokens.version;
+  const packageRoot = options.packageRoot ?? resolveTokensPackageRoot2(packageName);
+  const catalog = await loadTokensPackageManifest2(packageRoot);
+  const variantEntry = getVariantEntry2(catalog, currentVariant);
+  if (!variantEntry) {
+    throw new Error(
+      `Currently installed variant "${currentVariant}" no longer exists in ${packageName}@${catalog.version}. Available: ${catalog.variants.map((v) => v.name).join(", ")}. Run \`teamix-evo tokens uninstall\` then \`teamix-evo tokens init <variant>\` to switch.`
+    );
+  }
+  if (variantEntry.version === currentVersion) {
+    await rewriteRegenerableFiles(variantEntry.files, packageRoot, projectRoot);
+    return {
+      status: "up-to-date",
+      packageName,
+      variant: currentVariant,
+      version: currentVersion
+    };
+  }
+  const rewritten = await rewriteRegenerableFiles(
+    variantEntry.files,
+    packageRoot,
+    projectRoot
   );
-  logger.info(
-    "Workaround: clean `.teamix-evo/design/` and re-run `teamix-evo design init <variant>`."
+  const preserved = [];
+  const overridesAbs = path11.join(
+    projectRoot,
+    CONSUMER_TOKENS_DIR2,
+    "tokens.overrides.css"
   );
-  logger.info(
-    "Tracking: PLAN \xA712.6 v0.7 \u2014 semantic upgrade flow + tokens.overrides.css preservation."
+  if (await fileExists(overridesAbs)) preserved.push("tokens.overrides.css");
+  const lock = {
+    schemaVersion: 1,
+    variant: {
+      name: variantEntry.name,
+      displayName: variantEntry.displayName,
+      version: variantEntry.version,
+      from: packageName
+    },
+    packageVersion: catalog.version,
+    linked: variantEntry.linked,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeFileSafe(
+    path11.join(projectRoot, ".teamix-evo", "tokens-lock.json"),
+    JSON.stringify(lock, null, 2) + "\n"
   );
-  process.exitCode = 0;
+  config.packages.tokens.version = variantEntry.version;
+  await writeProjectConfig(projectRoot, config);
+  const prior = await readInstalledManifest(projectRoot) ?? {
+    schemaVersion: 1,
+    installed: []
+  };
+  const idx = prior.installed.findIndex((p) => p.package === packageName);
+  if (idx >= 0) {
+    prior.installed[idx].version = variantEntry.version;
+    prior.installed[idx].installedAt = (/* @__PURE__ */ new Date()).toISOString();
+    for (const r of prior.installed[idx].resources) {
+      if (r.strategy === "regenerable") {
+        const abs = path11.isAbsolute(r.target) ? r.target : path11.join(projectRoot, r.target);
+        if (await fileExists(abs)) {
+          r.hash = computeHash(await fs8.readFile(abs, "utf-8"));
+        }
+      }
+    }
+    await writeInstalledManifest(projectRoot, prior);
+  }
+  return {
+    status: "updated",
+    packageName,
+    variant: currentVariant,
+    from: currentVersion,
+    to: variantEntry.version,
+    rewritten,
+    preserved
+  };
+}
+async function rewriteRegenerableFiles(files, packageRoot, projectRoot) {
+  const written = [];
+  for (const fileRel of files) {
+    const base = path11.basename(fileRel);
+    if (base !== "theme.css") continue;
+    const sourceAbs = path11.join(packageRoot, fileRel);
+    const targetAbs = path11.join(
+      projectRoot,
+      CONSUMER_TOKENS_DIR2,
+      CONSUMER_THEME_FILE2
+    );
+    const content = await fs8.readFile(sourceAbs, "utf-8");
+    await writeFileSafe(targetAbs, content);
+    written.push(CONSUMER_THEME_FILE2);
+  }
+  return written;
+}
+function resolveTokensPackageRoot2(packageName) {
+  const pkgJson = require4.resolve(`${packageName}/package.json`);
+  return path11.dirname(pkgJson);
+}
+
+// src/commands/tokens/update.ts
+var updateCommand = new Command2("update").description(
+  "\u5237\u65B0 design tokens\uFF08regenerable \u8986\u76D6\u3001frozen \u4FDD\u7559 \u2014 ADR 0003 \u4E09\u6001\uFF09"
+).action(async () => {
+  try {
+    const ide = detectIde();
+    const projectRoot = ide.getProjectRoot();
+    const result = await runTokensUpdate({ projectRoot });
+    if (result.status === "not-initialized") {
+      logger.error(
+        "No tokens variant installed. Run `teamix-evo tokens init <variant>` first."
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (result.status === "up-to-date") {
+      logger.success(
+        `Already at latest: ${result.packageName} (${result.variant} v${result.version})`
+      );
+      logger.info(
+        "  Regenerable files refreshed in case of manual edits."
+      );
+      return;
+    }
+    logger.success(
+      `Updated ${result.packageName} (${result.variant}): v${result.from} \u2192 v${result.to}`
+    );
+    if (result.rewritten.length > 0) {
+      logger.info(`  Rewrote:  ${result.rewritten.join(", ")}`);
+    }
+    if (result.preserved.length > 0) {
+      logger.info(
+        `  Preserved: ${result.preserved.join(", ")} (frozen \u2014 your customizations kept)`
+      );
+    }
+  } catch (err) {
+    logger.error(`Failed to update tokens: ${err.message}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
 });
 
-// src/commands/design/list.ts
+// src/commands/tokens/list.ts
 import { Command as Command3 } from "commander";
 var listCommand = new Command3("list").description("\u5217\u51FA\u5DF2\u5B89\u88C5\u7684\u8BBE\u8BA1\u53D8\u4F53").action(async () => {
   try {
     const ide = detectIde();
     const projectRoot = ide.getProjectRoot();
     const config = await readProjectConfig(projectRoot);
-    if (!config?.packages?.design) {
-      logger.info("No design system installed.");
-      logger.info('Run "teamix-evo design init [variant]" to get started.');
+    if (!config?.packages?.tokens) {
+      logger.info("No tokens variant installed.");
+      logger.info('Run "teamix-evo tokens init [variant]" to get started.');
       return;
     }
-    const { variant, version: version2 } = config.packages.design;
-    logger.info("Installed design system:");
-    logger.info(`  Package:  @teamix-evo/design`);
+    const { variant, version: version2 } = config.packages.tokens;
+    logger.info("Installed tokens variant:");
+    logger.info(`  Package:  @teamix-evo/tokens`);
     logger.info(`  Variant:  ${variant}`);
     logger.info(`  Version:  ${version2}`);
     logger.info(`  IDE:      ${config.ide}`);
     const manifest = await readInstalledManifest(projectRoot);
     if (manifest) {
       const pkg = manifest.installed.find(
-        (p) => p.package === "@teamix-evo/design" && p.variant === variant
+        (p) => p.package === "@teamix-evo/tokens" && p.variant === variant
       );
       if (pkg) {
         logger.info(`  Resources: ${pkg.resources.length} files`);
@@ -1176,20 +1454,17 @@ var listCommand = new Command3("list").description("\u5217\u51FA\u5DF2\u5B89\u88
   }
 });
 
-// src/commands/design/list-variants.ts
+// src/commands/tokens/list-variants.ts
 import { Command as Command4 } from "commander";
-var listVariantsCommand = new Command4("list-variants").description("\u5217\u51FA @teamix-evo/design \u5305\u5185\u63D0\u4F9B\u7684\u6240\u6709\u53D8\u4F53").action(async () => {
+var listVariantsCommand = new Command4("list-variants").description("\u5217\u51FA @teamix-evo/tokens \u5305\u5185\u63D0\u4F9B\u7684\u6240\u6709\u53D8\u4F53").action(async () => {
   try {
-    const result = await listDesignVariants();
-    logger.info(`Available design variants in ${result.packageName}:`);
-    logger.info("");
-    logger.info("  default \u2014 B \u7AEF\u901A\u7528\u57FA\u7EBF(\u59CB\u7EC8\u5185\u7F6E,\u65E0\u9700\u9009\u62E9)");
-    if (result.defaultDescription) {
-      logger.info(`    ${result.defaultDescription}`);
-    }
+    const result = await listTokenVariants();
+    logger.info(
+      `Available variants in ${result.packageName} v${result.packageVersion}:`
+    );
     logger.info("");
     if (result.variants.length === 0) {
-      logger.info("  (no variants beyond default)");
+      logger.info("  (no variants advertised in manifest.json)");
       return;
     }
     for (const v of result.variants) {
@@ -1198,12 +1473,13 @@ var listVariantsCommand = new Command4("list-variants").description("\u5217\u51F
       if (v.linked) {
         const links = [];
         if (v.linked["biz-ui"]) links.push(`biz-ui: ${v.linked["biz-ui"]}`);
-        if (v.linked.templates) links.push(`templates: ${v.linked.templates}`);
+        if (v.linked.templates)
+          links.push(`templates: ${v.linked.templates}`);
         if (links.length) logger.info(`    linked: ${links.join(" / ")}`);
       }
       logger.info("");
     }
-    logger.info("Install a variant: teamix-evo design init <name>");
+    logger.info("Install a variant: teamix-evo tokens init <name>");
   } catch (err) {
     logger.error(`Failed to list variants: ${err.message}`);
     logger.debug(err.stack ?? "");
@@ -1211,37 +1487,42 @@ var listVariantsCommand = new Command4("list-variants").description("\u5217\u51F
   }
 });
 
-// src/commands/design/uninstall.ts
+// src/commands/tokens/uninstall.ts
 import { Command as Command5 } from "commander";
-import * as fs7 from "fs/promises";
-import * as path10 from "path";
+import * as fs9 from "fs/promises";
+import * as path12 from "path";
 import * as prompts from "@clack/prompts";
-var DESIGN_PACKAGE = "@teamix-evo/design";
-var uninstallCommand = new Command5("uninstall").description("\u5378\u8F7D\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90\uFF08\u9ED8\u8BA4\u4F1A\u5220\u9664 frozen / regenerable \u8D44\u6E90\u6587\u4EF6\uFF09").option("-y, --yes", "\u8DF3\u8FC7\u786E\u8BA4").option(
+var TOKENS_PACKAGE = "@teamix-evo/tokens";
+var uninstallCommand = new Command5("uninstall").description(
+  "\u5378\u8F7D\u5DF2\u88C5\u7684 tokens \u53D8\u4F53\uFF08\u9ED8\u8BA4\u4FDD\u7559 frozen \u6587\u4EF6\u5982 tokens.overrides.css\uFF1B--purge \u624D\u4E00\u5E76\u5220\uFF09"
+).option("-y, --yes", "\u8DF3\u8FC7\u786E\u8BA4").option(
   "--keep-files",
-  "\u4EC5\u6E05\u7406 .teamix-evo \u4E2D\u7684\u8BB0\u8D26\u4FE1\u606F\uFF0C\u4E0D\u5220\u9664\u5DF2\u843D\u5730\u8D44\u6E90\u6587\u4EF6"
+  "\u4EC5\u6E05\u7406 .teamix-evo \u4E2D\u7684\u8BB0\u8D26\u4FE1\u606F\uFF0C\u4E0D\u5220\u9664\u4EFB\u4F55\u843D\u5730\u8D44\u6E90\u6587\u4EF6"
+).option(
+  "--purge",
+  "\u540C\u65F6\u5220\u9664 frozen \u6587\u4EF6\uFF08\u9ED8\u8BA4 frozen / managed \u90FD\u4FDD\u7559 \u2014 ADR 0003\uFF09"
 ).action(async (opts) => {
   try {
     const ide = detectIde();
     const projectRoot = ide.getProjectRoot();
     const config = await readProjectConfig(projectRoot);
-    if (!config?.packages?.design) {
-      logger.info("Design system is not installed. Nothing to do.");
+    if (!config?.packages?.tokens) {
+      logger.info("No tokens variant installed. Nothing to do.");
       return;
     }
     const installedManifest = await readInstalledManifest(projectRoot);
     const pkg = installedManifest?.installed.find(
-      (p) => p.package === DESIGN_PACKAGE
+      (p) => p.package === TOKENS_PACKAGE
     );
     const resources = pkg?.resources ?? [];
-    const removable = opts.keepFiles ? [] : resources.filter((r) => r.strategy !== "managed");
+    const removable = opts.keepFiles ? [] : opts.purge ? resources.filter((r) => r.strategy !== "managed") : resources.filter((r) => r.strategy === "regenerable");
     const kept = resources.length - removable.length;
     logger.info(
       `Will remove ${removable.length} file(s); keep ${kept} managed file(s).`
     );
     if (!opts.yes) {
       const confirm4 = await prompts.confirm({
-        message: "\u786E\u8BA4\u5378\u8F7D\u8BBE\u8BA1\u4F53\u7CFB\uFF1F",
+        message: "\u786E\u8BA4\u5378\u8F7D tokens \u53D8\u4F53\uFF1F",
         initialValue: false
       });
       if (prompts.isCancel(confirm4) || !confirm4) {
@@ -1251,9 +1532,9 @@ var uninstallCommand = new Command5("uninstall").description("\u5378\u8F7D\u8BBE
     }
     let removed = 0;
     for (const r of removable) {
-      const target = path10.isAbsolute(r.target) ? r.target : path10.join(projectRoot, r.target);
+      const target = path12.isAbsolute(r.target) ? r.target : path12.join(projectRoot, r.target);
       try {
-        await fs7.unlink(target);
+        await fs9.unlink(target);
         removed++;
       } catch (err) {
         if (err.code !== "ENOENT") {
@@ -1265,18 +1546,31 @@ var uninstallCommand = new Command5("uninstall").description("\u5378\u8F7D\u8BBE
     }
     if (installedManifest) {
       installedManifest.installed = installedManifest.installed.filter(
-        (p) => p.package !== DESIGN_PACKAGE
+        (p) => p.package !== TOKENS_PACKAGE
       );
       await writeInstalledManifest(projectRoot, installedManifest);
     }
-    delete config.packages.design;
+    delete config.packages.tokens;
     await writeProjectConfig(projectRoot, config);
-    logger.success(`Uninstalled ${DESIGN_PACKAGE}`);
+    const lockPath = path12.join(
+      projectRoot,
+      ".teamix-evo",
+      "tokens-lock.json"
+    );
+    try {
+      await fs9.unlink(lockPath);
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        logger.warn(
+          `Failed to remove tokens-lock.json: ${err.message}`
+        );
+      }
+    }
+    logger.success(`Uninstalled ${TOKENS_PACKAGE}`);
     logger.info(`  Removed: ${removed} files`);
     if (kept > 0) {
-      logger.info(
-        `  Kept:    ${kept} managed files (you may delete manually)`
-      );
+      const note = opts.purge ? "managed (you may delete manually)" : "frozen / managed (preserved \u2014 ADR 0003; --purge to force)";
+      logger.info(`  Kept:    ${kept} files \u2014 ${note}`);
     }
   } catch (err) {
     logger.error(`Failed to uninstall: ${err.message}`);
@@ -1285,15 +1579,13 @@ var uninstallCommand = new Command5("uninstall").description("\u5378\u8F7D\u8BBE
   }
 });
 
-// src/commands/design/index.ts
-var designCommand = new Command6("design").description(
-  "\u7BA1\u7406\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90"
-);
-designCommand.addCommand(initCommand);
-designCommand.addCommand(updateCommand);
-designCommand.addCommand(listCommand);
-designCommand.addCommand(listVariantsCommand);
-designCommand.addCommand(uninstallCommand);
+// src/commands/tokens/index.ts
+var tokensCommand = new Command6("tokens").description("\u7BA1\u7406 design tokens(\u53D8\u4F53\u7EA7 theme.css \u7B49)");
+tokensCommand.addCommand(initCommand);
+tokensCommand.addCommand(updateCommand);
+tokensCommand.addCommand(listCommand);
+tokensCommand.addCommand(listVariantsCommand);
+tokensCommand.addCommand(uninstallCommand);
 
 // src/commands/skills/index.ts
 import { Command as Command13 } from "commander";
@@ -1301,34 +1593,6 @@ import { Command as Command13 } from "commander";
 // src/commands/skills/add.ts
 import { Command as Command7 } from "commander";
 import * as prompts2 from "@clack/prompts";
-
-// src/utils/global-root.ts
-import { existsSync } from "fs";
-import * as fs8 from "fs/promises";
-import * as os3 from "os";
-import * as path11 from "path";
-var GLOBAL_META_DIR = ".teamix-evo-global";
-var TEAMIX_DIR3 = ".teamix-evo";
-var CONFIG_FILE2 = "config.json";
-function getGlobalMetaRoot() {
-  return path11.join(os3.homedir(), GLOBAL_META_DIR);
-}
-function isTeamixEvoProject(dir) {
-  return existsSync(path11.join(dir, TEAMIX_DIR3, CONFIG_FILE2));
-}
-async function ensureGlobalMetaRoot() {
-  const root = getGlobalMetaRoot();
-  await fs8.mkdir(root, { recursive: true });
-  return root;
-}
-function resolveSkillsMaintenanceRoot(cwd) {
-  if (isTeamixEvoProject(cwd)) return cwd;
-  const globalRoot = getGlobalMetaRoot();
-  if (isTeamixEvoProject(globalRoot)) return globalRoot;
-  return cwd;
-}
-
-// src/commands/skills/add.ts
 var addCommand = new Command7("add").description(
   "\u5411\u9879\u76EE\uFF08\u6216\u5168\u5C40 IDE \u914D\u7F6E\uFF09\u6DFB\u52A0 teamix-evo skills\uFF1B\u4E0D\u4F20 names \u5219\u6DFB\u52A0 manifest \u5185\u5168\u90E8 skill"
 ).argument(
@@ -1351,6 +1615,11 @@ var addCommand = new Command7("add").description(
     if (scope === "global" && !isTeamixEvoProject(cwd)) {
       projectRoot = await ensureGlobalMetaRoot();
       logger.info(`Global skill install \u2014 meta root: ${projectRoot}`);
+    } else if (scope !== "global" && !hasPackageJson(cwd)) {
+      logger.error(
+        "No package.json found in current directory. Please run this command in a valid project root."
+      );
+      process.exit(1);
     }
     logger.info(
       isIncremental ? `Adding skills [${names.join(",")}]: ides=[${ides.join(
@@ -1483,11 +1752,17 @@ var listCommand2 = new Command8("list").alias("ls").description(
     const pkg = installedManifest?.installed.find(
       (p) => p.package === SKILLS_PACKAGE
     );
+    const skillsLock = await readSkillsLock(projectRoot);
     const installedBySkill = /* @__PURE__ */ new Map();
     for (const r of pkg?.resources ?? []) {
       const skillId = r.id.split(":")[0];
       installedBySkill.set(skillId, (installedBySkill.get(skillId) ?? 0) + 1);
     }
+    for (const skillId of Object.keys(skillsLock?.skills ?? {})) {
+      if (!installedBySkill.has(skillId)) {
+        installedBySkill.set(skillId, 1);
+      }
+    }
     if (opts.installed) {
       if (!config?.packages?.skills || !pkg) {
         logger.info("No skills installed.");
@@ -1510,9 +1785,13 @@ var listCommand2 = new Command8("list").alias("ls").description(
     const skills = [...manifest.skills].sort(
       (a, b) => a.id.localeCompare(b.id)
     );
-    const isInstalled = !!config?.packages?.skills && !!pkg;
-    if (isInstalled) {
+    const isInstalled = installedBySkill.size > 0;
+    if (isInstalled && config?.packages?.skills && pkg) {
       printInstalledHeader(config.packages.skills, pkg.installedAt);
+    } else if (isInstalled) {
+      logger.info(
+        `Installed (${installedBySkill.size} skill(s)) \u2014 config or manifest record missing; run "teamix-evo skills doctor" to repair.`
+      );
     } else {
       logger.info("Skills package not yet added.");
       logger.info(
@@ -1648,8 +1927,8 @@ var updateCommand2 = new Command9("update").description("\u66F4\u65B0\u5DF2\u5B8
 // src/commands/skills/uninstall.ts
 import { Command as Command10 } from "commander";
 import * as prompts3 from "@clack/prompts";
-import * as path12 from "path";
-import * as fs9 from "fs/promises";
+import * as path13 from "path";
+import * as fs10 from "fs/promises";
 var SKILLS_PACKAGE3 = "@teamix-evo/skills";
 var uninstallCommand2 = new Command10("uninstall").description(
   "\u5378\u8F7D\u5DF2\u5B89\u88C5\u7684 teamix-evo skills\uFF1B\u4E0D\u4F20 ids \u5219\u5378\u8F7D\u6574\u5305\uFF0C\u4F20 ids \u5219\u6309 skill \u5220\u9664"
@@ -1717,14 +1996,26 @@ async function runFullUninstall(args) {
   const removed = await removeSkillFiles(resources);
   logger.debug(`Removed ${removed.length} files`);
   const skillsRoot = getSkillsSourceDir(projectRoot);
+  const sourceSkillNames = await listSkillSourceNames(skillsRoot);
   try {
-    await fs9.rm(skillsRoot, { recursive: true, force: true });
+    await fs10.rm(skillsRoot, { recursive: true, force: true });
     logger.debug(`Removed source dir ${skillsRoot}`);
   } catch (err) {
     logger.warn(
       `Failed to remove ${skillsRoot}: ${err.message}`
     );
   }
+  const skillNames = collectSkillNames({
+    fromSources: sourceSkillNames,
+    fromConfig: config,
+    fromResources: resources
+  });
+  const cleanedMirrorDirs = await removeMirrorDirs(
+    projectRoot,
+    config?.packages?.skills?.scope,
+    config?.packages?.skills?.ides,
+    skillNames
+  );
   if (installedManifest && pkg) {
     installedManifest.installed = installedManifest.installed.filter(
       (p) => p.package !== SKILLS_PACKAGE3
@@ -1735,7 +2026,12 @@ async function runFullUninstall(args) {
   await writeProjectConfig(projectRoot, config);
   logger.success(`Uninstalled ${SKILLS_PACKAGE3}`);
   logger.info(`  Removed: ${removed.length} files`);
-  logger.info(`  Source:  ${path12.relative(projectRoot, skillsRoot)} (cleaned)`);
+  logger.info(`  Source:  ${path13.relative(projectRoot, skillsRoot)} (cleaned)`);
+  if (cleanedMirrorDirs.length > 0) {
+    logger.info(
+      `  Mirrors: ${cleanedMirrorDirs.map((d) => path13.relative(projectRoot, d)).join(", ")} (cleaned)`
+    );
+  }
 }
 async function runPartialUninstall(args) {
   const { projectRoot, installedManifest, pkg, resources, ids, opts } = args;
@@ -1771,12 +2067,19 @@ async function runPartialUninstall(args) {
   for (const id of matched) {
     const dir = getSkillsSourceDir(projectRoot, id);
     try {
-      await fs9.rm(dir, { recursive: true, force: true });
+      await fs10.rm(dir, { recursive: true, force: true });
       logger.debug(`Removed source dir ${dir}`);
     } catch (err) {
       logger.warn(`Failed to remove ${dir}: ${err.message}`);
     }
   }
+  const config = await readProjectConfig(projectRoot);
+  const cleanedMirrorDirs = await removeMirrorDirs(
+    projectRoot,
+    config?.packages?.skills?.scope,
+    config?.packages?.skills?.ides,
+    matched
+  );
   const lock = await readSkillsLock(projectRoot);
   if (lock) {
     for (const id of matched) delete lock.skills[id];
@@ -1790,10 +2093,69 @@ async function runPartialUninstall(args) {
     `Removed ${matched.length} skill(s): ${matched.join(", ")}`
   );
   logger.info(`  Files:   ${removed.length}`);
+  if (cleanedMirrorDirs.length > 0) {
+    logger.info(
+      `  Mirrors: ${cleanedMirrorDirs.map((d) => path13.relative(projectRoot, d)).join(", ")} (cleaned)`
+    );
+  }
   if (missing.length > 0) {
     logger.info(`  Skipped: ${missing.join(", ")} (not installed)`);
   }
 }
+async function listSkillSourceNames(skillsRoot) {
+  try {
+    const entries = await fs10.readdir(skillsRoot, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function collectSkillNames(args) {
+  const set = new Set(args.fromSources);
+  for (const r of args.fromResources) {
+    set.add(r.id.split(":")[0]);
+  }
+  return [...set];
+}
+async function removeMirrorDirs(projectRoot, scope, ides, skillNames) {
+  if (skillNames.length === 0) return [];
+  const targetIdes = ides && ides.length > 0 ? ides.filter((i) => i === "qoder" || i === "claude") : [...ALL_IDE_KINDS];
+  const targetScope = scope === "global" ? "global" : "project";
+  const removed = [];
+  for (const ide of targetIdes) {
+    const adapter = getAdapter(ide);
+    for (const name of skillNames) {
+      const dir = adapter.getSkillTargetDir(name, targetScope, projectRoot);
+      let existed = true;
+      try {
+        await fs10.access(dir);
+      } catch {
+        existed = false;
+      }
+      if (!existed) continue;
+      try {
+        await fs10.rm(dir, { recursive: true, force: true });
+        removed.push(dir);
+        logger.debug(`Removed mirror dir ${dir}`);
+      } catch (err) {
+        logger.warn(`Failed to remove ${dir}: ${err.message}`);
+      }
+    }
+    if (removed.length > 0) {
+      const skillsParent = path13.dirname(
+        adapter.getSkillTargetDir("placeholder", targetScope, projectRoot)
+      );
+      try {
+        const remaining = await fs10.readdir(skillsParent);
+        if (remaining.length === 0) {
+          await fs10.rmdir(skillsParent);
+        }
+      } catch {
+      }
+    }
+  }
+  return removed;
+}
 function skillIdOf(r) {
   return r.id.split(":")[0];
 }
@@ -1815,7 +2177,26 @@ function dedupe(values) {
 import { Command as Command11 } from "commander";
 
 // src/core/skills-sync.ts
-import * as fs10 from "fs/promises";
+import * as path14 from "path";
+import * as fs11 from "fs/promises";
+import { createRequire as createRequire4 } from "module";
+import { loadSkillsPackageManifest as loadSkillsPackageManifest2 } from "@teamix-evo/registry";
+var require5 = createRequire4(import.meta.url);
+async function readSkillMetaFromUpstream(skillId) {
+  try {
+    const pkgJson = require5.resolve("@teamix-evo/skills/package.json");
+    const packageRoot = path14.dirname(pkgJson);
+    const manifest = await loadSkillsPackageManifest2(packageRoot);
+    const entry = manifest.skills.find((s) => s.id === skillId);
+    if (!entry) return null;
+    return {
+      updateStrategy: entry.updateStrategy,
+      managedRegions: entry.managedRegions
+    };
+  } catch {
+    return null;
+  }
+}
 var SKILLS_PACKAGE_DEFAULT = "@teamix-evo/skills";
 async function runSkillsSync(options) {
   const { projectRoot, names } = options;
@@ -1849,13 +2230,15 @@ async function runSkillsSync(options) {
       logger.warn(`Skill "${skillId}" has no IDE mirror targets; skipped.`);
       continue;
     }
+    const upstreamMeta = await readSkillMetaFromUpstream(skillId);
     const result = await syncSkillsToIdes({
       projectRoot,
       skills: [
         {
           id: skillId,
           name: skillId,
-          updateStrategy: "regenerable"
+          updateStrategy: upstreamMeta?.updateStrategy ?? "regenerable",
+          managedRegions: upstreamMeta?.managedRegions
         }
       ],
       ides,
@@ -1882,7 +2265,7 @@ async function runSkillsSync(options) {
 }
 async function dirExists(p) {
   try {
-    const stat4 = await fs10.stat(p);
+    const stat4 = await fs11.stat(p);
     return stat4.isDirectory();
   } catch {
     return false;
@@ -1976,8 +2359,8 @@ function parseScope2(input) {
 import { Command as Command12 } from "commander";
 
 // src/core/skills-doctor.ts
-import * as path13 from "path";
-import * as fs11 from "fs/promises";
+import * as path15 from "path";
+import * as fs12 from "fs/promises";
 async function runSkillsDoctor(options) {
   const { projectRoot } = options;
   const lock = await readSkillsLock(projectRoot);
@@ -1999,8 +2382,8 @@ async function runSkillsDoctor(options) {
     const sourceFiles = await walkDir(sourceDir);
     const sourceContents = /* @__PURE__ */ new Map();
     for (const f of sourceFiles) {
-      const rel2 = path13.relative(sourceDir, f);
-      sourceContents.set(rel2, await fs11.readFile(f, "utf-8"));
+      const rel2 = path15.relative(sourceDir, f);
+      sourceContents.set(rel2, await fs12.readFile(f, "utf-8"));
     }
     for (const ide of entry.mirroredTo) {
       const adapter = getAdapter(ide);
@@ -2021,7 +2404,7 @@ async function runSkillsDoctor(options) {
         continue;
       }
       for (const [rel2, sourceContent] of sourceContents.entries()) {
-        const mirrorFile = path13.join(mirrorDir, rel2);
+        const mirrorFile = path15.join(mirrorDir, rel2);
         if (!await fileExists(mirrorFile)) {
           findings.push({
             kind: "missing-mirror",
@@ -2033,7 +2416,7 @@ async function runSkillsDoctor(options) {
           });
           continue;
         }
-        const mirrorContent = await fs11.readFile(mirrorFile, "utf-8");
+        const mirrorContent = await fs12.readFile(mirrorFile, "utf-8");
         if (computeHash(mirrorContent) !== computeHash(sourceContent)) {
           findings.push({
             kind: "mirror-drift",
@@ -2054,7 +2437,7 @@ async function runSkillsDoctor(options) {
 }
 async function dirExists2(p) {
   try {
-    const stat4 = await fs11.stat(p);
+    const stat4 = await fs12.stat(p);
     return stat4.isDirectory();
   } catch {
     return false;
@@ -2162,6 +2545,7 @@ async function runUiInit(options) {
     rsc
   };
   await writeProjectConfig(projectRoot, config);
+  await ensureMcpJson(projectRoot);
   return {
     status: "installed",
     aliases,
@@ -2182,6 +2566,12 @@ var initCommand2 = new Command14("init").description(
   try {
     const ide = detectIde();
     const projectRoot = ide.getProjectRoot();
+    if (!hasPackageJson(projectRoot)) {
+      logger.error(
+        "No package.json found in current directory. Please run this command in a valid project root."
+      );
+      process.exit(1);
+    }
     const cfg = await resolveConfig(opts);
     const result = await runUiInit({
       projectRoot,
@@ -2282,23 +2672,23 @@ async function resolveConfig(opts) {
 import { Command as Command15 } from "commander";
 
 // src/core/ui-client.ts
-import * as path14 from "path";
-import * as fs12 from "fs/promises";
-import { createRequire as createRequire3 } from "module";
+import * as path16 from "path";
+import * as fs13 from "fs/promises";
+import { createRequire as createRequire5 } from "module";
 import { loadUiPackageManifest } from "@teamix-evo/registry";
-var require4 = createRequire3(import.meta.url);
+var require6 = createRequire5(import.meta.url);
 function resolvePackageRoot2(packageName) {
-  const pkgJsonPath = require4.resolve(`${packageName}/package.json`);
-  return path14.dirname(pkgJsonPath);
+  const pkgJsonPath = require6.resolve(`${packageName}/package.json`);
+  return path16.dirname(pkgJsonPath);
 }
 async function loadUiData(packageName) {
   const packageRoot = resolvePackageRoot2(packageName);
   logger.debug(`Resolved ui package root: ${packageRoot}`);
   const manifest = await loadUiPackageManifest(packageRoot);
   let data = {};
-  const dataPath = path14.join(packageRoot, "_data.json");
+  const dataPath = path16.join(packageRoot, "_data.json");
   try {
-    const raw = await fs12.readFile(dataPath, "utf-8");
+    const raw = await fs13.readFile(dataPath, "utf-8");
     data = JSON.parse(raw);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -2310,8 +2700,8 @@ async function loadUiData(packageName) {
 }
 
 // src/core/ui-installer.ts
-import * as path15 from "path";
-import * as fs13 from "fs/promises";
+import * as path17 from "path";
+import * as fs14 from "fs/promises";
 import { resolveUiEntryOrder } from "@teamix-evo/registry";
 
 // src/utils/transform-imports.ts
@@ -2324,13 +2714,13 @@ var SOURCE_ROOT_TO_ALIAS_KEY = {
 function rewriteImports(source, aliases) {
   return source.replace(
     /(['"])@\/([a-z][a-z0-9-]*)(\/[^'"]*)?\1/g,
-    (full, quote, root, rest) => {
+    (full, quote2, root, rest) => {
       const aliasKey = SOURCE_ROOT_TO_ALIAS_KEY[root];
       if (!aliasKey) return full;
       const alias = aliases[aliasKey];
       const normalized = aliasToImportPath(alias);
       const flatRest = flattenRestPath(rest);
-      return `${quote}${normalized}${flatRest}${quote}`;
+      return `${quote2}${normalized}${flatRest}${quote2}`;
     }
   );
 }
@@ -2351,12 +2741,12 @@ function aliasToImportPath(alias) {
 }
 
 // src/core/ui-installer.ts
-var DESIGN_COMPONENTS_DIR = ".teamix-evo/design/components";
 async function installUiEntries(options) {
   const {
     projectRoot,
     manifest,
     packageRoot,
+    entryPackageRoot,
     aliases,
     requested,
     skipExisting = true
@@ -2365,7 +2755,6 @@ async function installUiEntries(options) {
   const idToEntry = new Map(manifest.entries.map((e) => [e.id, e]));
   const resources = [];
   const npmDeps = {};
-  const metaFiles = [];
   let written = 0;
   let skipped = 0;
   for (const id of orderedIds) {
@@ -2384,8 +2773,9 @@ async function installUiEntries(options) {
         skipped++;
         continue;
       }
-      const sourceAbs = path15.resolve(packageRoot, file.source);
-      const raw = await fs13.readFile(sourceAbs, "utf-8");
+      const rootForEntry = entryPackageRoot?.get(entry.id) ?? packageRoot;
+      const sourceAbs = path17.resolve(rootForEntry, file.source);
+      const raw = await fs14.readFile(sourceAbs, "utf-8");
       const transformed = rewriteImports(raw, aliases);
       await writeFileSafe(targetAbs, transformed);
       written++;
@@ -2397,32 +2787,13 @@ async function installUiEntries(options) {
         strategy: entry.updateStrategy ?? "frozen"
       });
     }
-    if (entry.meta) {
-      const metaSourceAbs = path15.resolve(packageRoot, entry.meta);
-      const metaContent = await fs13.readFile(metaSourceAbs, "utf-8");
-      const metaTargetAbs = path15.join(
-        projectRoot,
-        DESIGN_COMPONENTS_DIR,
-        `${entry.id}.meta.md`
-      );
-      await writeFileSafe(metaTargetAbs, metaContent);
-      metaFiles.push(metaTargetAbs);
-      resources.push({
-        id: `${entry.id}:meta`,
-        target: metaTargetAbs,
-        hash: computeHash(metaContent),
-        strategy: "regenerable"
-      });
-      logger.info(`  meta:  ${rel(projectRoot, metaTargetAbs)}`);
-    }
   }
   return {
     orderedIds,
     resources,
     npmDependencies: npmDeps,
     written,
-    skipped,
-    metaFiles
+    skipped
   };
 }
 function resolveTargetPath(projectRoot, aliases, entry, file) {
@@ -2432,16 +2803,16 @@ function resolveTargetPath(projectRoot, aliases, entry, file) {
       `Entry "${entry.id}" requires alias "${file.targetAlias}" but it is not configured.`
     );
   }
-  return path15.join(projectRoot, aliasDir, file.targetName);
+  return path17.join(projectRoot, aliasDir, file.targetName);
 }
 function rel(projectRoot, abs) {
-  return path15.relative(projectRoot, abs);
+  return path17.relative(projectRoot, abs);
 }
 
 // src/core/ui-add.ts
 var DEFAULT_UI_PACKAGE = "@teamix-evo/ui";
 async function runUiAdd(options) {
-  const { projectRoot, ids, overwrite } = options;
+  const { projectRoot, ids, overwrite, includeDeprecated } = options;
   const packageName = options.packageName ?? DEFAULT_UI_PACKAGE;
   if (ids.length === 0) {
     throw new Error("At least one entry id must be provided.");
@@ -2454,7 +2825,21 @@ async function runUiAdd(options) {
     );
   }
   const { manifest, packageRoot } = await loadUiData(packageName);
-  const knownIds = new Set(manifest.entries.map((e) => e.id));
+  const archived = manifest.deprecatedEntries ?? [];
+  const archivedIds = new Set(archived.map((e) => e.id));
+  const activeIds = new Set(manifest.entries.map((e) => e.id));
+  const requestedDeprecated = ids.filter((id) => archivedIds.has(id));
+  if (requestedDeprecated.length > 0 && !includeDeprecated) {
+    const list = requestedDeprecated.map((s) => `"${s}"`).join(", ");
+    throw new Error(
+      `Refusing to install deprecated entr${requestedDeprecated.length === 1 ? "y" : "ies"} ${list}. These entries are archived and not part of the active distribution (ADR 0028). Pass \`--include-deprecated\` to override (e.g. for migration tooling).`
+    );
+  }
+  const effectiveManifest = includeDeprecated ? { ...manifest, entries: [...manifest.entries, ...archived] } : manifest;
+  const knownIds = /* @__PURE__ */ new Set([
+    ...activeIds,
+    ...includeDeprecated ? archivedIds : []
+  ]);
   const unknown = ids.filter((id) => !knownIds.has(id));
   if (unknown.length > 0) {
     throw new Error(
@@ -2463,7 +2848,7 @@ async function runUiAdd(options) {
   }
   const result = await installUiEntries({
     projectRoot,
-    manifest,
+    manifest: effectiveManifest,
     packageRoot,
     aliases: uiCfg.aliases,
     requested: ids,
@@ -2497,7 +2882,6 @@ async function runUiAdd(options) {
     orderedIds: result.orderedIds,
     written: result.written,
     skipped: result.skipped,
-    metaFiles: result.metaFiles,
     npmDependencies: result.npmDependencies,
     resources: result.resources
   };
@@ -2512,46 +2896,48 @@ function mergeResources(prior, next) {
 // src/commands/ui/add.ts
 var addCommand2 = new Command15("add").description(
   "\u5B89\u88C5\u4E00\u4E2A\u6216\u591A\u4E2A ui entry\uFF08\u6309 id\uFF0C\u81EA\u52A8\u5C55\u5F00 registryDependencies\uFF09"
-).argument("<ids...>", 'entry id \u5217\u8868\uFF0C\u5982 "button" "dialog"').option("--overwrite", "\u5373\u4F7F\u76EE\u6807\u6587\u4EF6\u5DF2\u5B58\u5728\u4E5F\u8986\u76D6\uFF08\u7ED5\u8FC7 frozen \u8DF3\u8FC7\uFF09").action(async (ids, opts) => {
-  try {
-    const ide = detectIde();
-    const projectRoot = ide.getProjectRoot();
-    logger.info(`Installing entries: ${ids.join(", ")}`);
-    const result = await runUiAdd({
-      projectRoot,
-      ids,
-      overwrite: opts.overwrite
-    });
-    logger.success(
-      `UI add complete: ${result.written} written, ${result.skipped} skipped, ${result.metaFiles.length} meta.`
-    );
-    logger.info("");
-    logger.info(`Resolved order: ${result.orderedIds.join(" \u2192 ")}`);
-    const npmDeps = Object.entries(result.npmDependencies);
-    if (npmDeps.length > 0) {
-      logger.info("");
-      logger.info("Install npm dependencies in your project:");
-      const installCmd = npmDeps.map(([name, range]) => `${name}@${range}`).join(" ");
-      logger.info(`  pnpm add ${installCmd}`);
-      logger.info(`  # or: npm install ${installCmd}`);
-    }
-    if (result.metaFiles.length > 0) {
-      logger.info("");
-      logger.info(
-        "Component meta dropped under .teamix-evo/design/components/ (AI-readable)."
+).argument("<ids...>", 'entry id \u5217\u8868\uFF0C\u5982 "button" "dialog"').option("--overwrite", "\u5373\u4F7F\u76EE\u6807\u6587\u4EF6\u5DF2\u5B58\u5728\u4E5F\u8986\u76D6\uFF08\u7ED5\u8FC7 frozen \u8DF3\u8FC7\uFF09").option(
+  "--include-deprecated",
+  "\u5141\u8BB8\u5B89\u88C5\u5DF2\u5F52\u6863\u7684 deprecated entry\uFF08\u4EC5\u8FC1\u79FB / \u5BA1\u8BA1\u573A\u666F\uFF0CADR 0028\uFF09"
+).action(
+  async (ids, opts) => {
+    try {
+      const ide = detectIde();
+      const projectRoot = ide.getProjectRoot();
+      logger.info(`Installing entries: ${ids.join(", ")}`);
+      const result = await runUiAdd({
+        projectRoot,
+        ids,
+        overwrite: opts.overwrite,
+        includeDeprecated: opts.includeDeprecated
+      });
+      logger.success(
+        `UI add complete: ${result.written} written, ${result.skipped} skipped.`
       );
+      logger.info("");
+      logger.info(`Resolved order: ${result.orderedIds.join(" \u2192 ")}`);
+      const npmDeps = Object.entries(result.npmDependencies);
+      if (npmDeps.length > 0) {
+        logger.info("");
+        logger.info("Install npm dependencies in your project:");
+        const installCmd = npmDeps.map(([name, range]) => `${name}@${range}`).join(" ");
+        logger.info(`  pnpm add ${installCmd}`);
+        logger.info(`  # or: npm install ${installCmd}`);
+      }
+    } catch (err) {
+      const message = err.message;
+      if (message.startsWith("UI not initialized")) {
+        logger.error(
+          "UI not initialized. Run `npx teamix-evo ui init` first."
+        );
+      } else {
+        logger.error(`Failed to add ui entries: ${message}`);
+      }
+      logger.debug(err.stack ?? "");
+      process.exitCode = 1;
     }
-  } catch (err) {
-    const message = err.message;
-    if (message.startsWith("UI not initialized")) {
-      logger.error("UI not initialized. Run `npx teamix-evo ui init` first.");
-    } else {
-      logger.error(`Failed to add ui entries: ${message}`);
-    }
-    logger.debug(err.stack ?? "");
-    process.exitCode = 1;
   }
-});
+);
 
 // src/commands/ui/list.ts
 import { Command as Command16 } from "commander";
@@ -2559,7 +2945,7 @@ import { Command as Command16 } from "commander";
 // src/core/ui-list.ts
 var DEFAULT_UI_PACKAGE2 = "@teamix-evo/ui";
 async function runUiList(options) {
-  const { projectRoot, installedOnly } = options;
+  const { projectRoot, installedOnly, includeDeprecated } = options;
   const packageName = options.packageName ?? DEFAULT_UI_PACKAGE2;
   const { manifest } = await loadUiData(packageName);
   const installedManifest = await readInstalledManifest(projectRoot);
@@ -2571,65 +2957,77 @@ async function runUiList(options) {
     const colon = r.id.indexOf(":");
     installedIds.add(colon >= 0 ? r.id.slice(0, colon) : r.id);
   }
-  const entries = manifest.entries.filter((e) => !installedOnly || installedIds.has(e.id)).map((e) => ({
-    id: e.id,
-    type: e.type,
-    description: e.description,
-    installed: installedIds.has(e.id)
+  const archived = manifest.deprecatedEntries ?? [];
+  const pool = includeDeprecated ? [
+    ...manifest.entries.map((e) => ({ entry: e, deprecated: false })),
+    ...archived.map((e) => ({ entry: e, deprecated: true }))
+  ] : manifest.entries.map((e) => ({ entry: e, deprecated: false }));
+  const entries = pool.filter(({ entry }) => !installedOnly || installedIds.has(entry.id)).map(({ entry, deprecated }) => ({
+    id: entry.id,
+    type: entry.type,
+    description: entry.description,
+    installed: installedIds.has(entry.id),
+    deprecated
   }));
   return {
     packageName,
-    total: manifest.entries.length,
+    total: manifest.entries.length + (includeDeprecated ? archived.length : 0),
     installedCount: installedIds.size,
     entries
   };
 }
 
 // src/commands/ui/list.ts
-var listCommand3 = new Command16("list").description("\u5217\u51FA @teamix-evo/ui \u7684\u6240\u6709 entry \u53CA\u5DF2\u5B89\u88C5\u72B6\u6001").option("--installed", "\u4EC5\u5C55\u793A\u5DF2\u5B89\u88C5\u7684 entry").action(async (opts) => {
-  try {
-    const ide = detectIde();
-    const projectRoot = ide.getProjectRoot();
-    const { entries, total, installedCount } = await runUiList({
-      projectRoot,
-      installedOnly: opts.installed
-    });
-    if (entries.length === 0) {
+var listCommand3 = new Command16("list").description("\u5217\u51FA @teamix-evo/ui \u7684\u6240\u6709 entry \u53CA\u5DF2\u5B89\u88C5\u72B6\u6001").option("--installed", "\u4EC5\u5C55\u793A\u5DF2\u5B89\u88C5\u7684 entry").option(
+  "--include-deprecated",
+  "\u540C\u65F6\u5217\u51FA\u5DF2\u5F52\u6863\u7684 deprecated entry\uFF08\u9ED8\u8BA4\u9690\u85CF\uFF0CADR 0028\uFF09"
+).action(
+  async (opts) => {
+    try {
+      const ide = detectIde();
+      const projectRoot = ide.getProjectRoot();
+      const { entries, total, installedCount } = await runUiList({
+        projectRoot,
+        installedOnly: opts.installed,
+        includeDeprecated: opts.includeDeprecated
+      });
+      if (entries.length === 0) {
+        logger.info(
+          opts.installed ? "No ui entries installed." : "No ui entries available."
+        );
+        return;
+      }
+      const idWidth = Math.max(...entries.map((e) => e.id.length), 4);
+      const typeWidth = Math.max(...entries.map((e) => e.type.length), 4);
       logger.info(
-        opts.installed ? "No ui entries installed." : "No ui entries available."
+        `${"ID".padEnd(idWidth)}  ${"TYPE".padEnd(
+          typeWidth
+        )}  STATUS      DESCRIPTION`
       );
-      return;
-    }
-    const idWidth = Math.max(...entries.map((e) => e.id.length), 4);
-    const typeWidth = Math.max(...entries.map((e) => e.type.length), 4);
-    logger.info(
-      `${"ID".padEnd(idWidth)}  ${"TYPE".padEnd(
-        typeWidth
-      )}  STATUS   DESCRIPTION`
-    );
-    logger.info(
-      `${"\u2500".repeat(idWidth)}  ${"\u2500".repeat(
-        typeWidth
-      )}  \u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`
-    );
-    for (const e of entries) {
-      const status = e.installed ? "INSTALLED" : "\u2013";
       logger.info(
-        `${e.id.padEnd(idWidth)}  ${e.type.padEnd(
+        `${"\u2500".repeat(idWidth)}  ${"\u2500".repeat(
           typeWidth
-        )}  ${status.padEnd(7)}  ${e.description}`
+        )}  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`
       );
+      for (const e of entries) {
+        const status = e.deprecated ? e.installed ? "INST/DEPR" : "DEPRECATED" : e.installed ? "INSTALLED" : "\u2013";
+        logger.info(
+          `${e.id.padEnd(idWidth)}  ${e.type.padEnd(
+            typeWidth
+          )}  ${status.padEnd(10)}  ${e.description}`
+        );
+      }
+      logger.info("");
+      logger.info(
+        `Total: ${total} entr${total === 1 ? "y" : "ies"}, ${installedCount} installed.`
+      );
+    } catch (err) {
+      logger.error(`Failed to list ui entries: ${err.message}`);
+      logger.debug(err.stack ?? "");
+      process.exitCode = 1;
     }
-    logger.info("");
-    logger.info(
-      `Total: ${total} entr${total === 1 ? "y" : "ies"}, ${installedCount} installed.`
-    );
-  } catch (err) {
-    logger.error(`Failed to list ui entries: ${err.message}`);
-    logger.debug(err.stack ?? "");
-    process.exitCode = 1;
   }
-});
+);
 
 // src/commands/ui/index.ts
 var uiCommand = new Command17("ui").description(
@@ -2640,22 +3038,23 @@ uiCommand.addCommand(addCommand2);
 uiCommand.addCommand(listCommand3);
 
 // src/commands/biz-ui/index.ts
-import { Command as Command20 } from "commander";
+import { Command as Command21 } from "commander";
 
 // src/commands/biz-ui/add.ts
 import { Command as Command18 } from "commander";
 
 // src/core/variant-ui-add.ts
-import * as path16 from "path";
-import { createRequire as createRequire4 } from "module";
+import * as path18 from "path";
+import { createRequire as createRequire6 } from "module";
 import {
+  loadUiPackageManifest as loadUiPackageManifest2,
   loadVariantUiPackageCatalog,
   loadVariantUiPackageManifest
 } from "@teamix-evo/registry";
-var require5 = createRequire4(import.meta.url);
+var require7 = createRequire6(import.meta.url);
 function resolvePackageRoot3(packageName) {
-  const pkgJsonPath = require5.resolve(`${packageName}/package.json`);
-  return path16.dirname(pkgJsonPath);
+  const pkgJsonPath = require7.resolve(`${packageName}/package.json`);
+  return path18.dirname(pkgJsonPath);
 }
 async function runVariantUiAdd(packageName, options) {
   const { projectRoot, variant, ids, overwrite } = options;
@@ -2678,27 +3077,42 @@ async function runVariantUiAdd(packageName, options) {
       `Variant "${variant}" not found in ${fullPackageName}. Known variants: ${known}. Hint: \`teamix-evo ${packageName} list-variants\` shows all.`
     );
   }
-  const variantDir = path16.join(packageRoot, "variants", variant);
+  const variantDir = path18.join(packageRoot, "variants", variant);
   const variantManifest = await loadVariantUiPackageManifest(variantDir);
   const knownIds = new Set(variantManifest.entries.map((e) => e.id));
   const unknown = ids.filter((id) => !knownIds.has(id));
   if (unknown.length > 0) {
     throw new Error(
-      `Unknown entry id(s) in ${packageName}#${variant}: ${unknown.map((s) => `"${s}"`).join(", ")}. Run \`teamix-evo ${packageName} list --variant ${variant}\` to see options.`
+      `Unknown entry id(s) in ${packageName}#${variant}: ${unknown.map((s) => `"${s}"`).join(", ")}. Run \`teamix-evo ${packageName} list-variants\` to see this package's variants, or \`teamix-evo ${packageName} list --variant ${variant}\` for its entries.`
     );
   }
+  const uiPackageRoot = resolvePackageRoot3("@teamix-evo/ui");
+  const uiManifest = await loadUiPackageManifest2(uiPackageRoot);
+  const entryPackageRoot = /* @__PURE__ */ new Map();
+  const mergedEntries = [];
+  for (const e of variantManifest.entries) {
+    entryPackageRoot.set(e.id, variantDir);
+    mergedEntries.push(e);
+  }
+  for (const e of uiManifest.entries) {
+    if (entryPackageRoot.has(e.id)) continue;
+    entryPackageRoot.set(e.id, uiPackageRoot);
+    mergedEntries.push(e);
+  }
   const adaptedManifest = {
     schemaVersion: 1,
     package: "ui",
     version: variantManifest.version,
     engines: variantManifest.engines,
-    entries: variantManifest.entries
+    entries: mergedEntries
   };
   const result = await installUiEntries({
     projectRoot,
     manifest: adaptedManifest,
     packageRoot: variantDir,
-    // sources resolved relative to variant dir
+    // default for variant entries
+    entryPackageRoot,
+    // ui entries resolve from uiPackageRoot
     aliases: uiCfg.aliases,
     requested: ids,
     skipExisting: !overwrite
@@ -2730,7 +3144,6 @@ async function runVariantUiAdd(packageName, options) {
     orderedIds: result.orderedIds,
     written: result.written,
     skipped: result.skipped,
-    metaFiles: result.metaFiles,
     npmDependencies: result.npmDependencies,
     resources: result.resources
   };
@@ -2767,6 +3180,36 @@ async function listBizUiVariants(packageRoot) {
 async function listTemplatesVariants(packageRoot) {
   return listVariantUi("templates", packageRoot);
 }
+async function listVariantUiEntries(packageName, variant, packageRoot) {
+  const fullPackageName = `@teamix-evo/${packageName}`;
+  const root = packageRoot ?? resolvePackageRoot3(fullPackageName);
+  const catalog = await loadVariantUiPackageCatalog(root);
+  if (!catalog.variants.some((v) => v.name === variant)) {
+    const known = catalog.variants.map((v) => v.name).join(", ");
+    throw new Error(
+      `Variant "${variant}" not found in ${fullPackageName}. Known: ${known}.`
+    );
+  }
+  const variantDir = path18.join(root, "variants", variant);
+  const variantManifest = await loadVariantUiPackageManifest(variantDir);
+  return {
+    packageName: fullPackageName,
+    variant,
+    entries: variantManifest.entries.map((e) => ({
+      id: e.id,
+      name: e.name,
+      type: e.type,
+      description: e.description,
+      registryDependencies: e.registryDependencies ?? []
+    }))
+  };
+}
+async function listBizUiEntries(variant, packageRoot) {
+  return listVariantUiEntries("biz-ui", variant, packageRoot);
+}
+async function listTemplatesEntries(variant, packageRoot) {
+  return listVariantUiEntries("templates", variant, packageRoot);
+}
 
 // src/commands/biz-ui/add.ts
 var addCommand3 = new Command18("add").description(
@@ -2781,6 +3224,12 @@ var addCommand3 = new Command18("add").description(
       }
       const ide = detectIde();
       const projectRoot = ide.getProjectRoot();
+      const projectVariant = await readTokensVariant(projectRoot);
+      if (projectVariant && projectVariant !== opts.variant) {
+        throw new Error(
+          `Variant mismatch \u2014 project is locked to "${projectVariant}" but you requested "${opts.variant}". Fix: run \`teamix-evo tokens uninstall -y\` then \`teamix-evo tokens init ${opts.variant}\` to switch, or re-run with \`--variant ${projectVariant}\` to install for the current variant.`
+        );
+      }
       logger.info(
         `Installing biz-ui entries from variant "${opts.variant}": ${ids.join(", ")}`
       );
@@ -2791,7 +3240,7 @@ var addCommand3 = new Command18("add").description(
         overwrite: opts.overwrite
       });
       logger.success(
-        `biz-ui add complete: ${result.written} written, ${result.skipped} skipped, ${result.metaFiles.length} meta.`
+        `biz-ui add complete: ${result.written} written, ${result.skipped} skipped.`
       );
       logger.info("");
       logger.info(`Variant: ${result.variant}`);
@@ -2811,9 +3260,35 @@ var addCommand3 = new Command18("add").description(
   }
 );
 
-// src/commands/biz-ui/list-variants.ts
+// src/commands/biz-ui/list.ts
 import { Command as Command19 } from "commander";
-var listVariantsCommand2 = new Command19("list-variants").description("\u5217\u51FA @teamix-evo/biz-ui \u5305\u5185\u63D0\u4F9B\u7684\u6240\u6709\u4E1A\u52A1\u53D8\u4F53").action(async () => {
+var listCommand4 = new Command19("list").description("\u5217\u51FA\u6307\u5B9A\u53D8\u4F53\u4E0B\u7684 biz-ui entries").requiredOption("--variant <name>", "\u53D8\u4F53\u540D\uFF08\u5982 opentrek / uni-manager\uFF09").action(async (opts) => {
+  try {
+    const result = await listBizUiEntries(opts.variant);
+    logger.info(`${result.packageName}#${result.variant} entries:`);
+    logger.info("");
+    if (result.entries.length === 0) {
+      logger.info("  (no entries \u2014 variant skeleton, awaiting components)");
+      return;
+    }
+    for (const e of result.entries) {
+      const deps = e.registryDependencies.length ? ` [deps: ${e.registryDependencies.join(", ")}]` : "";
+      logger.info(`  ${e.id} (${e.type})${deps}`);
+      if (e.description) logger.info(`    ${e.description}`);
+      logger.info("");
+    }
+    logger.info(
+      `Install: teamix-evo biz-ui add <id> --variant ${result.variant}`
+    );
+  } catch (err) {
+    logger.error(`Failed: ${err.message}`);
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/biz-ui/list-variants.ts
+import { Command as Command20 } from "commander";
+var listVariantsCommand2 = new Command20("list-variants").description("\u5217\u51FA @teamix-evo/biz-ui \u5305\u5185\u63D0\u4F9B\u7684\u6240\u6709\u4E1A\u52A1\u53D8\u4F53").action(async () => {
   try {
     const result = await listBizUiVariants();
     logger.info(`Available biz-ui variants in ${result.packageName}:`);
@@ -2835,18 +3310,19 @@ var listVariantsCommand2 = new Command19("list-variants").description("\u5217\u5
 });
 
 // src/commands/biz-ui/index.ts
-var bizUiCommand = new Command20("biz-ui").description(
+var bizUiCommand = new Command21("biz-ui").description(
   "\u7BA1\u7406\u4E1A\u52A1 UI \u7EC4\u4EF6(\u53D8\u4F53\u611F\u77E5 \u2014 \u4E0E design / templates \u540C\u53D8\u4F53\u540D\u7A7A\u95F4)"
 );
 bizUiCommand.addCommand(addCommand3);
+bizUiCommand.addCommand(listCommand4);
 bizUiCommand.addCommand(listVariantsCommand2);
 
 // src/commands/templates/index.ts
-import { Command as Command23 } from "commander";
+import { Command as Command25 } from "commander";
 
 // src/commands/templates/add.ts
-import { Command as Command21 } from "commander";
-var addCommand4 = new Command21("add").description(
+import { Command as Command22 } from "commander";
+var addCommand4 = new Command22("add").description(
   "\u5B89\u88C5\u4E00\u4E2A\u6216\u591A\u4E2A\u9875\u9762\u6A21\u677F(\u6309 id,\u81EA\u52A8\u5C55\u5F00 ui \u5305\u7684 registryDependencies)"
 ).argument("<ids...>", '\u6A21\u677F id \u5217\u8868,\u5982 "list-detail-page"').option("--variant <name>", '\u53D8\u4F53 id(\u5FC5\u586B,\u5982 "opentrek"\u3001"uni-manager")').option("--overwrite", "\u5373\u4F7F\u76EE\u6807\u6587\u4EF6\u5DF2\u5B58\u5728\u4E5F\u8986\u76D6").action(
   async (ids, opts) => {
@@ -2858,6 +3334,12 @@ var addCommand4 = new Command21("add").description(
       }
       const ide = detectIde();
       const projectRoot = ide.getProjectRoot();
+      const projectVariant = await readTokensVariant(projectRoot);
+      if (projectVariant && projectVariant !== opts.variant) {
+        throw new Error(
+          `Variant mismatch \u2014 project is locked to "${projectVariant}" but you requested "${opts.variant}". Fix: run \`teamix-evo tokens uninstall -y\` then \`teamix-evo tokens init ${opts.variant}\` to switch, or re-run with \`--variant ${projectVariant}\` to install for the current variant.`
+        );
+      }
       logger.info(
         `Installing templates from variant "${opts.variant}": ${ids.join(", ")}`
       );
@@ -2868,7 +3350,7 @@ var addCommand4 = new Command21("add").description(
         overwrite: opts.overwrite
       });
       logger.success(
-        `templates add complete: ${result.written} written, ${result.skipped} skipped, ${result.metaFiles.length} meta.`
+        `templates add complete: ${result.written} written, ${result.skipped} skipped.`
       );
       logger.info("");
       logger.info(`Variant: ${result.variant}`);
@@ -2888,9 +3370,35 @@ var addCommand4 = new Command21("add").description(
   }
 );
 
+// src/commands/templates/list.ts
+import { Command as Command23 } from "commander";
+var listCommand5 = new Command23("list").description("\u5217\u51FA\u6307\u5B9A\u53D8\u4F53\u4E0B\u7684 templates entries").requiredOption("--variant <name>", "\u53D8\u4F53\u540D\uFF08\u5982 opentrek / uni-manager\uFF09").action(async (opts) => {
+  try {
+    const result = await listTemplatesEntries(opts.variant);
+    logger.info(`${result.packageName}#${result.variant} entries:`);
+    logger.info("");
+    if (result.entries.length === 0) {
+      logger.info("  (no entries \u2014 variant skeleton, awaiting templates)");
+      return;
+    }
+    for (const e of result.entries) {
+      const deps = e.registryDependencies.length ? ` [deps: ${e.registryDependencies.join(", ")}]` : "";
+      logger.info(`  ${e.id} (${e.type})${deps}`);
+      if (e.description) logger.info(`    ${e.description}`);
+      logger.info("");
+    }
+    logger.info(
+      `Install: teamix-evo templates add <id> --variant ${result.variant}`
+    );
+  } catch (err) {
+    logger.error(`Failed: ${err.message}`);
+    process.exitCode = 1;
+  }
+});
+
 // src/commands/templates/list-variants.ts
-import { Command as Command22 } from "commander";
-var listVariantsCommand3 = new Command22("list-variants").description("\u5217\u51FA @teamix-evo/templates \u5305\u5185\u63D0\u4F9B\u7684\u6240\u6709\u9875\u9762\u6A21\u677F\u53D8\u4F53").action(async () => {
+import { Command as Command24 } from "commander";
+var listVariantsCommand3 = new Command24("list-variants").description("\u5217\u51FA @teamix-evo/templates \u5305\u5185\u63D0\u4F9B\u7684\u6240\u6709\u9875\u9762\u6A21\u677F\u53D8\u4F53").action(async () => {
   try {
     const result = await listTemplatesVariants();
     logger.info(`Available templates variants in ${result.packageName}:`);
@@ -2912,21 +3420,427 @@ var listVariantsCommand3 = new Command22("list-variants").description("\u5217\u5
 });
 
 // src/commands/templates/index.ts
-var templatesCommand = new Command23("templates").description(
+var templatesCommand = new Command25("templates").description(
   "\u7BA1\u7406\u9875\u9762\u6A21\u677F(\u53D8\u4F53\u611F\u77E5 \u2014 \u4E0E design / biz-ui \u540C\u53D8\u4F53\u540D\u7A7A\u95F4)"
 );
 templatesCommand.addCommand(addCommand4);
+templatesCommand.addCommand(listCommand5);
 templatesCommand.addCommand(listVariantsCommand3);
 
+// src/commands/logs/index.ts
+import { Command as Command28 } from "commander";
+
+// src/commands/logs/analyze.ts
+import { Command as Command26 } from "commander";
+import { readFileSync, readdirSync, existsSync as existsSync2, statSync } from "fs";
+import { resolve as resolve3, join as join17 } from "path";
+var DATE_DIR_RE = /^\d{4}-\d{2}-\d{2}$/;
+var logsAnalyzeCommand = new Command26("analyze").description(
+  "\u6C47\u603B vibe-logger \u8F93\u51FA (.log/ai/**/*.jsonl) \u2014 \u5DE5\u5177 / \u5305\u6807\u7B7E / MCP \u8C03\u7528\u9891\u7387,\u8F85\u52A9\u751F\u6001\u4F18\u5316"
+).option("--dir <path>", "log \u76EE\u5F55 (\u9ED8\u8BA4 <project>/.log/ai)").option(
+  "--days <n>",
+  "\u53EA\u770B\u6700\u8FD1 N \u5929\u7684\u76EE\u5F55 (\u9ED8\u8BA4\u5168\u90E8;\u6309\u76EE\u5F55\u540D YYYY-MM-DD \u6BD4\u5BF9,\u4E0D\u89E3\u6790\u8BB0\u5F55 ts)"
+).option("--top <n>", "\u6BCF\u4E2A\u6392\u884C\u5C55\u793A\u524D N \u9879 (\u9ED8\u8BA4 10)", "10").option("--json", "\u4EE5 JSON \u8F93\u51FA (CI/\u5DE5\u5177\u53CB\u597D)").action((opts) => {
+  const baseDir = resolve3(opts.dir ?? join17(process.cwd(), ".log", "ai"));
+  if (!existsSync2(baseDir)) {
+    logger.warn(`No log directory at ${baseDir}.`);
+    logger.info(
+      "\u8FD0\u884C vibe-logger hook \u89E6\u53D1\u540E\u4F1A\u5728\u6B64\u76EE\u5F55\u751F\u6210 JSONL \u2014 \u89C1 .claude/scripts/vibe-logger.mjs"
+    );
+    return;
+  }
+  const dayLimit = parseIntOrUndef(opts.days);
+  const top = parseIntOrUndef(opts.top) ?? 10;
+  const dayDirs = readdirSync(baseDir, { withFileTypes: true }).filter((e) => e.isDirectory() && DATE_DIR_RE.test(e.name)).map((e) => e.name).sort().reverse();
+  const selected = dayLimit !== void 0 ? dayDirs.slice(0, dayLimit) : dayDirs;
+  const records = [];
+  for (const day of selected) {
+    const dayPath = join17(baseDir, day);
+    let entries;
+    try {
+      entries = readdirSync(dayPath);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".jsonl")) continue;
+      const fp = join17(dayPath, entry);
+      try {
+        if (!statSync(fp).isFile()) continue;
+      } catch {
+        continue;
+      }
+      const text2 = readFileSync(fp, "utf8");
+      for (const line of text2.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          records.push(JSON.parse(line));
+        } catch {
+        }
+      }
+    }
+  }
+  const report = buildReport(records, top);
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    return;
+  }
+  printReport(baseDir, selected.length, report);
+});
+function buildReport(records, top) {
+  const byAgent = {};
+  const byEvent = {};
+  const tools = /* @__PURE__ */ new Map();
+  const tags = /* @__PURE__ */ new Map();
+  const mcp = /* @__PURE__ */ new Map();
+  const sessions = /* @__PURE__ */ new Set();
+  const filesTouched = /* @__PURE__ */ new Set();
+  const errors = [];
+  let from = null;
+  let to = null;
+  for (const r of records) {
+    if (!from || r.ts < from) from = r.ts;
+    if (!to || r.ts > to) to = r.ts;
+    byAgent[r.agent] = (byAgent[r.agent] ?? 0) + 1;
+    byEvent[r.event] = (byEvent[r.event] ?? 0) + 1;
+    sessions.add(`${r.agent}::${r.session}`);
+    if (r.file) filesTouched.add(r.file);
+    if (r.tool) {
+      tools.set(r.tool, (tools.get(r.tool) ?? 0) + 1);
+      if (r.tool.startsWith("mcp__")) {
+        const name = r.tool.replace(/^mcp__[^_]+__/, "");
+        const slot = mcp.get(name) ?? { count: 0, keys: /* @__PURE__ */ new Set() };
+        slot.count += 1;
+        for (const k of r.mcpArgs ?? []) slot.keys.add(k);
+        mcp.set(name, slot);
+      }
+    }
+    for (const tag of r.tags ?? []) {
+      tags.set(tag, (tags.get(tag) ?? 0) + 1);
+    }
+    if (r.error) {
+      errors.push({
+        ts: r.ts,
+        tool: r.tool,
+        file: r.file,
+        session: r.session
+      });
+    }
+  }
+  const topTools = sortAndSlice(tools, top).map(([tool, count]) => ({
+    tool,
+    count
+  }));
+  const topTags = sortAndSlice(tags, top).map(([tag, count]) => ({
+    tag,
+    count
+  }));
+  const topMcp = [...mcp.entries()].sort((a, b) => b[1].count - a[1].count).slice(0, top).map(([name, v]) => ({
+    name,
+    count: v.count,
+    argKeys: [...v.keys].sort()
+  }));
+  const recentErrors = errors.slice(-10);
+  return {
+    range: { from, to },
+    totals: {
+      records: records.length,
+      sessions: sessions.size,
+      errors: errors.length,
+      files: filesTouched.size
+    },
+    byAgent,
+    byEvent,
+    topTools,
+    topTags,
+    topMcp,
+    recentErrors
+  };
+}
+function sortAndSlice(m, top) {
+  return [...m.entries()].sort((a, b) => b[1] - a[1]).slice(0, top);
+}
+function printReport(baseDir, dayCount, r) {
+  logger.info(`vibe-logger \u5206\u6790\u62A5\u544A`);
+  logger.info(`  \u76EE\u5F55:  ${baseDir}`);
+  logger.info(`  \u5929\u6570:  ${dayCount}`);
+  logger.info(`  \u65F6\u95F4:  ${r.range.from ?? "-"} \u2192 ${r.range.to ?? "-"}`);
+  logger.info("");
+  logger.info(
+    `Totals  records=${r.totals.records}  sessions=${r.totals.sessions}  errors=${r.totals.errors}  files=${r.totals.files}`
+  );
+  logger.info(`By agent  ${formatKv(r.byAgent)}`);
+  logger.info(`By event  ${formatKv(r.byEvent)}`);
+  logger.info("");
+  logger.info("Top tools:");
+  for (const { tool, count } of r.topTools) {
+    logger.info(`  ${pad(count, 5)}  ${tool}`);
+  }
+  if (r.topTags.length) {
+    logger.info("");
+    logger.info("Top package tags (which package the AI touched):");
+    for (const { tag, count } of r.topTags) {
+      logger.info(`  ${pad(count, 5)}  ${tag}`);
+    }
+  }
+  if (r.topMcp.length) {
+    logger.info("");
+    logger.info("Top MCP tools:");
+    for (const { name, count, argKeys } of r.topMcp) {
+      const keys = argKeys.length ? `  args: ${argKeys.join(", ")}` : "";
+      logger.info(`  ${pad(count, 5)}  ${name}${keys}`);
+    }
+  }
+  if (r.recentErrors.length) {
+    logger.info("");
+    logger.info(`Recent errors (last ${r.recentErrors.length}):`);
+    for (const e of r.recentErrors) {
+      logger.info(
+        `  ${e.ts}  session=${e.session}  tool=${e.tool ?? "-"}  file=${e.file ?? "-"}`
+      );
+    }
+  }
+}
+function formatKv(o) {
+  return Object.entries(o).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}=${v}`).join("  ");
+}
+function pad(n, width) {
+  const s = String(n);
+  return s.length >= width ? s : " ".repeat(width - s.length) + s;
+}
+function parseIntOrUndef(v) {
+  if (v === void 0) return void 0;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+
+// src/commands/logs/trace.ts
+import { Command as Command27 } from "commander";
+import { readFileSync as readFileSync2, readdirSync as readdirSync2, existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { resolve as resolve4, join as join18 } from "path";
+var DATE_DIR_RE2 = /^\d{4}-\d{2}-\d{2}$/;
+var logsTraceCommand = new Command27("trace").description(
+  "\u6309\u4F1A\u8BDD\u8FD8\u539F AI \u8C03\u7528\u94FE\u8DEF:\u4ECE\u7528\u6237 prompt \u8D77\u59CB,\u4E32\u8054\u540E\u7EED PreToolUse/PostToolUse \u76F4\u5230\u4E0B\u4E00\u4E2A prompt \u6216 Stop"
+).option("--prompt <keyword>", "\u6309\u7528\u6237\u8F93\u5165\u5173\u952E\u5B57\u8FC7\u6EE4 (\u5B50\u4E32\u5339\u914D,\u4E0D\u533A\u5206\u5927\u5C0F\u5199)").option("--session <id>", "\u6307\u5B9A\u4F1A\u8BDD ID (\u524D\u7F00\u5339\u914D)").option("--days <n>", "\u53EA\u770B\u6700\u8FD1 N \u5929\u7684\u76EE\u5F55 (\u9ED8\u8BA4 7)", "7").option("--dir <path>", "log \u76EE\u5F55 (\u9ED8\u8BA4 <project>/.log/ai)").option("--json", "\u4EE5 JSON \u8F93\u51FA (CI/\u5DE5\u5177\u53CB\u597D)").action((opts) => {
+  const baseDir = resolve4(opts.dir ?? join18(process.cwd(), ".log", "ai"));
+  if (!existsSync3(baseDir)) {
+    logger.warn(`No log directory at ${baseDir}.`);
+    logger.info(
+      "\u8FD0\u884C vibe-logger hook \u89E6\u53D1\u540E\u4F1A\u5728\u6B64\u76EE\u5F55\u751F\u6210 JSONL \u2014 \u89C1 .claude/scripts/vibe-logger.mjs"
+    );
+    return;
+  }
+  const dayLimit = parseIntOrUndef2(opts.days) ?? 7;
+  const records = readRecords(baseDir, dayLimit);
+  const report = buildTrace(records, {
+    prompt: opts.prompt,
+    session: opts.session
+  });
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    return;
+  }
+  printTrace(baseDir, report);
+});
+function readRecords(baseDir, dayLimit) {
+  const dayDirs = readdirSync2(baseDir, { withFileTypes: true }).filter((e) => e.isDirectory() && DATE_DIR_RE2.test(e.name)).map((e) => e.name).sort().reverse();
+  const selected = dayDirs.slice(0, dayLimit);
+  const records = [];
+  for (const day of selected) {
+    const dayPath = join18(baseDir, day);
+    let entries;
+    try {
+      entries = readdirSync2(dayPath);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".jsonl")) continue;
+      const fp = join18(dayPath, entry);
+      try {
+        if (!statSync2(fp).isFile()) continue;
+      } catch {
+        continue;
+      }
+      const text2 = readFileSync2(fp, "utf8");
+      for (const line of text2.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          records.push(JSON.parse(line));
+        } catch {
+        }
+      }
+    }
+  }
+  return records;
+}
+function buildTrace(records, filter = {}) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    if (!r.session) continue;
+    const arr = groups.get(r.session) ?? [];
+    arr.push(r);
+    groups.set(r.session, arr);
+  }
+  const promptNeedle = filter.prompt?.toLowerCase();
+  const sessionPrefix = filter.session;
+  const sessions = [];
+  for (const [sessionId, items] of groups.entries()) {
+    if (sessionPrefix && !sessionId.startsWith(sessionPrefix)) continue;
+    items.sort((a, b) => a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0);
+    const chains = [];
+    let current = null;
+    let pending = /* @__PURE__ */ new Map();
+    const closeCurrent = () => {
+      if (current) chains.push(current);
+      current = null;
+      pending = /* @__PURE__ */ new Map();
+    };
+    for (const r of items) {
+      if (r.event === "UserPromptSubmit") {
+        if (current) closeCurrent();
+        current = { prompt: r.prompt ?? "", promptTs: r.ts, steps: [] };
+        pending = /* @__PURE__ */ new Map();
+        continue;
+      }
+      if (r.event === "Stop") {
+        if (current) closeCurrent();
+        continue;
+      }
+      if (!current) continue;
+      if (r.event === "PreToolUse") {
+        const idx = current.steps.length;
+        current.steps.push({
+          ts: r.ts,
+          event: "PreToolUse",
+          tool: r.tool,
+          file: r.file,
+          tags: r.tags,
+          duration_ms: r.duration_ms,
+          error: r.error ?? false
+        });
+        if (r.tool) {
+          const list = pending.get(r.tool) ?? [];
+          list.push(idx);
+          pending.set(r.tool, list);
+        }
+      } else if (r.event === "PostToolUse") {
+        const list = r.tool ? pending.get(r.tool) : void 0;
+        if (list && list.length > 0) {
+          const idx = list.shift();
+          if (list.length === 0 && r.tool) pending.delete(r.tool);
+          const step = current.steps[idx];
+          if (r.duration_ms !== void 0) step.duration_ms = r.duration_ms;
+          if (r.error !== void 0) step.error = r.error;
+          if (!step.file && r.file) step.file = r.file;
+          if ((!step.tags || step.tags.length === 0) && r.tags)
+            step.tags = r.tags;
+        } else {
+          current.steps.push({
+            ts: r.ts,
+            event: "PostToolUse",
+            tool: r.tool,
+            file: r.file,
+            tags: r.tags,
+            duration_ms: r.duration_ms,
+            error: r.error ?? false
+          });
+        }
+      }
+    }
+    if (current) closeCurrent();
+    const filteredChains = promptNeedle ? chains.filter((c) => c.prompt.toLowerCase().includes(promptNeedle)) : chains;
+    if (filteredChains.length === 0) continue;
+    sessions.push({
+      id: sessionId,
+      agent: items[0]?.agent ?? "unknown",
+      chains: filteredChains
+    });
+  }
+  sessions.sort((a, b) => {
+    const ta = a.chains[0]?.promptTs ?? "";
+    const tb = b.chains[0]?.promptTs ?? "";
+    return tb.localeCompare(ta);
+  });
+  return { sessions };
+}
+function printTrace(baseDir, r) {
+  logger.info(`vibe-logger \u94FE\u8DEF\u8FFD\u8E2A`);
+  logger.info(`  \u76EE\u5F55:  ${baseDir}`);
+  logger.info(`  \u4F1A\u8BDD:  ${r.sessions.length}`);
+  logger.info("");
+  if (r.sessions.length === 0) {
+    logger.info("\u672A\u627E\u5230\u5339\u914D\u7684\u4F1A\u8BDD/\u63D0\u793A\u3002");
+    return;
+  }
+  for (const s of r.sessions) {
+    logger.info(`\u2501\u2501\u2501 Session: ${s.id} (${s.agent}) \u2501\u2501\u2501`);
+    logger.info("");
+    for (const c of s.chains) {
+      logger.info(
+        `[${formatTime(c.promptTs)}] \u{1F4AC} Prompt: ${quote(truncate(c.prompt, 200))}`
+      );
+      for (const step of c.steps) {
+        logger.info(`  ${formatStep(step)}`);
+      }
+      logger.info("");
+    }
+  }
+}
+function formatStep(s) {
+  const ts = `[${formatTime(s.ts)}]`;
+  const isEdit = s.tool === "Edit" || s.tool === "Write" || s.tool === "MultiEdit" || s.tool === "create_file" || s.tool === "search_replace";
+  const icon = isEdit ? "\u{1F4DD}" : "\u{1F527}";
+  const head = isEdit && s.file ? `${s.tool ?? "?"} \u2192 ${s.file}` : s.tool ?? s.event ?? "?";
+  const dur = s.duration_ms !== void 0 ? `${s.duration_ms}ms` : "";
+  const tags = s.tags && s.tags.length ? `[${s.tags.join(",")}]` : "";
+  const err = s.error ? "\u274C" : "";
+  return [ts, icon, padRight(head, 40), padLeft(dur, 6), tags, err].filter((x) => x !== "").join(" ");
+}
+function formatTime(ts) {
+  const d = new Date(ts);
+  if (Number.isNaN(d.getTime())) return ts;
+  const hh = String(d.getUTCHours()).padStart(2, "0");
+  const mm = String(d.getUTCMinutes()).padStart(2, "0");
+  const ss = String(d.getUTCSeconds()).padStart(2, "0");
+  return `${hh}:${mm}:${ss}`;
+}
+function quote(s) {
+  return `"${s.replace(/"/g, '\\"')}"`;
+}
+function truncate(s, n) {
+  if (s.length <= n) return s;
+  return s.slice(0, n) + "\u2026";
+}
+function padRight(s, n) {
+  return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+function padLeft(s, n) {
+  return s.length >= n ? s : " ".repeat(n - s.length) + s;
+}
+function parseIntOrUndef2(v) {
+  if (v === void 0) return void 0;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+
+// src/commands/logs/index.ts
+var logsCommand = new Command28("logs").description(
+  "\u67E5\u8BE2 vibe-logger \u8F93\u51FA (.log/ai/**/*.jsonl) \u2014 AI \u8C03\u7528\u94FE\u5206\u6790"
+);
+logsCommand.addCommand(logsAnalyzeCommand);
+logsCommand.addCommand(logsTraceCommand);
+
 // src/index.ts
-var require6 = createRequire5(import.meta.url);
-var { version } = require6("../package.json");
-var program = new Command24();
+var require8 = createRequire7(import.meta.url);
+var { version } = require8("../package.json");
+var program = new Command29();
 program.name("teamix-evo").description("Where ideas evolve. \u2014 AI Coding \u5957\u4EF6").version(version);
-program.addCommand(designCommand);
+program.addCommand(tokensCommand);
 program.addCommand(skillsCommand);
 program.addCommand(uiCommand);
 program.addCommand(bizUiCommand);
 program.addCommand(templatesCommand);
+program.addCommand(logsCommand);
 program.parse();
 //# sourceMappingURL=index.js.map