teamix-evo 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command15 } from "commander";
-import { createRequire as createRequire4 } from "module";
+import { Command as Command24 } from "commander";
+import { createRequire as createRequire5 } from "module";
 
 // src/commands/design/index.ts
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 
 // src/commands/design/init.ts
 import { Command } from "commander";
@@ -66,11 +66,19 @@ function detectIde() {
   return new QoderAdapter();
 }
 
-// src/core/registry-client.ts
-import * as path3 from "path";
+// src/core/design-init.ts
+import * as path9 from "path";
+import * as fs6 from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import {
+  loadDesignPack,
+  loadDesignPackageManifest,
+  mergeDefaultAndVariant
+} from "@teamix-evo/registry";
+
+// src/utils/fs.ts
 import * as fs from "fs/promises";
-import { createRequire } from "module";
-import { loadVariantManifest } from "@teamix-evo/registry";
+import * as path3 from "path";
 
 // src/utils/logger.ts
 import { red, yellow, cyan, green, gray } from "kolorist";
@@ -95,52 +103,20 @@ var logger = {
   }
 };
 
-// src/core/registry-client.ts
-var require2 = createRequire(import.meta.url);
-function resolvePackageRoot(packageName) {
-  const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
-  return path3.dirname(pkgJsonPath);
-}
-async function loadVariantData(packageName, variant) {
-  const packageRoot = resolvePackageRoot(packageName);
-  const variantDir = path3.join(packageRoot, "library", variant);
-  logger.debug(`Resolved variant dir: ${variantDir}`);
-  logger.debug(`Package root: ${packageRoot}`);
-  const manifest = await loadVariantManifest(variantDir);
-  let data = {};
-  const dataPath = path3.join(variantDir, "_data.json");
-  try {
-    const raw = await fs.readFile(dataPath, "utf-8");
-    data = JSON.parse(raw);
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      throw err;
-    }
-    logger.debug(`No _data.json found at ${dataPath}, using empty data`);
-  }
-  return { manifest, data, variantDir, packageRoot };
-}
-
-// src/core/installer.ts
-import * as path6 from "path";
-import * as fs5 from "fs/promises";
-
 // src/utils/fs.ts
