teamix-evo 0.3.0 → 0.4.0

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 Command28 } from "commander";
+import { createRequire as createRequire8 } 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
-import * as path9 from "path";
+// src/core/tokens-init.ts
+import * as path8 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,7 +319,7 @@ 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";
 
@@ -401,13 +352,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 +401,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 +416,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,11 +437,19 @@ 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 existing = await readFileOrNull(targetFile);
+    if (existing !== null && existing !== sourceContent) {
+      logger.warn(
+        `Mirror drift detected at ${targetFile} \u2014 overwriting from source. Edit ${src} (not the mirror) and re-run \`teamix-evo skills sync\`.`
+      );
+    }
+    await writeFileSafe(targetFile, sourceContent);
+    records.push(
+      makeMirrorRecord(skill, targetFile, sourceContent, ide, scope, rel2)
+    );
     logger.debug(`  Mirrored ${ide}:${scope}: ${targetFile}`);
   }
   return records;
@@ -549,7 +508,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 +516,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 +530,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 +610,20 @@ 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 existing = await readFileOrNull(targetFile);
+        if (existing !== null && existing !== sourceContent) {
+          logger.warn(
+            `Mirror drift detected at ${targetFile} \u2014 overwriting from source. Edit ${src} (not the mirror) and re-run \`teamix-evo skills sync\`.`
+          );
+        }
+        await writeFileSafe(targetFile, sourceContent);
         out.push({
           id: rel2 === "SKILL.md" ? skill.id : `${skill.id}:${rel2}`,
           target: targetFile,
-          hash: computeHash(content),
+          hash: computeHash(sourceContent),
           strategy: skill.updateStrategy,
           ide,
           scope
@@ -680,12 +645,18 @@ 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;
@@ -714,7 +685,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));
@@ -745,15 +716,15 @@ async function runSkillsAdd(options) {
     skippedSkillIds = [];
     onlyIds = 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;
       }