-import * as fs2 from "fs/promises";
-import * as path4 from "path";
 async function ensureDir(dir) {
-  await fs2.mkdir(dir, { recursive: true });
+  await fs.mkdir(dir, { recursive: true });
 }
 async function writeFileSafe(filePath, content) {
-  const dir = path4.dirname(filePath);
+  const dir = path3.dirname(filePath);
   await ensureDir(dir);
   const tmp = filePath + ".tmp";
-  await fs2.writeFile(tmp, content, "utf-8");
-  await fs2.rename(tmp, filePath);
+  await fs.writeFile(tmp, content, "utf-8");
+  await fs.rename(tmp, filePath);
 }
 async function readFileOrNull(filePath) {
   try {
-    return await fs2.readFile(filePath, "utf-8");
+    return await fs.readFile(filePath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return null;
@@ -154,21 +130,21 @@ async function backupFile(filePath, projectRoot) {
     logger.debug(`Skip backup: ${filePath} does not exist`);
     return;
   }
-  const rel2 = path4.relative(projectRoot, filePath);
+  const rel2 = path3.relative(projectRoot, filePath);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupPath = path4.join(
+  const backupPath = path3.join(
     projectRoot,
     ".teamix-evo",
     ".backups",
     `${rel2}.${timestamp}.bak`
   );
-  await ensureDir(path4.dirname(backupPath));
-  await fs2.writeFile(backupPath, content, "utf-8");
-  logger.debug(`Backed up ${rel2} \u2192 ${path4.relative(projectRoot, backupPath)}`);
+  await ensureDir(path3.dirname(backupPath));
+  await fs.writeFile(backupPath, content, "utf-8");
+  logger.debug(`Backed up ${rel2} \u2192 ${path3.relative(projectRoot, backupPath)}`);
 }
 async function fileExists(filePath) {
   try {
-    await fs2.access(filePath);
+    await fs.access(filePath);
     return true;
   } catch {
     return false;
@@ -182,157 +158,71 @@ function computeHash(content) {
   return `sha256:${hash}`;
 }
 
-// src/utils/template.ts
-import Handlebars from "handlebars";
-import * as fs3 from "fs/promises";
-Handlebars.registerHelper("lowercase", (str) => {
-  return typeof str === "string" ? str.toLowerCase() : String(str ?? "").toLowerCase();
-});
-var compiledCache = /* @__PURE__ */ new Map();
-var MAX_CACHE_SIZE = 64;
-function getCompiledTemplate(templateContent) {
-  let compiled = compiledCache.get(templateContent);
-  if (!compiled) {
-    if (compiledCache.size >= MAX_CACHE_SIZE) {
-      const firstKey = compiledCache.keys().next().value;
-      compiledCache.delete(firstKey);
-    }
-    compiled = Handlebars.compile(templateContent, { noEscape: true });
-    compiledCache.set(templateContent, compiled);
-  }
-  return compiled;
-}
-function renderTemplate(templateContent, data) {
-  const compiled = getCompiledTemplate(templateContent);
-  return compiled(data);
-}
-async function loadTemplateFile(filePath) {
-  return fs3.readFile(filePath, "utf-8");
-}
-
-// src/utils/path.ts
-import * as path5 from "path";
-import * as fs4 from "fs/promises";
-function resolveSourcePath(source, variantDir, packageRoot) {
-  if (source.startsWith("_template/")) {
-    return path5.join(packageRoot, source);
+// 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;
   }
-  return path5.join(variantDir, source);
-}
-async function walkDir(dir) {
-  const files = [];
-  const entries = await fs4.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path5.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...await walkDir(fullPath));
-    } else if (entry.isFile()) {
-      files.push(fullPath);
-    }
+  const rootManaged = ROOT_MANAGED_FILES[relPath];
+  if (rootManaged) {
+    return {
+      target: rootManaged.target,
+      strategy: "managed",
+      managedRegions: rootManaged.managedRegions,
+      isFrozen: false
+    };
   }
-  return files;
-}
-
-// src/core/installer.ts
-async function installResources(options) {
-  const { projectRoot, manifest, data, variantDir, packageRoot } = options;
-  const installedResources = [];
-  for (const resource of manifest.resources) {
-    logger.debug(`Installing resource: ${resource.id} \u2192 ${resource.target}`);
-    if (resource.recursive) {
-      const results = await installRecursiveResource(
-        resource,
-        projectRoot,
-        data,
-        variantDir,
-        packageRoot
-      );
-      installedResources.push(...results);
-    } else {
-      const result = await installSingleResource(
-        resource,
-        projectRoot,
-        data,
-        variantDir,
-        packageRoot
-      );
-      installedResources.push(result);
+  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 };
   }
-  return {
-    resources: installedResources,
-    count: installedResources.length
-  };
-}
-async function installSingleResource(resource, projectRoot, data, variantDir, packageRoot) {
-  const sourcePath = resolveSourcePath(
-    resource.source,
-    variantDir,
-    packageRoot
-  );
-  const targetPath = path6.join(projectRoot, resource.target);
-  let content;
-  if (resource.template) {
-    const templateContent = await loadTemplateFile(sourcePath);
-    content = renderTemplate(templateContent, data);
-  } else {
-    content = await fs5.readFile(sourcePath, "utf-8");
+  if (FROZEN_FILES.has(relPath)) {
+    return {
+      target: path4.posix.join(TEAMIX_DIR, relPath),
+      strategy: "frozen",
+      isFrozen: true
+    };
   }
-  await writeFileSafe(targetPath, content);
-  const hash = computeHash(content);
-  logger.debug(`  Written: ${resource.target} (${resource.updateStrategy})`);
   return {
-    id: resource.id,
-    target: resource.target,
-    hash,
-    strategy: resource.updateStrategy
+    target: path4.posix.join(TEAMIX_DIR, relPath),
+    strategy: "regenerable",
+    isFrozen: false
   };
 }
-async function installRecursiveResource(resource, projectRoot, data, variantDir, packageRoot) {
-  const sourcePath = resolveSourcePath(
-    resource.source,
-    variantDir,
-    packageRoot
-  );
-  const targetDir = path6.join(projectRoot, resource.target);
-  const results = [];
-  await ensureDir(targetDir);
-  const entries = await walkDir(sourcePath);
-  for (const entry of entries) {
-    const relPath = path6.relative(sourcePath, entry);
-    let targetFile = path6.join(targetDir, relPath);
-    if (resource.template && targetFile.endsWith(".hbs")) {
-      targetFile = targetFile.slice(0, -4);
-    }
-    let content;
-    if (resource.template && entry.endsWith(".hbs")) {
-      const templateContent = await loadTemplateFile(entry);
-      content = renderTemplate(templateContent, data);
-    } else {
-      content = await fs5.readFile(entry, "utf-8");
-    }
-    await writeFileSafe(targetFile, content);
-    const hash = computeHash(content);
-    const targetRel = path6.relative(projectRoot, targetFile);
-    results.push({
-      id: `${resource.id}:${relPath}`,
-      target: targetRel,
-      hash,
-      strategy: resource.updateStrategy
-    });
-    logger.debug(`  Written: ${targetRel}`);
-  }
-  return results;
-}
 
 // src/core/state.ts
-import * as path7 from "path";
-import { validateConfig, validateInstalled } from "@teamix-evo/registry";
-var TEAMIX_DIR = ".teamix-evo";
+import * as path5 from "path";
+import {
+  validateConfig,
+  validateInstalled,
+  validateSkillsLock,
+  DesignPackLockSchema
+} from "@teamix-evo/registry";
+var TEAMIX_DIR2 = ".teamix-evo";
 var CONFIG_FILE = "config.json";
 var MANIFEST_FILE = "manifest.json";
+var DESIGN_DIR = "design";
+var DESIGN_LOCK_FILE = "pack.lock.json";
+var SKILLS_DIR = "skills";
+var SKILLS_LOCK_FILE = "manifest.lock.json";
 function getTeamixDir(projectRoot) {
-  return path7.join(projectRoot, TEAMIX_DIR);
+  return path5.join(projectRoot, TEAMIX_DIR2);
 }
 async function ensureTeamixDir(projectRoot) {
   const dir = getTeamixDir(projectRoot);
@@ -340,7 +230,7 @@ async function ensureTeamixDir(projectRoot) {
   return dir;
 }
 async function readProjectConfig(projectRoot) {
-  const configPath = path7.join(projectRoot, TEAMIX_DIR, CONFIG_FILE);
+  const configPath = path5.join(projectRoot, TEAMIX_DIR2, CONFIG_FILE);
   const raw = await readFileOrNull(configPath);
   if (raw === null) return null;
   try {
@@ -357,12 +247,12 @@ async function readProjectConfig(projectRoot) {
   }
 }
 async function writeProjectConfig(projectRoot, config) {
-  const configPath = path7.join(projectRoot, TEAMIX_DIR, CONFIG_FILE);
+  const configPath = path5.join(projectRoot, TEAMIX_DIR2, CONFIG_FILE);
   await writeFileSafe(configPath, JSON.stringify(config, null, 2) + "\n");
   logger.debug(`Wrote config \u2192 ${configPath}`);
 }
 async function readInstalledManifest(projectRoot) {
-  const manifestPath = path7.join(projectRoot, TEAMIX_DIR, MANIFEST_FILE);
+  const manifestPath = path5.join(projectRoot, TEAMIX_DIR2, MANIFEST_FILE);
   const raw = await readFileOrNull(manifestPath);
   if (raw === null) return null;
   try {
@@ -379,559 +269,94 @@ async function readInstalledManifest(projectRoot) {
   }
 }
 async function writeInstalledManifest(projectRoot, manifest) {
-  const manifestPath = path7.join(projectRoot, TEAMIX_DIR, MANIFEST_FILE);
+  const manifestPath = path5.join(projectRoot, TEAMIX_DIR2, MANIFEST_FILE);
   await writeFileSafe(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
   logger.debug(`Wrote manifest \u2192 ${manifestPath}`);
 }
-
-// src/core/design-init.ts
-var DEFAULT_DESIGN_PACKAGE = "@teamix-evo/design";
-async function runDesignInit(options) {
-  const { projectRoot, variant, tailwind, ide } = options;
-  const packageName = options.packageName ?? DEFAULT_DESIGN_PACKAGE;
-  await ensureTeamixDir(projectRoot);
-  const existingConfig = await readProjectConfig(projectRoot);
-  if (existingConfig?.packages?.design) {
-    return {
-      status: "already-initialized",
-      existingVariant: existingConfig.packages.design.variant
-    };
-  }
-  const { manifest, data, variantDir, packageRoot } = await loadVariantData(
-    packageName,
-    variant
-  );
-  const result = await installResources({
+async function readDesignPackLock(projectRoot) {
+  const lockPath = path5.join(
     projectRoot,
-    manifest,
-    data,
-    variantDir,
-    packageRoot
-  });
-  const config = {
-    $schema: "https://teamix-evo.dev/schema/config/v1.json",
-    schemaVersion: 1,
-    ide,
-    packages: {
-      design: {
-        variant,
-        version: manifest.version,
-        tailwind
-      }
-    }
-  };
-  await writeProjectConfig(projectRoot, config);
-  const installedManifest = {
-    schemaVersion: 1,
-    installed: [
-      {
-        package: packageName,
-        variant,
-        version: manifest.version,
-        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        resources: result.resources
-      }
-    ]
-  };
-  await writeInstalledManifest(projectRoot, installedManifest);
-  return {
-    status: "installed",
-    packageName,
-    variant,
-    version: manifest.version,
-    tailwind,
-    count: result.count,
-    resources: result.resources
-  };
-}
-
-// src/commands/design/init.ts
-var DEFAULT_VARIANT = "opentrek";
-var DEFAULT_TAILWIND = "v4";
-function normalizeTailwind(input) {
-  if (input === void 0) return DEFAULT_TAILWIND;
-  const lower = input.toLowerCase();
-  if (lower === "v3" || lower === "3") return "v3";
-  if (lower === "v4" || lower === "4") return "v4";
-  throw new Error(
-    `Invalid --tailwind value: "${input}". Expected "v3" or "v4".`
+    TEAMIX_DIR2,
+    DESIGN_DIR,
+    DESIGN_LOCK_FILE
   );
-}
-var initCommand = new Command("init").description("\u521D\u59CB\u5316\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90").argument("[variant]", "\u8BBE\u8BA1\u53D8\u4F53\u540D\u79F0", DEFAULT_VARIANT).option(
-  "--tailwind <version>",
-  "\u9879\u76EE\u4F7F\u7528\u7684 Tailwind CSS \u4E3B\u7248\u672C\uFF08v3 | v4\uFF09",
-  DEFAULT_TAILWIND
-).action(async (variant, opts) => {
+  const raw = await readFileOrNull(lockPath);
+  if (raw === null) return null;
   try {
-    const tailwind = normalizeTailwind(opts.tailwind);
-    const ide = detectIde();
-    const projectRoot = ide.getProjectRoot();
-    logger.info(
-      `Initializing design system: variant="${variant}", tailwind="${tailwind}"`
-    );
-    logger.debug(`Project root: ${projectRoot}`);
-    logger.debug(`IDE: ${ide.name}`);
-    logger.info(`Loading variant "${variant}"...`);
-    logger.info("Installing resources...");
-    const result = await runDesignInit({
-      projectRoot,
-      variant,
-      tailwind,
-      ide: ide.name
-    });
-    if (result.status === "already-initialized") {
-      logger.warn(
-        `Design system already initialized (variant: ${result.existingVariant}). Use "teamix-evo design update" to update.`
-      );
-      return;
+    const parsed = DesignPackLockSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) {
+      logger.warn(`Invalid design pack.lock.json: ${parsed.error.message}`);
+      return null;
     }
-    logger.success(
-      `Design system initialized: ${result.packageName} v${result.version}`
-    );
-    logger.info(`  Variant:  ${result.variant}`);
-    logger.info(`  Tailwind: ${result.tailwind}`);
-    logger.info(`  Resources: ${result.count} files installed`);
-    logger.info("");
-    logger.info('Run "teamix-evo design update" to update resources later.');
+    return parsed.data;
   } catch (err) {
-    logger.error(`Failed to initialize: ${err.message}`);
-    logger.debug(err.stack ?? "");
-    process.exitCode = 1;
+    logger.warn(
+      `Failed to parse design pack.lock.json: ${err.message}`
+    );
+    return null;
   }
-});
-
-// src/commands/design/update.ts
-import { Command as Command2 } from "commander";
-
-// src/core/updater.ts
-import * as path8 from "path";
-import * as fs6 from "fs/promises";
-import { getUpdateAction, replaceManagedRegion } from "@teamix-evo/registry";
-async function updateResources(options) {
-  const {
+}
+async function readDesignVariant(projectRoot) {
+  const lock = await readDesignPackLock(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;
+}
+async function readSkillsLock(projectRoot) {
+  const lockPath = path5.join(
     projectRoot,
-    manifest,
-    data,
-    variantDir,
-    packageRoot,
-    installedManifest,
-    packageName
-  } = options;
-  const updatedResources = [];
-  const summary = { overwritten: 0, managed: 0, skipped: 0, created: 0 };
-  const installedPkg = installedManifest.installed.find(
-    (p) => p.package === packageName && p.variant === manifest.variant
+    TEAMIX_DIR2,
+    SKILLS_DIR,
+    SKILLS_LOCK_FILE
   );
-  const installedMap = /* @__PURE__ */ new Map();
-  if (installedPkg) {
-    for (const res of installedPkg.resources) {
-      installedMap.set(res.id, res);
-    }
-  }
-  for (const resource of manifest.resources) {
-    if (resource.recursive) {
-      const results = await updateRecursiveResource(
-        resource,
-        projectRoot,
-        data,
-        variantDir,
-        packageRoot,
-        installedMap,
-        summary
-      );
-      updatedResources.push(...results);
-    } else {
-      const result = await updateSingleResource(
-        resource,
-        projectRoot,
-        data,
-        variantDir,
-        packageRoot,
-        installedMap,
-        summary
-      );
-      updatedResources.push(result);
+  const raw = await readFileOrNull(lockPath);
+  if (raw === null) return null;
+  try {
+    const data = JSON.parse(raw);
+    const result = validateSkillsLock(data);
+    if (!result.success) {
+      logger.warn(`Invalid skills manifest.lock.json: ${result.error}`);
+      return null;
     }
+    return result.data;
+  } catch (err) {
+    logger.warn(
+      `Failed to parse skills manifest.lock.json: ${err.message}`
+    );
+    return null;
   }
-  return { resources: updatedResources, summary };
 }
-async function updateSingleResource(resource, projectRoot, data, variantDir, packageRoot, installedMap, summary) {
-  const targetPath = path8.join(projectRoot, resource.target);
-  const exists = await fileExists(targetPath);
-  const installed = installedMap.get(resource.id);
-  const sourcePath = resolveSourcePath(
-    resource.source,
-    variantDir,
-    packageRoot
+async function writeSkillsLock(projectRoot, lock) {
+  const lockPath = path5.join(
+    projectRoot,
+    TEAMIX_DIR2,
+    SKILLS_DIR,
+    SKILLS_LOCK_FILE
   );
-  let newContent;
-  if (resource.template) {
-    const templateContent = await loadTemplateFile(sourcePath);
-    newContent = renderTemplate(templateContent, data);
-  } else {
-    newContent = await fs6.readFile(sourcePath, "utf-8");
-  }
-  const newHash = computeHash(newContent);
-  const action = getUpdateAction(resource.updateStrategy, {
-    exists,
-    hash: newHash,
-    currentHash: installed?.hash
-  });
-  switch (action) {
-    case "skip": {
-      logger.debug(`  Skip: ${resource.target} (${resource.updateStrategy})`);
-      summary.skipped++;
-      return installed ?? {
-        id: resource.id,
-        target: resource.target,
-        hash: newHash,
-        strategy: resource.updateStrategy
-      };
-    }
-    case "overwrite": {
-      if (exists) {
-        await backupFile(targetPath, projectRoot);
-        summary.overwritten++;
-      } else {
-        summary.created++;
-      }
-      await writeFileSafe(targetPath, newContent);
-      logger.debug(`  ${exists ? "Overwrite" : "Create"}: ${resource.target}`);
-      return {
-        id: resource.id,
-        target: resource.target,
-        hash: newHash,
-        strategy: resource.updateStrategy
-      };
-    }
-    case "managed-update": {
-      const currentContent = await readFileOrNull(targetPath);
-      if (currentContent === null) {
-        await writeFileSafe(targetPath, newContent);
-        summary.created++;
-        return {
-          id: resource.id,
-          target: resource.target,
-          hash: computeHash(newContent),
-          strategy: resource.updateStrategy
-        };
-      }
-      let updatedContent = currentContent;
-      const regionIds = resource.managedRegions ?? [];
-      for (const regionId of regionIds) {
-        const regionPattern = new RegExp(
-          `<!-- teamix-evo:managed:start id="${escapeRegExp(
-            regionId
-          )}" -->([\\s\\S]*?)<!-- teamix-evo:managed:end id="${escapeRegExp(
-            regionId
-          )}" -->`
-        );
-        const match = newContent.match(regionPattern);
-        if (match) {
-          const regionContent = match[1].replace(/^\n/, "").replace(/\n$/, "");
-          try {
-            updatedContent = replaceManagedRegion(
-              updatedContent,
-              regionId,
-              regionContent
-            );
-          } catch {
-            logger.warn(
-              `Managed region "${regionId}" not found in ${resource.target}. Skipping region.`
-            );
-          }
-        }
-      }
-      await backupFile(targetPath, projectRoot);
-      await writeFileSafe(targetPath, updatedContent);
-      summary.managed++;
-      return {
-        id: resource.id,
-        target: resource.target,
-        hash: computeHash(updatedContent),
-        strategy: resource.updateStrategy
-      };
-    }
-    default:
-      summary.skipped++;
-      return installed ?? {
-        id: resource.id,
-        target: resource.target,
-        hash: newHash,
-        strategy: resource.updateStrategy
-      };
-  }
+  await writeFileSafe(lockPath, JSON.stringify(lock, null, 2) + "\n");
+  logger.debug(`Wrote skills lock \u2192 ${lockPath}`);
 }
-async function updateRecursiveResource(resource, projectRoot, data, variantDir, packageRoot, installedMap, summary) {
-  const sourcePath = resolveSourcePath(
-    resource.source,
-    variantDir,
-    packageRoot
-  );
-  const targetDir = path8.join(projectRoot, resource.target);
-  const results = [];
-  if (resource.updateStrategy === "frozen") {
-    const anyInstalled = [...installedMap.keys()].some(
-      (k) => k.startsWith(`${resource.id}:`)
-    );
-    if (anyInstalled) {
-      summary.skipped++;
-      for (const [id, res] of installedMap) {
-        if (id.startsWith(`${resource.id}:`)) {
-          results.push(res);
-        }
-      }
-      return results;
-    }
-  }
-  await ensureDir(targetDir);
-  const entries = await walkDir(sourcePath);
-  for (const entry of entries) {
-    const relPath = path8.relative(sourcePath, entry);
-    let targetFile = path8.join(targetDir, relPath);
-    if (resource.template && targetFile.endsWith(".hbs")) {
-      targetFile = targetFile.slice(0, -4);
-    }
-    let content;
-    if (resource.template && entry.endsWith(".hbs")) {
-      const templateContent = await loadTemplateFile(entry);
-      content = renderTemplate(templateContent, data);
-    } else {
-      content = await fs6.readFile(entry, "utf-8");
-    }
-    await writeFileSafe(targetFile, content);
-    const hash = computeHash(content);
-    const targetRel = path8.relative(projectRoot, targetFile);
-    results.push({
-      id: `${resource.id}:${relPath}`,
-      target: targetRel,
-      hash,
-      strategy: resource.updateStrategy
-    });
-    summary.overwritten++;
-  }
-  return results;
-}
-function escapeRegExp(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// src/commands/design/update.ts
-var DESIGN_PACKAGE = "@teamix-evo/design";
-var updateCommand = new Command2("update").description("\u66F4\u65B0\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90").action(async () => {
-  try {
-    const ide = detectIde();
-    const projectRoot = ide.getProjectRoot();
-    logger.info("Updating design system resources...");
-    const config = await readProjectConfig(projectRoot);
-    if (!config?.packages?.design) {
-      logger.error(
-        'Design system not initialized. Run "teamix-evo design init" first.'
-      );
-      process.exitCode = 1;
-      return;
-    }
-    const { variant, version: currentVersion } = config.packages.design;
-    const installedManifest = await readInstalledManifest(projectRoot);
-    if (!installedManifest) {
-      logger.error(
-        'No installed manifest found. Try re-initializing with "teamix-evo design init".'
-      );
-      process.exitCode = 1;
-      return;
-    }
-    logger.info(`Loading variant "${variant}" from ${DESIGN_PACKAGE}...`);
-    const { manifest, data, variantDir, packageRoot } = await loadVariantData(DESIGN_PACKAGE, variant);
-    logger.info(
-      `Current: v${currentVersion} \u2192 Available: v${manifest.version}`
-    );
-    const result = await updateResources({
-      projectRoot,
-      manifest,
-      data,
-      variantDir,
-      packageRoot,
-      installedManifest,
-      packageName: DESIGN_PACKAGE
-    });
-    config.packages.design.version = manifest.version;
-    await writeProjectConfig(projectRoot, config);
-    const updatedManifest = { ...installedManifest };
-    const pkgIdx = updatedManifest.installed.findIndex(
-      (p) => p.package === DESIGN_PACKAGE && p.variant === variant
-    );
-    const pkgEntry = {
-      package: DESIGN_PACKAGE,
-      variant,
-      version: manifest.version,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      resources: result.resources
-    };
-    if (pkgIdx >= 0) {
-      updatedManifest.installed[pkgIdx] = pkgEntry;
-    } else {
-      updatedManifest.installed.push(pkgEntry);
-    }
-    await writeInstalledManifest(projectRoot, updatedManifest);
-    const { summary } = result;
-    logger.success(
-      `Design system updated to v${manifest.version}`
-    );
-    logger.info(`  Created:     ${summary.created}`);
-    logger.info(`  Overwritten: ${summary.overwritten}`);
-    logger.info(`  Managed:     ${summary.managed}`);
-    logger.info(`  Skipped:     ${summary.skipped}`);
-  } catch (err) {
-    logger.error(`Failed to update: ${err.message}`);
-    logger.debug(err.stack ?? "");
-    process.exitCode = 1;
-  }
-});
-
-// src/commands/design/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.');
-      return;
-    }
-    const { variant, version: version2 } = config.packages.design;
-    logger.info("Installed design system:");
-    logger.info(`  Package:  @teamix-evo/design`);
-    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
-      );
-      if (pkg) {
-        logger.info(`  Resources: ${pkg.resources.length} files`);
-        logger.info(
-          `  Installed: ${new Date(pkg.installedAt).toLocaleString()}`
-        );
-      }
-    }
-  } catch (err) {
-    logger.error(`Failed to list: ${err.message}`);
-    process.exitCode = 1;
-  }
-});
-
-// src/commands/design/uninstall.ts
-import { Command as Command4 } from "commander";
-import * as fs7 from "fs/promises";
-import * as path9 from "path";
-import * as prompts from "@clack/prompts";
-var DESIGN_PACKAGE2 = "@teamix-evo/design";
-var uninstallCommand = new Command4("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(
-  "--keep-files",
-  "\u4EC5\u6E05\u7406 .teamix-evo \u4E2D\u7684\u8BB0\u8D26\u4FE1\u606F\uFF0C\u4E0D\u5220\u9664\u5DF2\u843D\u5730\u8D44\u6E90\u6587\u4EF6"
-).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.");
-      return;
-    }
-    const installedManifest = await readInstalledManifest(projectRoot);
-    const pkg = installedManifest?.installed.find(
-      (p) => p.package === DESIGN_PACKAGE2
-    );
-    const resources = pkg?.resources ?? [];
-    const removable = opts.keepFiles ? [] : resources.filter((r) => r.strategy !== "managed");
-    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",
-        initialValue: false
-      });
-      if (prompts.isCancel(confirm4) || !confirm4) {
-        logger.info("Cancelled.");
-        return;
-      }
-    }
-    let removed = 0;
-    for (const r of removable) {
-      const target = path9.isAbsolute(r.target) ? r.target : path9.join(projectRoot, r.target);
-      try {
-        await fs7.unlink(target);
-        removed++;
-      } catch (err) {
-        if (err.code !== "ENOENT") {
-          logger.warn(
-            `Failed to remove ${target}: ${err.message}`
-          );
-        }
-      }
-    }
-    if (installedManifest) {
-      installedManifest.installed = installedManifest.installed.filter(
-        (p) => p.package !== DESIGN_PACKAGE2
-      );
-      await writeInstalledManifest(projectRoot, installedManifest);
-    }
-    delete config.packages.design;
-    await writeProjectConfig(projectRoot, config);
-    logger.success(`Uninstalled ${DESIGN_PACKAGE2}`);
-    logger.info(`  Removed: ${removed} files`);
-    if (kept > 0) {
-      logger.info(
-        `  Kept:    ${kept} managed files (you may delete manually)`
-      );
-    }
-  } catch (err) {
-    logger.error(`Failed to uninstall: ${err.message}`);
-    logger.debug(err.stack ?? "");
-    process.exitCode = 1;
-  }
-});
-
-// src/commands/design/index.ts
-var designCommand = new Command5("design").description(
-  "\u7BA1\u7406\u8BBE\u8BA1\u4F53\u7CFB\u8D44\u6E90"
-);
-designCommand.addCommand(initCommand);
-designCommand.addCommand(updateCommand);
-designCommand.addCommand(listCommand);
-designCommand.addCommand(uninstallCommand);
-
-// src/commands/skills/index.ts
-import { Command as Command10 } from "commander";
-
-// src/commands/skills/add.ts
-import { Command as Command6 } from "commander";
-import * as prompts2 from "@clack/prompts";
 
 // src/core/skills-client.ts
-import * as path10 from "path";
-import * as fs8 from "fs/promises";
-import { createRequire as createRequire2 } from "module";
+import * as path6 from "path";
+import * as fs2 from "fs/promises";
+import { createRequire } from "module";
 import { loadSkillsPackageManifest } from "@teamix-evo/registry";
-var require3 = createRequire2(import.meta.url);
-function resolvePackageRoot2(packageName) {
-  const pkgJsonPath = require3.resolve(`${packageName}/package.json`);
-  return path10.dirname(pkgJsonPath);
+var require2 = createRequire(import.meta.url);
+function resolvePackageRoot(packageName) {
+  const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
+  return path6.dirname(pkgJsonPath);
 }
 async function loadSkillsData(packageName) {
-  const packageRoot = resolvePackageRoot2(packageName);
+  const packageRoot = resolvePackageRoot(packageName);
   logger.debug(`Resolved skills package root: ${packageRoot}`);
   const manifest = await loadSkillsPackageManifest(packageRoot);
   let data = {};
-  const dataPath = path10.join(packageRoot, "_data.json");
+  const dataPath = path6.join(packageRoot, "_data.json");
   try {
-    const raw = await fs8.readFile(dataPath, "utf-8");
+    const raw = await fs2.readFile(dataPath, "utf-8");
     data = JSON.parse(raw);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -943,9 +368,56 @@ async function loadSkillsData(packageName) {
 }
 
 // src/core/skills-installer.ts
-import * as path11 from "path";
-import * as fs9 from "fs/promises";
-import { replaceManagedRegion as replaceManagedRegion2 } from "@teamix-evo/registry";
+import * as path8 from "path";
+import * as fs5 from "fs/promises";
+import { replaceManagedRegion } from "@teamix-evo/registry";
+
+// src/utils/template.ts
+import Handlebars from "handlebars";
+import * as fs3 from "fs/promises";
+Handlebars.registerHelper("lowercase", (str) => {
+  return typeof str === "string" ? str.toLowerCase() : String(str ?? "").toLowerCase();
+});
+var compiledCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 64;
+function getCompiledTemplate(templateContent) {
+  let compiled = compiledCache.get(templateContent);
+  if (!compiled) {
+    if (compiledCache.size >= MAX_CACHE_SIZE) {
+      const firstKey = compiledCache.keys().next().value;
+      compiledCache.delete(firstKey);
+    }
+    compiled = Handlebars.compile(templateContent, { noEscape: true });
+    compiledCache.set(templateContent, compiled);
+  }
+  return compiled;
+}
+function renderTemplate(templateContent, data) {
+  const compiled = getCompiledTemplate(templateContent);
+  return compiled(data);
+}
+async function loadTemplateFile(filePath) {
+  return fs3.readFile(filePath, "utf-8");
+}
+
+// src/utils/path.ts
+import * as path7 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);
+    if (entry.isDirectory()) {
+      files.push(...await walkDir(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+// src/core/skills-installer.ts
 async function installSkills(options) {
   const { manifest, ides, scope, onlyIds } = options;
   const installed = [];
@@ -962,60 +434,85 @@ async function installSkills(options) {
       );
       continue;
     }
+    const sourceRecords = await writeSkillSource(skill, options);
+    installed.push(...sourceRecords);
     for (const ide of skillIdes) {
-      const result = await installSkillForIde(skill, ide, scope, options);
-      installed.push(...result);
+      const mirrorRecords = await mirrorSkillToIde(
+        skill,
+        ide,
+        scope,
+        options.projectRoot
+      );
+      installed.push(...mirrorRecords);
     }
   }
   return { resources: installed, count: installed.length };
 }
-async function installSkillForIde(skill, ide, scope, options) {
+async function writeSkillSource(skill, options) {
   const { data, packageRoot, projectRoot } = options;
-  const adapter = getAdapter(ide);
-  const targetDir = adapter.getSkillTargetDir(skill.name, scope, projectRoot);
-  const sourceAbs = path11.resolve(packageRoot, skill.source);
-  const stat2 = await fs9.stat(sourceAbs);
-  const results = [];
-  if (stat2.isFile()) {
-    const targetFile = path11.join(targetDir, "SKILL.md");
+  const sourceAbs = path8.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 content = await renderSkillContent(sourceAbs, skill, data);
     await writeFileSafe(targetFile, content);
-    results.push(makeInstalledRecord(skill, targetFile, content, ide, scope));
-    logger.debug(`  Wrote ${ide}:${scope}: ${targetFile}`);
-    return results;
+    records.push(makeSourceRecord(skill, targetFile, content));
+    logger.debug(`  Wrote source: ${targetFile}`);
+    return records;
   }
   await ensureDir(targetDir);
   const entries = await walkDir(sourceAbs);
   for (const entry of entries) {
-    const rel2 = path11.relative(sourceAbs, entry);
-    let targetFile = path11.join(targetDir, rel2);
+    const rel2 = path8.relative(sourceAbs, entry);
+    let targetFile = path8.join(targetDir, rel2);
     if (skill.template && targetFile.endsWith(".hbs")) {
       targetFile = targetFile.slice(0, -4);
     }
-    let content;
-    if (skill.template && entry.endsWith(".hbs")) {
-      const tpl = await loadTemplateFile(entry);
-      content = renderTemplate(tpl, { ...data, skill });
-    } else {
-      content = await fs9.readFile(entry, "utf-8");
-    }
+    const content = skill.template && entry.endsWith(".hbs") ? renderTemplate(await loadTemplateFile(entry), { ...data, skill }) : await fs5.readFile(entry, "utf-8");
     await writeFileSafe(targetFile, content);
-    results.push(
-      makeInstalledRecord(skill, targetFile, content, ide, scope, rel2)
-    );
-    logger.debug(`  Wrote ${ide}:${scope}: ${targetFile}`);
-  }
-  return results;
-}
-async function renderSkillContent(sourceAbs, skill, data) {
-  if (skill.template ?? sourceAbs.endsWith(".hbs")) {
-    const tpl = await loadTemplateFile(sourceAbs);
-    return renderTemplate(tpl, { ...data, skill });
+    const relWritten = path8.relative(targetDir, targetFile);
+    records.push(makeSourceRecord(skill, targetFile, content, relWritten));
+    logger.debug(`  Wrote source: ${targetFile}`);
   }
-  return fs9.readFile(sourceAbs, "utf-8");
+  return records;
 }
-function makeInstalledRecord(skill, targetAbs, content, ide, scope, rel2) {
-  const id = rel2 ? `${skill.id}:${rel2}` : skill.id;
+async function mirrorSkillToIde(skill, ide, scope, projectRoot) {
+  const sourceDir = getSkillsSourceDir(projectRoot, skill.name);
+  const adapter = getAdapter(ide);
+  const targetDir = adapter.getSkillTargetDir(skill.name, scope, projectRoot);
+  const records = [];
+  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));
+    logger.debug(`  Mirrored ${ide}:${scope}: ${targetFile}`);
+  }
+  return records;
+}
+async function renderSkillContent(sourceAbs, skill, data) {
+  if (skill.template ?? sourceAbs.endsWith(".hbs")) {
+    const tpl = await loadTemplateFile(sourceAbs);
+    return renderTemplate(tpl, { ...data, skill });
+  }
+  return fs5.readFile(sourceAbs, "utf-8");
+}
+function makeSourceRecord(skill, targetAbs, content, rel2) {
+  const id = rel2 ? `${skill.id}:source:${rel2}` : `${skill.id}:source`;
+  return {
+    id,
+    target: targetAbs,
+    hash: computeHash(content),
+    strategy: skill.updateStrategy
+  };
+}
+function makeMirrorRecord(skill, targetAbs, content, ide, scope, rel2) {
+  const id = rel2 && rel2 !== "SKILL.md" ? `${skill.id}:${rel2}` : skill.id;
   return {
     id,
     target: targetAbs,
@@ -1026,55 +523,46 @@ function makeInstalledRecord(skill, targetAbs, content, ide, scope, rel2) {
   };
 }
 async function updateSkills(options) {
-  const { manifest, ides, scope, installed, projectRoot, data, packageRoot } = options;
+  const { manifest, ides, scope, projectRoot } = options;
   const summary = { overwritten: 0, managed: 0, skipped: 0, created: 0 };
   const updated = [];
-  const installedMap = /* @__PURE__ */ new Map();
-  for (const r of installed) {
-    installedMap.set(installedKey(r), r);
-  }
   for (const skill of manifest.skills) {
     const skillIdes = skill.ides.filter((i) => ides.includes(i));
+    if (skillIdes.length === 0) continue;
+    const sourceRecords = await rewriteSkillSource(
+      skill,
+      options,
+      summary
+    );
+    updated.push(...sourceRecords);
     for (const ide of skillIdes) {
-      const records = await updateSkillForIde(
+      const mirrorRecords = await mirrorSkillToIde(
         skill,
         ide,
         scope,
-        data,
-        packageRoot,
-        projectRoot,
-        installedMap,
-        summary
+        projectRoot
       );
-      updated.push(...records);
+      updated.push(...mirrorRecords);
     }
   }
   return { resources: updated, summary };
 }
-async function updateSkillForIde(skill, ide, scope, data, packageRoot, projectRoot, installedMap, summary) {
-  const adapter = getAdapter(ide);
-  const targetDir = adapter.getSkillTargetDir(skill.name, scope, projectRoot);
-  const sourceAbs = path11.resolve(packageRoot, skill.source);
-  const stat2 = await fs9.stat(sourceAbs);
-  const records = [];
-  if (!stat2.isFile()) {
-    const entries = await walkDir(sourceAbs);
+async function rewriteSkillSource(skill, options, summary) {
+  const { data, packageRoot, projectRoot } = options;
+  const sourceAbs = path8.resolve(packageRoot, skill.source);
+  const targetDir = getSkillsSourceDir(projectRoot, skill.name);
+  const stat4 = await fs5.stat(sourceAbs);
+  if (!stat4.isFile()) {
     await ensureDir(targetDir);
+    const entries = await walkDir(sourceAbs);
+    const records = [];
     for (const entry of entries) {
-      const rel2 = path11.relative(sourceAbs, entry);
-      let targetFile2 = path11.join(targetDir, rel2);
+      const rel2 = path8.relative(sourceAbs, entry);
+      let targetFile2 = path8.join(targetDir, rel2);
       if (skill.template && targetFile2.endsWith(".hbs")) {
         targetFile2 = targetFile2.slice(0, -4);
       }
-      let content;
-      if (skill.template && entry.endsWith(".hbs")) {
-        content = renderTemplate(await loadTemplateFile(entry), {
-          ...data,
-          skill
-        });
-      } else {
-        content = await fs9.readFile(entry, "utf-8");
-      }
+      const content = skill.template && entry.endsWith(".hbs") ? renderTemplate(await loadTemplateFile(entry), { ...data, skill }) : await fs5.readFile(entry, "utf-8");
       const exists2 = await fileExists(targetFile2);
       if (exists2) {
         await backupFile(targetFile2, projectRoot);
@@ -1083,30 +571,23 @@ async function updateSkillForIde(skill, ide, scope, data, packageRoot, projectRo
         summary.created++;
       }
       await writeFileSafe(targetFile2, content);
-      records.push(
-        makeInstalledRecord(skill, targetFile2, content, ide, scope, rel2)
-      );
+      const relWritten = path8.relative(targetDir, targetFile2);
+      records.push(makeSourceRecord(skill, targetFile2, content, relWritten));
     }
     return records;
   }
-  const targetFile = path11.join(targetDir, "SKILL.md");
+  const targetFile = path8.join(targetDir, "SKILL.md");
   const newContent = await renderSkillContent(sourceAbs, skill, data);
   const exists = await fileExists(targetFile);
-  const installedKeyStr = `${skill.id}|${ide}|${scope}`;
-  const prior = installedMap.get(installedKeyStr);
   if (skill.updateStrategy === "frozen") {
     if (exists) {
       summary.skipped++;
-      return [
-        prior ?? makeInstalledRecord(skill, targetFile, newContent, ide, scope)
-      ];
+      const current2 = await readFileOrNull(targetFile) ?? newContent;
+      return [makeSourceRecord(skill, targetFile, current2)];
     }
     await writeFileSafe(targetFile, newContent);
     summary.created++;
-    records.push(
-      makeInstalledRecord(skill, targetFile, newContent, ide, scope)
-    );
-    return records;
+    return [makeSourceRecord(skill, targetFile, newContent)];
   }
   if (skill.updateStrategy === "regenerable" || !exists) {
     if (exists) {
@@ -1116,19 +597,15 @@ async function updateSkillForIde(skill, ide, scope, data, packageRoot, projectRo
       summary.created++;
     }
     await writeFileSafe(targetFile, newContent);
-    records.push(
-      makeInstalledRecord(skill, targetFile, newContent, ide, scope)
-    );
-    return records;
+    return [makeSourceRecord(skill, targetFile, newContent)];
   }
   const current = await readFileOrNull(targetFile);
-  let updated = current ?? newContent;
-  const regionIds = skill.managedRegions ?? [];
-  for (const regionId of regionIds) {
+  let merged = current ?? newContent;
+  for (const regionId of skill.managedRegions ?? []) {
     const re = new RegExp(
-      `<!-- teamix-evo:managed:start id="${escapeRegExp2(
+      `<!-- teamix-evo:managed:start id="${escapeRegExp(
         regionId
-      )}" -->([\\s\\S]*?)<!-- teamix-evo:managed:end id="${escapeRegExp2(
+      )}" -->([\\s\\S]*?)<!-- teamix-evo:managed:end id="${escapeRegExp(
         regionId
       )}" -->`
     );
@@ -1136,7 +613,7 @@ async function updateSkillForIde(skill, ide, scope, data, packageRoot, projectRo
     if (match) {
       const region = match[1].replace(/^\n/, "").replace(/\n$/, "");
       try {
-        updated = replaceManagedRegion2(updated, regionId, region);
+        merged = replaceManagedRegion(merged, regionId, region);
       } catch {
         logger.warn(
           `Managed region "${regionId}" not found in ${targetFile}. Skipped.`
@@ -1145,22 +622,57 @@ async function updateSkillForIde(skill, ide, scope, data, packageRoot, projectRo
     }
   }
   await backupFile(targetFile, projectRoot);
-  await writeFileSafe(targetFile, updated);
+  await writeFileSafe(targetFile, merged);
   summary.managed++;
-  records.push(makeInstalledRecord(skill, targetFile, updated, ide, scope));
-  return records;
+  return [makeSourceRecord(skill, targetFile, merged)];
 }
-function installedKey(r) {
-  return `${r.id}|${r.ide ?? ""}|${r.scope ?? ""}`;
-}
-function escapeRegExp2(str) {
+function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+async function syncSkillsToIdes(options) {
+  const { projectRoot, skills, ides, scope, onlyIds } = options;
+  const out = [];
+  const targets = skills.filter((s) => !onlyIds || onlyIds.includes(s.id));
+  for (const skill of targets) {
+    const sourceDir = getSkillsSourceDir(projectRoot, skill.name);
+    if (!await fileExists(sourceDir)) {
+      logger.warn(
+        `Skill "${skill.id}" has no source at ${sourceDir}; skipped.`
+      );
+      continue;
+    }
+    for (const ide of ides) {
+      const adapter = getAdapter(ide);
+      const targetDir = adapter.getSkillTargetDir(
+        skill.name,
+        scope,
+        projectRoot
+      );
+      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);
+        out.push({
+          id: rel2 === "SKILL.md" ? skill.id : `${skill.id}:${rel2}`,
+          target: targetFile,
+          hash: computeHash(content),
+          strategy: skill.updateStrategy,
+          ide,
+          scope
+        });
+      }
+    }
+  }
+  return { resources: out, count: out.length };
+}
 async function removeSkillFiles(records) {
   const removed = [];
   for (const r of records) {
     try {
-      await fs9.unlink(r.target);
+      await fs5.unlink(r.target);
       removed.push(r.target);
     } catch (err) {
       if (err.code !== "ENOENT") {
@@ -1168,11 +680,11 @@ async function removeSkillFiles(records) {
       }
     }
   }
-  const parents = new Set(records.map((r) => path11.dirname(r.target)));
+  const parents = new Set(records.map((r) => path8.dirname(r.target)));
   for (const dir of parents) {
     try {
-      const entries = await fs9.readdir(dir);
-      if (entries.length === 0) await fs9.rmdir(dir);
+      const entries = await fs5.readdir(dir);
+      if (entries.length === 0) await fs5.rmdir(dir);
     } catch {
     }
   }
@@ -1202,6 +714,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);
   if (isIncremental) {
     const known = new Set(manifest.skills.map((s) => s.id));
     const unknown = requestedNames.filter((n) => !known.has(n));
@@ -1212,102 +725,605 @@ async function runSkillsAdd(options) {
       );
     }
   }
-  const existingInstalled = await readInstalledManifest(projectRoot);
-  const existingPkg = existingInstalled?.installed.find(
-    (p) => p.package === packageName
-  );
-  const existingSkillIds = new Set(
-    (existingPkg?.resources ?? []).map((r) => r.id.split(":")[0])
-  );
-  let onlyIds;
-  let skippedSkillIds;
-  if (isIncremental) {
-    skippedSkillIds = requestedNames.filter((n) => existingSkillIds.has(n));
-    onlyIds = requestedNames.filter((n) => !existingSkillIds.has(n));
-  } else {
-    skippedSkillIds = [];
-    onlyIds = manifest.skills.map((s) => s.id);
-  }
-  if (isIncremental && onlyIds.length === 0) {
-    return {
-      status: "installed",
-      packageName,
-      version: existingSkillsCfg?.version ?? manifest.version,
-      ides,
-      scope,
-      skillCount: 0,
-      fileCount: 0,
-      resources: [],
-      addedSkillIds: [],
-      skippedSkillIds
-    };
-  }
-  const result = await installSkills({
-    projectRoot,
-    manifest,
-    data,
-    packageRoot,
-    ides,
-    scope,
-    onlyIds
-  });
-  const config = existingConfig ?? {
-    $schema: "https://teamix-evo.dev/schema/config/v1.json",
-    schemaVersion: 1,
-    ide: ideIdent,
-    packages: {}
-  };
-  config.packages.skills = {
-    variant: FLAT_VARIANT,
-    version: manifest.version,
-    ides,
-    scope
-  };
-  await writeProjectConfig(projectRoot, config);
-  const installedManifest = existingInstalled ?? {
-    schemaVersion: 1,
-    installed: []
-  };
-  const idx = installedManifest.installed.findIndex(
-    (p) => p.package === packageName
-  );
-  const mergedResources = mergeInstalledResources(
-    existingPkg?.resources ?? [],
-    result.resources
-  );
-  const entry = {
-    package: packageName,
-    variant: FLAT_VARIANT,
-    version: manifest.version,
-    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    resources: mergedResources
-  };
-  if (idx >= 0) installedManifest.installed[idx] = entry;
-  else installedManifest.installed.push(entry);
-  await writeInstalledManifest(projectRoot, installedManifest);
-  return {
-    status: "installed",
-    packageName,
-    version: manifest.version,
-    ides,
-    scope,
-    skillCount: onlyIds.length,
-    fileCount: result.count,
-    resources: result.resources,
-    addedSkillIds: onlyIds,
-    skippedSkillIds
-  };
+  const existingInstalled = await readInstalledManifest(projectRoot);
+  const existingPkg = existingInstalled?.installed.find(
+    (p) => p.package === packageName
+  );
+  const existingLock = await readSkillsLock(projectRoot);
+  const existingSkillIds = /* @__PURE__ */ new Set([
+    ...Object.keys(existingLock?.skills ?? {}),
+    // Legacy fallback: pre-ADR-0013 installs only had manifest.json. Derive
+    // skill ids by stripping the trailing :source / :sub-file suffix.
+    ...(existingPkg?.resources ?? []).map((r) => r.id.split(":")[0])
+  ]);
+  let onlyIds;
+  let skippedSkillIds;
+  if (isIncremental) {
+    skippedSkillIds = requestedNames.filter((n) => existingSkillIds.has(n));
+    onlyIds = requestedNames.filter((n) => !existingSkillIds.has(n));
+  } else {
+    skippedSkillIds = [];
+    onlyIds = manifest.skills.filter((s) => {
+      if (!s.variant) return true;
+      if (!currentDesignVariant) {
+        logger.debug(
+          `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): no design pack installed; will be picked up when "design init" runs.`
+        );
+        return false;
+      }
+      if (s.variant !== currentDesignVariant) {
+        logger.debug(
+          `Skipping variant-bound skill "${s.id}" (variant=${s.variant}): current design variant is "${currentDesignVariant}".`
+        );
+        return false;
+      }
+      return true;
+    }).map((s) => s.id);
+  }
+  if (isIncremental && onlyIds.length === 0) {
+    return {
+      status: "installed",
+      packageName,
+      version: existingSkillsCfg?.version ?? manifest.version,
+      ides,
+      scope,
+      skillCount: 0,
+      fileCount: 0,
+      resources: [],
+      addedSkillIds: [],
+      skippedSkillIds
+    };
+  }
+  const result = await installSkills({
+    projectRoot,
+    manifest,
+    data,
+    packageRoot,
+    ides,
+    scope,
+    onlyIds
+  });
+  const config = existingConfig ?? {
+    $schema: "https://teamix-evo.dev/schema/config/v1.json",
+    schemaVersion: 1,
+    ide: ideIdent,
+    packages: {}
+  };
+  config.packages.skills = {
+    variant: FLAT_VARIANT,
+    version: manifest.version,
+    ides,
+    scope
+  };
+  await writeProjectConfig(projectRoot, config);
+  const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const installedManifest = existingInstalled ?? {
+    schemaVersion: 1,
+    installed: []
+  };
+  const idx = installedManifest.installed.findIndex(
+    (p) => p.package === packageName
+  );
+  const mergedResources = mergeInstalledResources(
+    existingPkg?.resources ?? [],
+    result.resources
+  );
+  const entry = {
+    package: packageName,
+    variant: FLAT_VARIANT,
+    version: manifest.version,
+    installedAt,
+    resources: mergedResources
+  };
+  if (idx >= 0) installedManifest.installed[idx] = entry;
+  else installedManifest.installed.push(entry);
+  await writeInstalledManifest(projectRoot, installedManifest);
+  const lock = existingLock ?? {
+    schemaVersion: 1,
+    skills: {}
+  };
+  for (const skillId of onlyIds) {
+    const skillDef = manifest.skills.find((s) => s.id === skillId);
+    if (!skillDef) continue;
+    const mirroredTo = skillDef.ides.filter((i) => ides.includes(i));
+    lock.skills[skillId] = {
+      version: skillDef.version,
+      from: packageName,
+      installedAt,
+      scope,
+      mirroredTo
+    };
+  }
+  await writeSkillsLock(projectRoot, lock);
+  return {
+    status: "installed",
+    packageName,
+    version: manifest.version,
+    ides,
+    scope,
+    skillCount: onlyIds.length,
+    fileCount: result.count,
+    resources: result.resources,
+    addedSkillIds: onlyIds,
+    skippedSkillIds
+  };
+}
+function mergeInstalledResources(existing, next) {
+  const map = /* @__PURE__ */ new Map();
+  const key = (r) => `${r.id}|${r.ide ?? ""}|${r.scope ?? ""}`;
+  for (const r of existing) map.set(key(r), r);
+  for (const r of next) map.set(key(r), r);
+  return [...map.values()];
+}
+
+// src/core/design-init.ts
+var BASELINE_DESIGN_RULES_SKILL = "teamix-evo-design-rules";
+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 require3 = createRequire2(import.meta.url);
+async function runDesignInit(options) {
+  const { projectRoot, variant, ide } = options;
+  const packageName = options.packageName ?? DEFAULT_DESIGN_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);
+  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.`
+    );
+  }
+  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);
+    if (result) installed.push(result);
+  }
+  const lock = {
+    schemaVersion: 1,
+    default: { version: defaultPack.version, from: packageName },
+    variant: {
+      name: variantPack.name,
+      displayName: variantPack.displayName,
+      version: variantPack.version,
+      from: packageName
+    },
+    linked: variantPack.linked,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeFileSafe(
+    path9.join(projectRoot, ".teamix-evo", "design", "pack.lock.json"),
+    JSON.stringify(lock, null, 2) + "\n"
+  );
+  const config = {
+    $schema: "https://teamix-evo.dev/schema/config/v1.json",
+    schemaVersion: 1,
+    ide,
+    packages: {
+      design: {
+        variant,
+        version: variantPack.version,
+        tailwind: "v4"
+      }
+    }
+  };
+  await writeProjectConfig(projectRoot, config);
+  const installedManifest = {
+    schemaVersion: 1,
+    installed: [
+      {
+        package: packageName,
+        variant,
+        version: variantPack.version,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        resources: installed
+      }
+    ]
+  };
+  await writeInstalledManifest(projectRoot, installedManifest);
+  const skills = await tryAutoInstallVariantSkills({
+    projectRoot,
+    variant,
+    ide
+  });
+  return {
+    status: "installed",
+    packageName,
+    variant,
+    version: variantPack.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];
+  let manifestSkillIds;
+  try {
+    const { manifest } = await loadSkillsData(DEFAULT_SKILLS_PACKAGE2);
+    manifestSkillIds = new Set(manifest.skills.map((s) => s.id));
+  } catch (err) {
+    logger.warn(
+      `Skipping skills auto-install: could not load skills manifest (${err.message}).`
+    );
+    return {
+      attempted: [],
+      addedSkillIds: [],
+      skippedSkillIds: [],
+      missing: desired
+    };
+  }
+  const present = desired.filter((id) => manifestSkillIds.has(id));
+  const missing = desired.filter((id) => !manifestSkillIds.has(id));
+  if (missing.length > 0) {
+    logger.warn(
+      `Skills auto-install: not found in manifest, skipping: ${missing.join(", ")}.`
+    );
+  }
+  if (present.length === 0) {
+    return {
+      attempted: desired,
+      addedSkillIds: [],
+      skippedSkillIds: [],
+      missing
+    };
+  }
+  try {
+    const result = await runSkillsAdd({
+      projectRoot,
+      names: present,
+      ides: DEFAULT_AUTO_SKILL_IDES,
+      scope: DEFAULT_AUTO_SKILL_SCOPE,
+      ide
+    });
+    if (result.status !== "installed") {
+      return {
+        attempted: desired,
+        addedSkillIds: [],
+        skippedSkillIds: present,
+        missing
+      };
+    }
+    return {
+      attempted: desired,
+      addedSkillIds: result.addedSkillIds,
+      skippedSkillIds: result.skippedSkillIds,
+      missing
+    };
+  } catch (err) {
+    logger.warn(
+      `Skills auto-install failed (continuing): ${err.message}`
+    );
+    return {
+      attempted: desired,
+      addedSkillIds: [],
+      skippedSkillIds: [],
+      missing
+    };
+  }
+}
+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");
+    return {
+      id: `pack:${file.relPath}`,
+      target: cls.target,
+      hash: computeHash(existing),
+      strategy: cls.strategy
+    };
+  }
+  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
+  };
+}
+function resolveDesignPackageRoot(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);
+  return {
+    packageName,
+    defaultDescription: catalog.default.description,
+    variants: catalog.variants.map((v) => ({
+      name: v.name,
+      displayName: v.displayName,
+      version: v.version,
+      description: v.description,
+      linked: v.linked
+    }))
+  };
+}
+
+// src/commands/design/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();
+    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({
+      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.`
+      );
+      return;
+    }
+    logger.success(
+      `Design system initialized: ${result.packageName} (${result.variant} v${result.version})`
+    );
+    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) {
+        logger.info(
+          `  Skills:   auto-installed ${addedSkillIds.join(", ")}`
+        );
+      }
+      if (skippedSkillIds.length > 0) {
+        logger.info(
+          `  Skills:   already installed (skipped) ${skippedSkillIds.join(", ")}`
+        );
+      }
+      if (missing.length > 0) {
+        logger.info(
+          `  Skills:   not in manifest (skipped) ${missing.join(", ")}`
+        );
+      }
+    }
+    logger.info("");
+    logger.info('Run "teamix-evo design update" to update resources later.');
+    logger.info(
+      'Run "teamix-evo design list-variants" to see all available variants.'
+    );
+  } catch (err) {
+    logger.error(`Failed to initialize: ${err.message}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/design/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)."
+  );
+  logger.info(
+    "Workaround: clean `.teamix-evo/design/` and re-run `teamix-evo design init <variant>`."
+  );
+  logger.info(
+    "Tracking: PLAN \xA712.6 v0.7 \u2014 semantic upgrade flow + tokens.overrides.css preservation."
+  );
+  process.exitCode = 0;
+});
+
+// src/commands/design/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.');
+      return;
+    }
+    const { variant, version: version2 } = config.packages.design;
+    logger.info("Installed design system:");
+    logger.info(`  Package:  @teamix-evo/design`);
+    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
+      );
+      if (pkg) {
+        logger.info(`  Resources: ${pkg.resources.length} files`);
+        logger.info(
+          `  Installed: ${new Date(pkg.installedAt).toLocaleString()}`
+        );
+      }
+    }
+  } catch (err) {
+    logger.error(`Failed to list: ${err.message}`);
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/design/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 () => {
+  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}`);
+    }
+    logger.info("");
+    if (result.variants.length === 0) {
+      logger.info("  (no variants beyond default)");
+      return;
+    }
+    for (const v of result.variants) {
+      logger.info(`  ${v.name} (${v.displayName}) \u2014 v${v.version}`);
+      if (v.description) logger.info(`    ${v.description}`);
+      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 (links.length) logger.info(`    linked: ${links.join(" / ")}`);
+      }
+      logger.info("");
+    }
+    logger.info("Install a variant: teamix-evo design init <name>");
+  } catch (err) {
+    logger.error(`Failed to list variants: ${err.message}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/design/uninstall.ts
+import { Command as Command5 } from "commander";
+import * as fs7 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(
+  "--keep-files",
+  "\u4EC5\u6E05\u7406 .teamix-evo \u4E2D\u7684\u8BB0\u8D26\u4FE1\u606F\uFF0C\u4E0D\u5220\u9664\u5DF2\u843D\u5730\u8D44\u6E90\u6587\u4EF6"
+).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.");
+      return;
+    }
+    const installedManifest = await readInstalledManifest(projectRoot);
+    const pkg = installedManifest?.installed.find(
+      (p) => p.package === DESIGN_PACKAGE
+    );
+    const resources = pkg?.resources ?? [];
+    const removable = opts.keepFiles ? [] : resources.filter((r) => r.strategy !== "managed");
+    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",
+        initialValue: false
+      });
+      if (prompts.isCancel(confirm4) || !confirm4) {
+        logger.info("Cancelled.");
+        return;
+      }
+    }
+    let removed = 0;
+    for (const r of removable) {
+      const target = path10.isAbsolute(r.target) ? r.target : path10.join(projectRoot, r.target);
+      try {
+        await fs7.unlink(target);
+        removed++;
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          logger.warn(
+            `Failed to remove ${target}: ${err.message}`
+          );
+        }
+      }
+    }
+    if (installedManifest) {
+      installedManifest.installed = installedManifest.installed.filter(
+        (p) => p.package !== DESIGN_PACKAGE
+      );
+      await writeInstalledManifest(projectRoot, installedManifest);
+    }
+    delete config.packages.design;
+    await writeProjectConfig(projectRoot, config);
+    logger.success(`Uninstalled ${DESIGN_PACKAGE}`);
+    logger.info(`  Removed: ${removed} files`);
+    if (kept > 0) {
+      logger.info(
+        `  Kept:    ${kept} managed files (you may delete manually)`
+      );
+    }
+  } catch (err) {
+    logger.error(`Failed to uninstall: ${err.message}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+
+// 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/skills/index.ts
+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 mergeInstalledResources(existing, next) {
-  const map = /* @__PURE__ */ new Map();
-  const key = (r) => `${r.id}|${r.ide ?? ""}|${r.scope ?? ""}`;
-  for (const r of existing) map.set(key(r), r);
-  for (const r of next) map.set(key(r), r);
-  return [...map.values()];
+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;
 }
 
 // src/commands/skills/add.ts
-var addCommand = new Command6("add").description(
+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(
   "[names...]",
@@ -1318,13 +1334,18 @@ var addCommand = new Command6("add").description(
 ).option("-y, --yes", "\u4F7F\u7528\u9ED8\u8BA4\u503C\uFF0C\u8DF3\u8FC7\u4EA4\u4E92").action(async (names, opts) => {
   try {
     const ide = detectIde();
-    const projectRoot = ide.getProjectRoot();
+    const cwd = ide.getProjectRoot();
     const isIncremental = names.length > 0;
     const { ides, scope } = await resolveIdesAndScope({
       opts,
-      projectRoot,
+      projectRoot: cwd,
       isIncremental
     });
+    let projectRoot = cwd;
+    if (scope === "global" && !isTeamixEvoProject(cwd)) {
+      projectRoot = await ensureGlobalMetaRoot();
+      logger.info(`Global skill install \u2014 meta root: ${projectRoot}`);
+    }
     logger.info(
       isIncremental ? `Adding skills [${names.join(",")}]: ides=[${ides.join(
         ","
@@ -1439,9 +1460,9 @@ function parseScope(input) {
 }
 
 // src/commands/skills/list.ts
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 var SKILLS_PACKAGE = "@teamix-evo/skills";
-var listCommand2 = new Command7("list").alias("ls").description(
+var listCommand2 = new Command8("list").alias("ls").description(
   "\u5217\u51FA teamix-evo skills\uFF08\u9ED8\u8BA4\u5C55\u793A\u5168\u90E8 skill \u5E76\u6807\u6CE8\u5DF2\u88C5/\u672A\u88C5\uFF1B--installed \u4EC5\u770B\u5DF2\u88C5\uFF09"
 ).option("--installed", "\u4EC5\u5C55\u793A\u5DF2\u5B89\u88C5\u7684 skill\uFF08\u9690\u85CF\u672A\u5B89\u88C5\u9879\uFF09").action(async (opts) => {
   try {
@@ -1521,10 +1542,10 @@ function printInstalledHeader(cfg, installedAt) {
 }
 
 // src/commands/skills/update.ts
-import { Command as Command8 } from "commander";
+import { Command as Command9 } from "commander";
 var SKILLS_PACKAGE2 = "@teamix-evo/skills";
 var FLAT_VARIANT2 = "_flat";
-var updateCommand2 = new Command8("update").description("\u66F4\u65B0\u5DF2\u5B89\u88C5\u7684 teamix-evo skills").action(async () => {
+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();
@@ -1550,10 +1571,6 @@ var updateCommand2 = new Command8("update").description("\u66F4\u65B0\u5DF2\u5B8
     const { manifest, data, packageRoot } = await loadSkillsData(
       SKILLS_PACKAGE2
     );
-    const pkgInstalled = installedManifest.installed.find(
-      (p) => p.package === SKILLS_PACKAGE2
-    );
-    const installedResources = pkgInstalled?.resources ?? [];
     logger.info(
       `Current: v${skillsEntry.version} \u2192 Available: v${manifest.version}`
     );
@@ -1563,101 +1580,416 @@ var updateCommand2 = new Command8("update").description("\u66F4\u65B0\u5DF2\u5B8
       data,
       packageRoot,
       ides,
-      scope,
-      installed: installedResources
+      scope
     });
     config.packages.skills.version = manifest.version;
     await writeProjectConfig(projectRoot, config);
+    const installedAt = (/* @__PURE__ */ new Date()).toISOString();
     const idx = installedManifest.installed.findIndex(
       (p) => p.package === SKILLS_PACKAGE2
     );
-    const entry = {
-      package: SKILLS_PACKAGE2,
-      variant: FLAT_VARIANT2,
-      version: manifest.version,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      resources: result.resources
-    };
-    if (idx >= 0) installedManifest.installed[idx] = entry;
-    else installedManifest.installed.push(entry);
-    await writeInstalledManifest(projectRoot, installedManifest);
-    const { summary } = result;
-    logger.success(`Skills updated to v${manifest.version}`);
-    logger.info(`  Created:     ${summary.created}`);
-    logger.info(`  Overwritten: ${summary.overwritten}`);
-    logger.info(`  Managed:     ${summary.managed}`);
-    logger.info(`  Skipped:     ${summary.skipped}`);
+    const entry = {
+      package: SKILLS_PACKAGE2,
+      variant: FLAT_VARIANT2,
+      version: manifest.version,
+      installedAt,
+      resources: result.resources
+    };
+    if (idx >= 0) installedManifest.installed[idx] = entry;
+    else installedManifest.installed.push(entry);
+    await writeInstalledManifest(projectRoot, installedManifest);
+    const existingLock = await readSkillsLock(projectRoot) ?? {
+      schemaVersion: 1,
+      skills: {}
+    };
+    const lock = {
+      schemaVersion: 1,
+      skills: { ...existingLock.skills }
+    };
+    for (const skill of manifest.skills) {
+      const mirroredTo = skill.ides.filter((i) => ides.includes(i));
+      if (mirroredTo.length === 0) continue;
+      lock.skills[skill.id] = {
+        version: skill.version,
+        from: SKILLS_PACKAGE2,
+        installedAt,
+        scope,
+        mirroredTo
+      };
+    }
+    await writeSkillsLock(projectRoot, lock);
+    const { summary } = result;
+    logger.success(`Skills updated to v${manifest.version}`);
+    logger.info(`  Created:     ${summary.created}`);
+    logger.info(`  Overwritten: ${summary.overwritten}`);
+    logger.info(`  Managed:     ${summary.managed}`);
+    logger.info(`  Skipped:     ${summary.skipped}`);
+  } catch (err) {
+    logger.error(`Failed to update skills: ${err.message}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+
+// 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";
+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) => {
+  try {
+    const ide = detectIde();
+    const projectRoot = ide.getProjectRoot();
+    const config = await readProjectConfig(projectRoot);
+    if (!config?.packages?.skills) {
+      logger.info("Skills are not installed. Nothing to do.");
+      return;
+    }
+    const installedManifest = await readInstalledManifest(projectRoot);
+    const pkg = installedManifest?.installed.find(
+      (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 (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);
+    }
+    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)`);
+  } catch (err) {
+    logger.error(`Failed to uninstall: ${err.message}`);
+    logger.debug(err.stack ?? "");
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/skills/sync.ts
+import { Command as Command11 } from "commander";
+
+// src/core/skills-sync.ts
+import * as fs10 from "fs/promises";
+var SKILLS_PACKAGE_DEFAULT = "@teamix-evo/skills";
+async function runSkillsSync(options) {
+  const { projectRoot, names } = options;
+  const lock = await readSkillsLock(projectRoot);
+  if (!lock || Object.keys(lock.skills).length === 0) {
+    return {
+      status: "no-skills",
+      syncedSkillIds: [],
+      fileCount: 0,
+      resources: [],
+      missingSourceIds: []
+    };
+  }
+  const skillIds = Object.keys(lock.skills);
+  const targets = names ? skillIds.filter((id) => names.includes(id)) : skillIds;
+  const allResources = [];
+  const synced = [];
+  const missing = [];
+  for (const skillId of targets) {
+    const lockEntry = lock.skills[skillId];
+    if (!lockEntry) continue;
+    const sourceDir = getSkillsSourceDir(projectRoot, skillId);
+    if (!await dirExists(sourceDir)) {
+      logger.warn(`Skill "${skillId}" has no source at ${sourceDir}; skipped.`);
+      missing.push(skillId);
+      continue;
+    }
+    const ides = options.ides ?? lockEntry.mirroredTo;
+    const scope = options.scope ?? lockEntry.scope;
+    if (ides.length === 0) {
+      logger.warn(`Skill "${skillId}" has no IDE mirror targets; skipped.`);
+      continue;
+    }
+    const result = await syncSkillsToIdes({
+      projectRoot,
+      skills: [
+        {
+          id: skillId,
+          name: skillId,
+          updateStrategy: "regenerable"
+        }
+      ],
+      ides,
+      scope
+    });
+    allResources.push(...result.resources);
+    synced.push(skillId);
+    lock.skills[skillId] = {
+      ...lockEntry,
+      mirroredTo: ides,
+      scope,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  await writeSkillsLock(projectRoot, lock);
+  await refreshMirrorRecords(projectRoot, allResources);
+  return {
+    status: "synced",
+    syncedSkillIds: synced,
+    fileCount: allResources.length,
+    resources: allResources,
+    missingSourceIds: missing
+  };
+}
+async function dirExists(p) {
+  try {
+    const stat4 = await fs10.stat(p);
+    return stat4.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function refreshMirrorRecords(projectRoot, newMirrorRecords) {
+  const installed = await readInstalledManifest(projectRoot);
+  if (!installed) return;
+  const pkg = installed.installed.find((p) => p.package === SKILLS_PACKAGE_DEFAULT);
+  if (!pkg) return;
+  const sourceOnly = pkg.resources.filter((r) => r.ide === void 0);
+  pkg.resources = [...sourceOnly, ...newMirrorRecords];
+  pkg.installedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeInstalledManifest(projectRoot, installed);
+}
+
+// src/commands/skills/sync.ts
+var syncCommand = new Command11("sync").description(
+  "\u628A .teamix-evo/skills/ \u4E0B\u7684\u6E90\u91CD\u65B0\u955C\u50CF\u5230 IDE \u8DEF\u5F84\uFF08.qoder / .claude\uFF09"
+).argument(
+  "[names...]",
+  "\u53EF\u9009\uFF1A\u4EC5\u540C\u6B65\u6307\u5B9A skill id\uFF1B\u7701\u7565\u5219\u540C\u6B65\u5168\u90E8\u5DF2\u8BB0\u5F55\u5728 lock \u5185\u7684 skill"
+).option(
+  "--ide <list>",
+  "\u9017\u53F7\u5206\u9694\u7684 IDE \u5217\u8868\uFF08\u8986\u76D6 lock \u4E2D\u8BB0\u5F55\u7684 mirroredTo\uFF09"
+).option(
+  "--scope <scope>",
+  "project | global\uFF08\u8986\u76D6 lock \u4E2D\u8BB0\u5F55\u7684 scope\uFF09"
+).action(async (names, opts) => {
+  try {
+    const ide = detectIde();
+    const projectRoot = ide.getProjectRoot();
+    const ides = opts.ide ? parseIdeList2(opts.ide) : void 0;
+    const scope = opts.scope ? parseScope2(opts.scope) : void 0;
+    const result = await runSkillsSync({
+      projectRoot,
+      ides,
+      scope,
+      names: names.length > 0 ? names : void 0
+    });
+    if (result.status === "no-skills") {
+      logger.info(
+        "No skills recorded in .teamix-evo/skills/manifest.lock.json. Nothing to sync."
+      );
+      return;
+    }
+    logger.success(
+      `Synced ${result.syncedSkillIds.length} skill(s) \u2192 ${result.fileCount} file(s)`
+    );
+    if (result.syncedSkillIds.length > 0) {
+      logger.info(`  Skills: ${result.syncedSkillIds.join(", ")}`);
+    }
+    if (result.missingSourceIds.length > 0) {
+      logger.warn(
+        `  Missing source: ${result.missingSourceIds.join(
+          ", "
+        )} (run "skills add <id>" to (re)install)`
+      );
+    }
   } catch (err) {
-    logger.error(`Failed to update skills: ${err.message}`);
+    logger.error(`Failed to sync skills: ${err.message}`);
     logger.debug(err.stack ?? "");
     process.exitCode = 1;
   }
 });
+function parseIdeList2(input) {
+  const parts = input.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  const result = [];
+  for (const p of parts) {
+    if (p === "qoder" || p === "claude") {
+      if (!result.includes(p)) result.push(p);
+    } else {
+      throw new Error(
+        `Unknown IDE: "${p}". Expected one of: ${ALL_IDE_KINDS.join(", ")}.`
+      );
+    }
+  }
+  return result;
+}
+function parseScope2(input) {
+  const v = input.toLowerCase();
+  if (v === "project" || v === "global") return v;
+  throw new Error(`Invalid --scope: "${input}". Expected project | global.`);
+}
 
-// src/commands/skills/uninstall.ts
-import { Command as Command9 } from "commander";
-import * as prompts3 from "@clack/prompts";
-var SKILLS_PACKAGE3 = "@teamix-evo/skills";
-var uninstallCommand2 = new Command9("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) => {
+// src/commands/skills/doctor.ts
+import { Command as Command12 } from "commander";
+
+// src/core/skills-doctor.ts
+import * as path13 from "path";
+import * as fs11 from "fs/promises";
+async function runSkillsDoctor(options) {
+  const { projectRoot } = options;
+  const lock = await readSkillsLock(projectRoot);
+  if (!lock || Object.keys(lock.skills).length === 0) {
+    return { status: "no-skills", findings: [] };
+  }
+  const findings = [];
+  for (const [skillId, entry] of Object.entries(lock.skills)) {
+    const sourceDir = getSkillsSourceDir(projectRoot, skillId);
+    if (!await dirExists2(sourceDir)) {
+      findings.push({
+        kind: "missing-source",
+        skillId,
+        path: sourceDir,
+        detail: 'Run "teamix-evo skills add" to reinstall.'
+      });
+      continue;
+    }
+    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"));
+    }
+    for (const ide of entry.mirroredTo) {
+      const adapter = getAdapter(ide);
+      const mirrorDir = adapter.getSkillTargetDir(
+        skillId,
+        entry.scope,
+        projectRoot
+      );
+      if (!await dirExists2(mirrorDir)) {
+        findings.push({
+          kind: "missing-mirror",
+          skillId,
+          ide,
+          scope: entry.scope,
+          path: mirrorDir,
+          detail: 'Run "teamix-evo skills sync" to re-mirror.'
+        });
+        continue;
+      }
+      for (const [rel2, sourceContent] of sourceContents.entries()) {
+        const mirrorFile = path13.join(mirrorDir, rel2);
+        if (!await fileExists(mirrorFile)) {
+          findings.push({
+            kind: "missing-mirror",
+            skillId,
+            ide,
+            scope: entry.scope,
+            path: mirrorFile,
+            detail: 'Run "teamix-evo skills sync" to re-mirror.'
+          });
+          continue;
+        }
+        const mirrorContent = await fs11.readFile(mirrorFile, "utf-8");
+        if (computeHash(mirrorContent) !== computeHash(sourceContent)) {
+          findings.push({
+            kind: "mirror-drift",
+            skillId,
+            ide,
+            scope: entry.scope,
+            path: mirrorFile,
+            detail: 'Mirror differs from source. Re-run "teamix-evo skills sync" to overwrite.'
+          });
+        }
+      }
+    }
+  }
+  return {
+    status: findings.length === 0 ? "clean" : "drift",
+    findings
+  };
+}
+async function dirExists2(p) {
+  try {
+    const stat4 = await fs11.stat(p);
+    return stat4.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/skills/doctor.ts
+var doctorCommand = new Command12("doctor").description(
+  "\u68C0\u67E5 .teamix-evo/skills/ \u6E90\u4E0E IDE \u955C\u50CF\u662F\u5426\u6F02\u79FB\uFF1B\u63D0\u793A\u5982\u4F55\u4FEE\u590D"
+).action(async () => {
   try {
     const ide = detectIde();
     const projectRoot = ide.getProjectRoot();
-    const config = await readProjectConfig(projectRoot);
-    if (!config?.packages?.skills) {
-      logger.info("Skills are not installed. Nothing to do.");
+    const result = await runSkillsDoctor({ projectRoot });
+    if (result.status === "no-skills") {
+      logger.info(
+        'No skills recorded. Run "teamix-evo skills add" first.'
+      );
       return;
     }
-    const installedManifest = await readInstalledManifest(projectRoot);
-    const pkg = installedManifest?.installed.find(
-      (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 (prompts3.isCancel(confirm4) || !confirm4) {
-        logger.info("Cancelled.");
-        return;
-      }
+    if (result.status === "clean") {
+      logger.success("Skills are in sync. No drift detected.");
+      return;
     }
-    const removed = await removeSkillFiles(resources);
-    logger.debug(`Removed ${removed.length} files`);
-    if (installedManifest && pkg) {
-      installedManifest.installed = installedManifest.installed.filter(
-        (p) => p.package !== SKILLS_PACKAGE3
-      );
-      await writeInstalledManifest(projectRoot, installedManifest);
+    logger.warn(
+      `Found ${result.findings.length} drift issue(s). Run "teamix-evo skills sync" to repair mirrors.`
+    );
+    for (const f of result.findings) {
+      const idePart = f.ide ? ` [${f.ide}]` : "";
+      logger.info(`  - ${f.kind}${idePart}: ${f.skillId}`);
+      logger.info(`      ${f.path}`);
+      if (f.detail) logger.info(`      ${f.detail}`);
     }
-    delete config.packages.skills;
-    await writeProjectConfig(projectRoot, config);
-    logger.success(`Uninstalled ${SKILLS_PACKAGE3}`);
-    logger.info(`  Removed: ${removed.length} files`);
+    process.exitCode = 1;
   } catch (err) {
-    logger.error(`Failed to uninstall: ${err.message}`);
+    logger.error(`Failed to run doctor: ${err.message}`);
     logger.debug(err.stack ?? "");
     process.exitCode = 1;
   }
 });
 
 // src/commands/skills/index.ts
-var skillsCommand = new Command10("skills").description(
-  "\u7BA1\u7406 teamix-evo skills\uFF08\u5411 AI IDE \u6CE8\u5165\u6280\u80FD\uFF09"
+var skillsCommand = new Command13("skills").description(
+  "\u7BA1\u7406 teamix-evo skills\uFF08\u5411 AI IDE \u6CE8\u5165\u6280\u80FD\uFF1Bsource-mirror \u6A21\u578B\u89C1 ADR 0013\uFF09"
 );
 skillsCommand.addCommand(addCommand);
 skillsCommand.addCommand(listCommand2);
 skillsCommand.addCommand(updateCommand2);
+skillsCommand.addCommand(syncCommand);
+skillsCommand.addCommand(doctorCommand);
 skillsCommand.addCommand(uninstallCommand2);
 
 // src/commands/ui/index.ts
-import { Command as Command14 } from "commander";
+import { Command as Command17 } from "commander";
 
 // src/commands/ui/init.ts
-import { Command as Command11 } from "commander";
+import { Command as Command14 } from "commander";
 import * as prompts4 from "@clack/prompts";
 
 // src/core/ui-init.ts
@@ -1665,7 +1997,9 @@ var DEFAULT_UI_ALIASES = {
   components: "src/components/ui",
   hooks: "src/hooks",
   utils: "src/lib/utils",
-  lib: "src/lib"
+  lib: "src/lib",
+  business: "src/components/business",
+  templates: "src/templates"
 };
 var DEFAULT_UI_ICON_LIBRARY = "lucide";
 async function runUiInit(options) {
@@ -1680,7 +2014,9 @@ async function runUiInit(options) {
     components: options.aliases?.components ?? DEFAULT_UI_ALIASES.components,
     hooks: options.aliases?.hooks ?? DEFAULT_UI_ALIASES.hooks,
     utils: options.aliases?.utils ?? DEFAULT_UI_ALIASES.utils,
-    lib: options.aliases?.lib ?? DEFAULT_UI_ALIASES.lib
+    lib: options.aliases?.lib ?? DEFAULT_UI_ALIASES.lib,
+    business: options.aliases?.business ?? DEFAULT_UI_ALIASES.business,
+    templates: options.aliases?.templates ?? DEFAULT_UI_ALIASES.templates
   };
   const iconLibrary = options.iconLibrary ?? DEFAULT_UI_ICON_LIBRARY;
   const tsx = options.tsx ?? true;
@@ -1710,7 +2046,7 @@ async function runUiInit(options) {
 }
 
 // src/commands/ui/init.ts
-var initCommand2 = new Command11("init").description(
+var initCommand2 = new Command14("init").description(
   "\u521D\u59CB\u5316 teamix-evo ui \u914D\u7F6E\uFF08\u8BE2\u95EE aliases / iconLibrary / tsx / rsc\uFF09"
 ).option("-y, --yes", "\u4F7F\u7528\u9ED8\u8BA4\u503C\uFF0C\u8DF3\u8FC7\u4EA4\u4E92").option(
   "--components <path>",
@@ -1757,7 +2093,9 @@ async function resolveConfig(opts) {
         components: opts.components ?? DEFAULT_UI_ALIASES.components,
         hooks: opts.hooks ?? DEFAULT_UI_ALIASES.hooks,
         utils: opts.utils ?? DEFAULT_UI_ALIASES.utils,
-        lib: opts.lib ?? DEFAULT_UI_ALIASES.lib
+        lib: opts.lib ?? DEFAULT_UI_ALIASES.lib,
+        business: DEFAULT_UI_ALIASES.business,
+        templates: DEFAULT_UI_ALIASES.templates
       },
       iconLibrary: opts.iconLibrary ?? "lucide",
       tsx: opts.tsx ?? true,
@@ -1800,7 +2138,14 @@ async function resolveConfig(opts) {
   });
   if (prompts4.isCancel(rscAns)) throw new Error("Cancelled by user.");
   return {
-    aliases: { components, hooks, utils, lib },
+    aliases: {
+      components,
+      hooks,
+      utils,
+      lib,
+      business: DEFAULT_UI_ALIASES.business,
+      templates: DEFAULT_UI_ALIASES.templates
+    },
     iconLibrary,
     tsx: tsxAns,
     rsc: rscAns
@@ -1808,26 +2153,26 @@ async function resolveConfig(opts) {
 }
 
 // src/commands/ui/add.ts
-import { Command as Command12 } from "commander";
+import { Command as Command15 } from "commander";
 
 // src/core/ui-client.ts
-import * as path12 from "path";
-import * as fs10 from "fs/promises";
+import * as path14 from "path";
+import * as fs12 from "fs/promises";
 import { createRequire as createRequire3 } from "module";
 import { loadUiPackageManifest } from "@teamix-evo/registry";
 var require4 = createRequire3(import.meta.url);
-function resolvePackageRoot3(packageName) {
+function resolvePackageRoot2(packageName) {
   const pkgJsonPath = require4.resolve(`${packageName}/package.json`);
-  return path12.dirname(pkgJsonPath);
+  return path14.dirname(pkgJsonPath);
 }
 async function loadUiData(packageName) {
-  const packageRoot = resolvePackageRoot3(packageName);
+  const packageRoot = resolvePackageRoot2(packageName);
   logger.debug(`Resolved ui package root: ${packageRoot}`);
   const manifest = await loadUiPackageManifest(packageRoot);
   let data = {};
-  const dataPath = path12.join(packageRoot, "_data.json");
+  const dataPath = path14.join(packageRoot, "_data.json");
   try {
-    const raw = await fs10.readFile(dataPath, "utf-8");
+    const raw = await fs12.readFile(dataPath, "utf-8");
     data = JSON.parse(raw);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -1839,8 +2184,8 @@ async function loadUiData(packageName) {
 }
 
 // src/core/ui-installer.ts
-import * as path13 from "path";
-import * as fs11 from "fs/promises";
+import * as path15 from "path";
+import * as fs13 from "fs/promises";
 import { resolveUiEntryOrder } from "@teamix-evo/registry";
 
 // src/utils/transform-imports.ts
@@ -1858,10 +2203,19 @@ function rewriteImports(source, aliases) {
       if (!aliasKey) return full;
       const alias = aliases[aliasKey];
       const normalized = aliasToImportPath(alias);
-      return `${quote}${normalized}${rest ?? ""}${quote}`;
+      const flatRest = flattenRestPath(rest);
+      return `${quote}${normalized}${flatRest}${quote}`;
     }
   );
 }
+function flattenRestPath(rest) {
+  if (!rest) return "";
+  const segments = rest.split("/");
+  if (segments.length === 3) {
+    return `/${segments[2]}`;
+  }
+  return rest;
+}
 function aliasToImportPath(alias) {
   const trimmed = alias.replace(/^\.\//, "").replace(/\/$/, "");
   if (trimmed.startsWith("src/")) {
@@ -1904,8 +2258,8 @@ async function installUiEntries(options) {
         skipped++;
         continue;
       }
-      const sourceAbs = path13.resolve(packageRoot, file.source);
-      const raw = await fs11.readFile(sourceAbs, "utf-8");
+      const sourceAbs = path15.resolve(packageRoot, file.source);
+      const raw = await fs13.readFile(sourceAbs, "utf-8");
       const transformed = rewriteImports(raw, aliases);
       await writeFileSafe(targetAbs, transformed);
       written++;
@@ -1918,9 +2272,9 @@ async function installUiEntries(options) {
       });
     }
     if (entry.meta) {
-      const metaSourceAbs = path13.resolve(packageRoot, entry.meta);
-      const metaContent = await fs11.readFile(metaSourceAbs, "utf-8");
-      const metaTargetAbs = path13.join(
+      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`
@@ -1952,10 +2306,10 @@ function resolveTargetPath(projectRoot, aliases, entry, file) {
       `Entry "${entry.id}" requires alias "${file.targetAlias}" but it is not configured.`
     );
   }
-  return path13.join(projectRoot, aliasDir, file.targetName);
+  return path15.join(projectRoot, aliasDir, file.targetName);
 }
 function rel(projectRoot, abs) {
-  return path13.relative(projectRoot, abs);
+  return path15.relative(projectRoot, abs);
 }
 
 // src/core/ui-add.ts
@@ -2030,7 +2384,7 @@ function mergeResources(prior, next) {
 }
 
 // src/commands/ui/add.ts
-var addCommand2 = new Command12("add").description(
+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 {
@@ -2074,7 +2428,7 @@ var addCommand2 = new Command12("add").description(
 });
 
 // src/commands/ui/list.ts
-import { Command as Command13 } from "commander";
+import { Command as Command16 } from "commander";
 
 // src/core/ui-list.ts
 var DEFAULT_UI_PACKAGE2 = "@teamix-evo/ui";
@@ -2106,7 +2460,7 @@ async function runUiList(options) {
 }
 
 // src/commands/ui/list.ts
-var listCommand3 = new Command13("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) => {
+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();
@@ -2152,20 +2506,301 @@ var listCommand3 = new Command13("list").description("\u5217\u51FA @teamix-evo/u
 });
 
 // src/commands/ui/index.ts
-var uiCommand = new Command14("ui").description(
+var uiCommand = new Command17("ui").description(
   "\u7BA1\u7406 teamix-evo ui \u7EC4\u4EF6\uFF08\u6E90\u7801\u6CE8\u5165\u5F0F\u5B89\u88C5\uFF0Cshadcn \u98CE\u683C\uFF09"
 );
 uiCommand.addCommand(initCommand2);
 uiCommand.addCommand(addCommand2);
 uiCommand.addCommand(listCommand3);
 
-// src/index.ts
+// src/commands/biz-ui/index.ts
+import { Command as Command20 } 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 {
+  loadVariantUiPackageCatalog,
+  loadVariantUiPackageManifest
+} from "@teamix-evo/registry";
 var require5 = createRequire4(import.meta.url);
-var { version } = require5("../package.json");
-var program = new Command15();
+function resolvePackageRoot3(packageName) {
+  const pkgJsonPath = require5.resolve(`${packageName}/package.json`);
+  return path16.dirname(pkgJsonPath);
+}
+async function runVariantUiAdd(packageName, options) {
+  const { projectRoot, variant, ids, overwrite } = options;
+  const fullPackageName = options.packageName ?? `@teamix-evo/${packageName}`;
+  if (ids.length === 0) {
+    throw new Error("At least one entry id must be provided.");
+  }
+  const config = await readProjectConfig(projectRoot);
+  const uiCfg = config?.packages?.ui;
+  if (!config || !uiCfg?.aliases) {
+    throw new Error(
+      `UI not initialized. Run \`teamix-evo ui init\` first \u2014 \`${packageName} add\` writes into the same alias map (business / templates).`
+    );
+  }
+  const packageRoot = options.packageRoot ?? resolvePackageRoot3(fullPackageName);
+  const catalog = await loadVariantUiPackageCatalog(packageRoot);
+  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 variants: ${known}. Hint: \`teamix-evo ${packageName} list-variants\` shows all.`
+    );
+  }
+  const variantDir = path16.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.`
+    );
+  }
+  const adaptedManifest = {
+    schemaVersion: 1,
+    package: "ui",
+    version: variantManifest.version,
+    engines: variantManifest.engines,
+    entries: variantManifest.entries
+  };
+  const result = await installUiEntries({
+    projectRoot,
+    manifest: adaptedManifest,
+    packageRoot: variantDir,
+    // sources resolved relative to variant dir
+    aliases: uiCfg.aliases,
+    requested: ids,
+    skipExisting: !overwrite
+  });
+  const installed = await readInstalledManifest(
+    projectRoot
+  ) ?? { schemaVersion: 1, installed: [] };
+  const idx = installed.installed.findIndex(
+    (p) => p.package === fullPackageName && p.variant === variant
+  );
+  const prior = idx >= 0 ? installed.installed[idx] : null;
+  const mergedResources = mergeResources2(
+    prior?.resources ?? [],
+    result.resources
+  );
+  const entry = {
+    package: fullPackageName,
+    variant,
+    version: variantManifest.version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resources: mergedResources
+  };
+  if (idx >= 0) installed.installed[idx] = entry;
+  else installed.installed.push(entry);
+  await writeInstalledManifest(projectRoot, installed);
+  return {
+    packageName: fullPackageName,
+    variant,
+    orderedIds: result.orderedIds,
+    written: result.written,
+    skipped: result.skipped,
+    metaFiles: result.metaFiles,
+    npmDependencies: result.npmDependencies,
+    resources: result.resources
+  };
+}
+function mergeResources2(prior, next) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const r of prior) merged.set(r.id, r);
+  for (const r of next) merged.set(r.id, r);
+  return Array.from(merged.values());
+}
+async function runBizUiAdd(options) {
+  return runVariantUiAdd("biz-ui", options);
+}
+async function runTemplatesAdd(options) {
+  return runVariantUiAdd("templates", options);
+}
+async function listVariantUi(packageName, packageRoot) {
+  const fullPackageName = `@teamix-evo/${packageName}`;
+  const root = packageRoot ?? resolvePackageRoot3(fullPackageName);
+  const catalog = await loadVariantUiPackageCatalog(root);
+  return {
+    packageName: fullPackageName,
+    variants: catalog.variants.map((v) => ({
+      name: v.name,
+      displayName: v.displayName,
+      version: v.version,
+      description: v.description
+    }))
+  };
+}
+async function listBizUiVariants(packageRoot) {
+  return listVariantUi("biz-ui", packageRoot);
+}
+async function listTemplatesVariants(packageRoot) {
+  return listVariantUi("templates", packageRoot);
+}
+
+// src/commands/biz-ui/add.ts
+var addCommand3 = new Command18("add").description(
+  "\u5B89\u88C5\u4E00\u4E2A\u6216\u591A\u4E2A\u4E1A\u52A1 UI \u7EC4\u4EF6(\u6309 id,\u81EA\u52A8\u5C55\u5F00 ui \u5305\u7684 registryDependencies)"
+).argument("<ids...>", '\u7EC4\u4EF6 id \u5217\u8868,\u5982 "tenant-switcher" "org-picker"').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) => {
+    try {
+      if (!opts.variant) {
+        throw new Error(
+          "--variant <name> is required. Run `teamix-evo biz-ui list-variants` to see available variants."
+        );
+      }
+      const ide = detectIde();
+      const projectRoot = ide.getProjectRoot();
+      logger.info(
+        `Installing biz-ui entries from variant "${opts.variant}": ${ids.join(", ")}`
+      );
+      const result = await runBizUiAdd({
+        projectRoot,
+        variant: opts.variant,
+        ids,
+        overwrite: opts.overwrite
+      });
+      logger.success(
+        `biz-ui add complete: ${result.written} written, ${result.skipped} skipped, ${result.metaFiles.length} meta.`
+      );
+      logger.info("");
+      logger.info(`Variant: ${result.variant}`);
+      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}`);
+      }
+    } catch (err) {
+      logger.error(`Failed: ${err.message}`);
+      logger.debug(err.stack ?? "");
+      process.exitCode = 1;
+    }
+  }
+);
+
+// src/commands/biz-ui/list-variants.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 () => {
+  try {
+    const result = await listBizUiVariants();
+    logger.info(`Available biz-ui variants in ${result.packageName}:`);
+    logger.info("");
+    if (result.variants.length === 0) {
+      logger.info("  (no variants yet)");
+      return;
+    }
+    for (const v of result.variants) {
+      logger.info(`  ${v.name} (${v.displayName}) \u2014 v${v.version}`);
+      if (v.description) logger.info(`    ${v.description}`);
+      logger.info("");
+    }
+    logger.info("Install from a variant: teamix-evo biz-ui add <id> --variant <name>");
+  } catch (err) {
+    logger.error(`Failed: ${err.message}`);
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/biz-ui/index.ts
+var bizUiCommand = new Command20("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(listVariantsCommand2);
+
+// src/commands/templates/index.ts
+import { Command as Command23 } from "commander";
+
+// src/commands/templates/add.ts
+import { Command as Command21 } from "commander";
+var addCommand4 = new Command21("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) => {
+    try {
+      if (!opts.variant) {
+        throw new Error(
+          "--variant <name> is required. Run `teamix-evo templates list-variants` to see available variants."
+        );
+      }
+      const ide = detectIde();
+      const projectRoot = ide.getProjectRoot();
+      logger.info(
+        `Installing templates from variant "${opts.variant}": ${ids.join(", ")}`
+      );
+      const result = await runTemplatesAdd({
+        projectRoot,
+        variant: opts.variant,
+        ids,
+        overwrite: opts.overwrite
+      });
+      logger.success(
+        `templates add complete: ${result.written} written, ${result.skipped} skipped, ${result.metaFiles.length} meta.`
+      );
+      logger.info("");
+      logger.info(`Variant: ${result.variant}`);
+      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}`);
+      }
+    } catch (err) {
+      logger.error(`Failed: ${err.message}`);
+      logger.debug(err.stack ?? "");
+      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 () => {
+  try {
+    const result = await listTemplatesVariants();
+    logger.info(`Available templates variants in ${result.packageName}:`);
+    logger.info("");
+    if (result.variants.length === 0) {
+      logger.info("  (no variants yet)");
+      return;
+    }
+    for (const v of result.variants) {
+      logger.info(`  ${v.name} (${v.displayName}) \u2014 v${v.version}`);
+      if (v.description) logger.info(`    ${v.description}`);
+      logger.info("");
+    }
+    logger.info("Install from a variant: teamix-evo templates add <id> --variant <name>");
+  } catch (err) {
+    logger.error(`Failed: ${err.message}`);
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/templates/index.ts
+var templatesCommand = new Command23("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(listVariantsCommand3);
+
+// src/index.ts
+var require6 = createRequire5(import.meta.url);
+var { version } = require6("../package.json");
+var program = new Command24();
 program.name("teamix-evo").description("Where ideas evolve. \u2014 AI Coding \u5957\u4EF6").version(version);
 program.addCommand(designCommand);
 program.addCommand(skillsCommand);
 program.addCommand(uiCommand);
+program.addCommand(bizUiCommand);
+program.addCommand(templatesCommand);
 program.parse();
 //# sourceMappingURL=index.js.map