@@ -856,85 +827,108 @@ 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) {
+  if (existingConfig?.packages?.tokens) {
+    const existingVariant = existingConfig.packages.tokens.variant;
+    if (existingVariant === variant) {
+      return { status: "already-initialized", existingVariant };
+    }
     return {
-      status: "already-initialized",
-      existingVariant: existingConfig.packages.design.variant
+      status: "variant-mismatch",
+      existingVariant,
+      requestedVariant: 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.`
+      `Tokens variant not found: "${variant}". Known variants: ${known || "(none)"}. Hint: run "teamix-evo tokens list-variants" to see all.`
     );
   }
-  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 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 = path8.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: path8.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"),
+    path8.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);
   const skills = await tryAutoInstallVariantSkills({
     projectRoot,
     variant,
@@ -944,21 +938,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 +967,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 +1014,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 = path8.join(packageRoot, fileRelToPackage);
+  const base = path8.basename(fileRelToPackage);
+  if (base === "theme.css") {
+    const targetRel = path8.posix.join(
+      CONSUMER_TOKENS_DIR,
+      CONSUMER_THEME_FILE
+    );
+    const targetAbs = path8.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 = path8.posix.join(
+      CONSUMER_TOKENS_DIR,
+      CONSUMER_OVERRIDES_FILE
+    );
+    const targetAbs = path8.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);
+  return path8.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,7 +1078,7 @@ async function listDesignVariants(packageName = DEFAULT_DESIGN_PACKAGE, packageR
   };
 }
 
-// src/commands/design/init.ts
+// 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();
@@ -1075,15 +1088,28 @@ var initCommand = new Command("init").description("\u521D\u59CB\u5316\u8BBE\u8BA
     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 +1118,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 +1137,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 +1148,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 path9 from "path";
+import * as fs7 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 = path9.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(
+    path9.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 = path9.isAbsolute(r.target) ? r.target : path9.join(projectRoot, r.target);
+        if (await fileExists(abs)) {
+          r.hash = computeHash(await fs7.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 = path9.basename(fileRel);
+    if (base !== "theme.css") continue;
+    const sourceAbs = path9.join(packageRoot, fileRel);
+    const targetAbs = path9.join(
+      projectRoot,
+      CONSUMER_TOKENS_DIR2,
+      CONSUMER_THEME_FILE2
+    );
+    const content = await fs7.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 path9.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 +1347,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 +1366,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 +1380,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 fs8 from "fs/promises";
 import * as path10 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) {
@@ -1253,7 +1427,7 @@ var uninstallCommand = new Command5("uninstall").description("\u5378\u8F7D\u8BBE
     for (const r of removable) {
       const target = path10.isAbsolute(r.target) ? r.target : path10.join(projectRoot, r.target);
       try {
-        await fs7.unlink(target);
+        await fs8.unlink(target);
         removed++;
       } catch (err) {
         if (err.code !== "ENOENT") {
@@ -1265,18 +1439,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 = path10.join(
+      projectRoot,
+      ".teamix-evo",
+      "tokens-lock.json"
+    );
+    try {
+      await fs8.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 +1472,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";
@@ -1304,23 +1489,29 @@ import * as prompts2 from "@clack/prompts";
 
 // src/utils/global-root.ts
 import { existsSync } from "fs";
-import * as fs8 from "fs/promises";
+import * as fs9 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 TEAMIX_DIR2 = ".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));
+  return existsSync(path11.join(dir, TEAMIX_DIR2, CONFIG_FILE2));
 }
 async function ensureGlobalMetaRoot() {
   const root = getGlobalMetaRoot();
-  await fs8.mkdir(root, { recursive: true });
+  await fs9.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(
@@ -1467,17 +1658,27 @@ var listCommand2 = new Command8("list").alias("ls").description(
 ).option("--installed", "\u4EC5\u5C55\u793A\u5DF2\u5B89\u88C5\u7684 skill\uFF08\u9690\u85CF\u672A\u5B89\u88C5\u9879\uFF09").action(async (opts) => {
   try {
     const ide = detectIde();
-    const projectRoot = ide.getProjectRoot();
+    const cwd = ide.getProjectRoot();
+    const projectRoot = resolveSkillsMaintenanceRoot(cwd);
+    if (projectRoot !== cwd) {
+      logger.info(`Using global skills meta root: ${projectRoot}`);
+    }
     const config = await readProjectConfig(projectRoot);
     const installedManifest = await readInstalledManifest(projectRoot);
     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.");
@@ -1500,9 +1701,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(
@@ -1548,7 +1753,11 @@ var FLAT_VARIANT2 = "_flat";
 var updateCommand2 = new Command9("update").description("\u66F4\u65B0\u5DF2\u5B89\u88C5\u7684 teamix-evo skills").action(async () => {
   try {
     const ide = detectIde();
-    const projectRoot = ide.getProjectRoot();
+    const cwd = ide.getProjectRoot();
+    const projectRoot = resolveSkillsMaintenanceRoot(cwd);
+    if (projectRoot !== cwd) {
+      logger.info(`Using global skills meta root: ${projectRoot}`);
+    }
     const config = await readProjectConfig(projectRoot);
     if (!config?.packages?.skills) {
       logger.error('Skills not added. Run "teamix-evo skills add" first.');
@@ -1635,12 +1844,21 @@ var updateCommand2 = new Command9("update").description("\u66F4\u65B0\u5DF2\u5B8
 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 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\uFF08\u5220\u9664\u6CE8\u5165\u5230 IDE \u7684\u6280\u80FD\u6587\u4EF6\uFF09").option("-y, --yes", "\u8DF3\u8FC7\u786E\u8BA4").action(async (opts) => {
+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"
+).argument(
+  "[ids...]",
+  "\u53EF\u9009\uFF1A\u4EC5\u5378\u8F7D\u6307\u5B9A skill id\uFF1B\u7701\u7565\u5219\u5378\u8F7D\u6574\u4E2A skills \u5305"
+).option("-y, --yes", "\u8DF3\u8FC7\u786E\u8BA4").action(async (ids, opts) => {
   try {
     const ide = detectIde();
-    const projectRoot = ide.getProjectRoot();
+    const cwd = ide.getProjectRoot();
+    const projectRoot = resolveSkillsMaintenanceRoot(cwd);
+    if (projectRoot !== cwd) {
+      logger.info(`Using global skills meta root: ${projectRoot}`);
+    }
     const config = await readProjectConfig(projectRoot);
     if (!config?.packages?.skills) {
       logger.info("Skills are not installed. Nothing to do.");
@@ -1651,53 +1869,167 @@ var uninstallCommand2 = new Command10("uninstall").description("\u5378\u8F7D\u5D
       (p) => p.package === SKILLS_PACKAGE3
     );
     const resources = pkg?.resources ?? [];
-    logger.info(
-      `Will remove ${resources.length} skill file(s) installed by ${SKILLS_PACKAGE3}.`
-    );
-    if (!opts.yes) {
-      const confirm4 = await prompts3.confirm({
-        message: "\u786E\u8BA4\u5378\u8F7D\uFF1F\u6B64\u64CD\u4F5C\u4F1A\u5220\u9664\u4E0A\u8FF0\u6587\u4EF6\u3002",
-        initialValue: false
+    if (ids.length === 0) {
+      await runFullUninstall({
+        projectRoot,
+        config,
+        installedManifest,
+        pkg,
+        resources,
+        opts
       });
-      if (prompts3.isCancel(confirm4) || !confirm4) {
-        logger.info("Cancelled.");
-        return;
-      }
-    }
-    const removed = await removeSkillFiles(resources);
-    logger.debug(`Removed ${removed.length} files`);
-    const skillsRoot = getSkillsSourceDir(projectRoot);
-    try {
-      await fs9.rm(skillsRoot, { recursive: true, force: true });
-      logger.debug(`Removed source dir ${skillsRoot}`);
-    } catch (err) {
-      logger.warn(
-        `Failed to remove ${skillsRoot}: ${err.message}`
-      );
-    }
-    if (installedManifest && pkg) {
-      installedManifest.installed = installedManifest.installed.filter(
-        (p) => p.package !== SKILLS_PACKAGE3
-      );
-      await writeInstalledManifest(projectRoot, installedManifest);
+      return;
     }
-    delete config.packages.skills;
-    await writeProjectConfig(projectRoot, config);
-    logger.success(`Uninstalled ${SKILLS_PACKAGE3}`);
-    logger.info(`  Removed: ${removed.length} files`);
-    logger.info(`  Source:  ${path12.relative(projectRoot, skillsRoot)} (cleaned)`);
+    await runPartialUninstall({
+      projectRoot,
+      installedManifest,
+      pkg,
+      resources,
+      ids,
+      opts
+    });
   } catch (err) {
     logger.error(`Failed to uninstall: ${err.message}`);
     logger.debug(err.stack ?? "");
     process.exitCode = 1;
   }
 });
+async function runFullUninstall(args) {
+  const { projectRoot, config, installedManifest, pkg, resources, opts } = args;
+  logger.info(
+    `Will remove ${resources.length} skill file(s) installed by ${SKILLS_PACKAGE3}.`
+  );
+  if (!opts.yes) {
+    const confirm4 = await prompts3.confirm({
+      message: "\u786E\u8BA4\u5378\u8F7D\uFF1F\u6B64\u64CD\u4F5C\u4F1A\u5220\u9664\u4E0A\u8FF0\u6587\u4EF6\u3002",
+      initialValue: false
+    });
+    if (prompts3.isCancel(confirm4) || !confirm4) {
+      logger.info("Cancelled.");
+      return;
+    }
+  }
+  const removed = await removeSkillFiles(resources);
+  logger.debug(`Removed ${removed.length} files`);
+  const skillsRoot = getSkillsSourceDir(projectRoot);
+  try {
+    await fs10.rm(skillsRoot, { recursive: true, force: true });
+    logger.debug(`Removed source dir ${skillsRoot}`);
+  } catch (err) {
+    logger.warn(
+      `Failed to remove ${skillsRoot}: ${err.message}`
+    );
+  }
+  if (installedManifest && pkg) {
+    installedManifest.installed = installedManifest.installed.filter(
+      (p) => p.package !== SKILLS_PACKAGE3
+    );
+    await writeInstalledManifest(projectRoot, installedManifest);
+  }
+  delete config.packages.skills;
+  await writeProjectConfig(projectRoot, config);
+  logger.success(`Uninstalled ${SKILLS_PACKAGE3}`);
+  logger.info(`  Removed: ${removed.length} files`);
+  logger.info(`  Source:  ${path12.relative(projectRoot, skillsRoot)} (cleaned)`);
+}
+async function runPartialUninstall(args) {
+  const { projectRoot, installedManifest, pkg, resources, ids, opts } = args;
+  const grouped = groupBySkillId(resources);
+  const requested = dedupe(ids);
+  const matched = requested.filter((id) => grouped.has(id));
+  const missing = requested.filter((id) => !grouped.has(id));
+  if (missing.length > 0) {
+    logger.warn(`Not installed (skipped): ${missing.join(", ")}`);
+  }
+  if (matched.length === 0) {
+    logger.info("Nothing to remove.");
+    return;
+  }
+  const toRemove = matched.flatMap(
+    (id) => grouped.get(id) ?? []
+  );
+  logger.info(
+    `Will remove ${matched.length} skill(s): ${matched.join(", ")} (${toRemove.length} file(s)).`
+  );
+  if (!opts.yes) {
+    const confirm4 = await prompts3.confirm({
+      message: "\u786E\u8BA4\u5378\u8F7D\uFF1F\u6B64\u64CD\u4F5C\u4F1A\u5220\u9664\u4E0A\u8FF0\u6587\u4EF6\u3002",
+      initialValue: false
+    });
+    if (prompts3.isCancel(confirm4) || !confirm4) {
+      logger.info("Cancelled.");
+      return;
+    }
+  }
+  const removed = await removeSkillFiles(toRemove);
+  logger.debug(`Removed ${removed.length} files`);
+  for (const id of matched) {
+    const dir = getSkillsSourceDir(projectRoot, id);
+    try {
+      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 lock = await readSkillsLock(projectRoot);
+  if (lock) {
+    for (const id of matched) delete lock.skills[id];
+    await writeSkillsLock(projectRoot, lock);
+  }
+  if (installedManifest && pkg) {
+    pkg.resources = resources.filter((r) => !matched.includes(skillIdOf(r)));
+    await writeInstalledManifest(projectRoot, installedManifest);
+  }
+  logger.success(
+    `Removed ${matched.length} skill(s): ${matched.join(", ")}`
+  );
+  logger.info(`  Files:   ${removed.length}`);
+  if (missing.length > 0) {
+    logger.info(`  Skipped: ${missing.join(", ")} (not installed)`);
+  }
+}
+function skillIdOf(r) {
+  return r.id.split(":")[0];
+}
+function groupBySkillId(records) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const id = skillIdOf(r);
+    const bucket = map.get(id);
+    if (bucket) bucket.push(r);
+    else map.set(id, [r]);
+  }
+  return map;
+}
+function dedupe(values) {
+  return Array.from(new Set(values));
+}
 
 // src/commands/skills/sync.ts
 import { Command as Command11 } from "commander";
 
 // src/core/skills-sync.ts
-import * as fs10 from "fs/promises";
+import * as path13 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 = path13.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;
@@ -1731,13 +2063,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,
@@ -1764,7 +2098,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;
@@ -1796,7 +2130,11 @@ var syncCommand = new Command11("sync").description(
 ).action(async (names, opts) => {
   try {
     const ide = detectIde();
-    const projectRoot = ide.getProjectRoot();
+    const cwd = ide.getProjectRoot();
+    const projectRoot = resolveSkillsMaintenanceRoot(cwd);
+    if (projectRoot !== cwd) {
+      logger.info(`Using global skills meta root: ${projectRoot}`);
+    }
     const ides = opts.ide ? parseIdeList2(opts.ide) : void 0;
     const scope = opts.scope ? parseScope2(opts.scope) : void 0;
     const result = await runSkillsSync({
@@ -1854,8 +2192,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 path14 from "path";
+import * as fs12 from "fs/promises";
 async function runSkillsDoctor(options) {
   const { projectRoot } = options;
   const lock = await readSkillsLock(projectRoot);
@@ -1877,8 +2215,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 = path14.relative(sourceDir, f);
+      sourceContents.set(rel2, await fs12.readFile(f, "utf-8"));
     }
     for (const ide of entry.mirroredTo) {
       const adapter = getAdapter(ide);
@@ -1899,7 +2237,7 @@ async function runSkillsDoctor(options) {
         continue;
       }
       for (const [rel2, sourceContent] of sourceContents.entries()) {
-        const mirrorFile = path13.join(mirrorDir, rel2);
+        const mirrorFile = path14.join(mirrorDir, rel2);
         if (!await fileExists(mirrorFile)) {
           findings.push({
             kind: "missing-mirror",
@@ -1911,7 +2249,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",
@@ -1932,7 +2270,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;
@@ -1945,7 +2283,11 @@ var doctorCommand = new Command12("doctor").description(
 ).action(async () => {
   try {
     const ide = detectIde();
-    const projectRoot = ide.getProjectRoot();
+    const cwd = ide.getProjectRoot();
+    const projectRoot = resolveSkillsMaintenanceRoot(cwd);
+    if (projectRoot !== cwd) {
+      logger.info(`Using global skills meta root: ${projectRoot}`);
+    }
     const result = await runSkillsDoctor({ projectRoot });
     if (result.status === "no-skills") {
       logger.info(
@@ -1993,6 +2335,35 @@ import { Command as Command14 } from "commander";
 import * as prompts4 from "@clack/prompts";
 
 // src/core/ui-init.ts
+import * as fs13 from "fs/promises";
+import { createRequire as createRequire5 } from "module";
+import * as path15 from "path";
+var require6 = createRequire5(import.meta.url);
+async function deployPreferencesCss(projectRoot) {
+  const targetDir = path15.join(projectRoot, "src");
+  const targetPath = path15.join(targetDir, "preferences.css");
+  try {
+    await fs13.access(targetPath);
+    logger.debug(`preferences.css already exists at ${targetPath}, skipping`);
+    return "skipped";
+  } catch {
+  }
+  let sourcePath;
+  try {
+    const uiPkgJson = require6.resolve("@teamix-evo/ui/package.json");
+    sourcePath = path15.join(path15.dirname(uiPkgJson), "src", "preferences.css");
+    await fs13.access(sourcePath);
+  } catch {
+    logger.debug(
+      "Could not resolve @teamix-evo/ui/src/preferences.css; skipping deploy"
+    );
+    return "source-missing";
+  }
+  await fs13.mkdir(targetDir, { recursive: true });
+  const content = await fs13.readFile(sourcePath, "utf-8");
+  await fs13.writeFile(targetPath, content, "utf-8");
+  return "deployed";
+}
 var DEFAULT_UI_ALIASES = {
   components: "src/components/ui",
   hooks: "src/hooks",
@@ -2036,12 +2407,14 @@ async function runUiInit(options) {
     rsc
   };
   await writeProjectConfig(projectRoot, config);
+  const preferencesCss = await deployPreferencesCss(projectRoot);
   return {
     status: "installed",
     aliases,
     iconLibrary,
     tsx,
-    rsc
+    rsc,
+    preferencesCss
   };
 }
 
@@ -2078,6 +2451,14 @@ var initCommand2 = new Command14("init").description(
     logger.info(`  lib:        ${result.aliases.lib}`);
     logger.info(`  iconLibrary: ${result.iconLibrary}`);
     logger.info(`  tsx: ${result.tsx}, rsc: ${result.rsc}`);
+    if (result.preferencesCss === "deployed") {
+      logger.info("  preferences.css: deployed \u2192 src/preferences.css");
+      logger.info(
+        "    \u5728 src/index.css \u9876\u90E8\u52A0 `@import './preferences.css';` \u542F\u7528 shadcn \u5168\u5C40\u504F\u597D"
+      );
+    } else if (result.preferencesCss === "skipped") {
+      logger.info("  preferences.css: \u5DF2\u5B58\u5728,\u4FDD\u7559\u7528\u6237\u7248\u672C");
+    }
     logger.info("");
     logger.info("Next: `npx teamix-evo ui add button`");
   } catch (err) {
@@ -2156,23 +2537,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 fs14 from "fs/promises";
+import { createRequire as createRequire6 } from "module";
 import { loadUiPackageManifest } from "@teamix-evo/registry";
-var require4 = createRequire3(import.meta.url);
+var require7 = createRequire6(import.meta.url);
 function resolvePackageRoot2(packageName) {
-  const pkgJsonPath = require4.resolve(`${packageName}/package.json`);
-  return path14.dirname(pkgJsonPath);
+  const pkgJsonPath = require7.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 fs14.readFile(dataPath, "utf-8");
     data = JSON.parse(raw);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -2184,8 +2565,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 fs15 from "fs/promises";
 import { resolveUiEntryOrder } from "@teamix-evo/registry";
 
 // src/utils/transform-imports.ts
@@ -2225,12 +2606,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
@@ -2239,7 +2620,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) {
@@ -2258,8 +2638,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 fs15.readFile(sourceAbs, "utf-8");
       const transformed = rewriteImports(raw, aliases);
       await writeFileSafe(targetAbs, transformed);
       written++;
@@ -2271,32 +2652,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) {
@@ -2306,10 +2668,10 @@ 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
@@ -2371,7 +2733,6 @@ async function runUiAdd(options) {
     orderedIds: result.orderedIds,
     written: result.written,
     skipped: result.skipped,
-    metaFiles: result.metaFiles,
     npmDependencies: result.npmDependencies,
     resources: result.resources
   };
@@ -2397,7 +2758,7 @@ var addCommand2 = new Command15("add").description(
       overwrite: opts.overwrite
     });
     logger.success(
-      `UI add complete: ${result.written} written, ${result.skipped} skipped, ${result.metaFiles.length} meta.`
+      `UI add complete: ${result.written} written, ${result.skipped} skipped.`
     );
     logger.info("");
     logger.info(`Resolved order: ${result.orderedIds.join(" \u2192 ")}`);
@@ -2409,12 +2770,6 @@ var addCommand2 = new Command15("add").description(
       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)."
-      );
-    }
   } catch (err) {
     const message = err.message;
     if (message.startsWith("UI not initialized")) {
@@ -2514,22 +2869,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 createRequire7 } from "module";
 import {
+  loadUiPackageManifest as loadUiPackageManifest2,
   loadVariantUiPackageCatalog,
   loadVariantUiPackageManifest
 } from "@teamix-evo/registry";
-var require5 = createRequire4(import.meta.url);
+var require8 = createRequire7(import.meta.url);
 function resolvePackageRoot3(packageName) {
-  const pkgJsonPath = require5.resolve(`${packageName}/package.json`);
-  return path16.dirname(pkgJsonPath);
+  const pkgJsonPath = require8.resolve(`${packageName}/package.json`);
+  return path18.dirname(pkgJsonPath);
 }
 async function runVariantUiAdd(packageName, options) {
   const { projectRoot, variant, ids, overwrite } = options;
@@ -2552,27 +2908,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
@@ -2604,7 +2975,6 @@ async function runVariantUiAdd(packageName, options) {
     orderedIds: result.orderedIds,
     written: result.written,
     skipped: result.skipped,
-    metaFiles: result.metaFiles,
     npmDependencies: result.npmDependencies,
     resources: result.resources
   };
@@ -2641,6 +3011,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(
@@ -2665,7 +3065,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}`);
@@ -2685,9 +3085,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}:`);
@@ -2709,18 +3135,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) => {
@@ -2742,7 +3169,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}`);
@@ -2762,9 +3189,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}:`);
@@ -2786,21 +3239,216 @@ 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 Command27 } 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/index.ts
+var logsCommand = new Command27("logs").description(
+  "\u67E5\u8BE2 vibe-logger \u8F93\u51FA (.log/ai/**/*.jsonl) \u2014 AI \u8C03\u7528\u94FE\u5206\u6790"
+);
+logsCommand.addCommand(logsAnalyzeCommand);
+
 // src/index.ts
-var require6 = createRequire5(import.meta.url);
-var { version } = require6("../package.json");
-var program = new Command24();
+var require9 = createRequire8(import.meta.url);
+var { version } = require9("../package.json");
+var program = new Command28();
 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