teamix-evo 0.2.0 → 0.3.1

package/dist/core/index.js

@@ -1,8 +1,16 @@
-// src/core/registry-client.ts
-import * as path 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 path from "path";
 
 // src/utils/logger.ts
 import { red, yellow, cyan, green, gray } from "kolorist";
@@ -27,52 +35,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 path.dirname(pkgJsonPath);
-}
-async function loadVariantData(packageName, variant) {
-  const packageRoot = resolvePackageRoot(packageName);
-  const variantDir = path.join(packageRoot, "library", variant);
-  logger.debug(`Resolved variant dir: ${variantDir}`);
-  logger.debug(`Package root: ${packageRoot}`);
-  const manifest = await loadVariantManifest(variantDir);
-  let data = {};
-  const dataPath = path.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 path4 from "path";
-import * as fs5 from "fs/promises";
-
 // src/utils/fs.ts
-import * as fs2 from "fs/promises";
-import * as path2 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 = path2.dirname(filePath);
+  const dir = path.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;
@@ -86,21 +62,21 @@ async function backupFile(filePath, projectRoot) {
     logger.debug(`Skip backup: ${filePath} does not exist`);
     return;
   }
-  const rel2 = path2.relative(projectRoot, filePath);
+  const rel2 = path.relative(projectRoot, filePath);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupPath = path2.join(
+  const backupPath = path.join(
     projectRoot,
     ".teamix-evo",
     ".backups",
     `${rel2}.${timestamp}.bak`
   );
-  await ensureDir(path2.dirname(backupPath));
-  await fs2.writeFile(backupPath, content, "utf-8");
-  logger.debug(`Backed up ${rel2} \u2192 ${path2.relative(projectRoot, backupPath)}`);
+  await ensureDir(path.dirname(backupPath));
+  await fs.writeFile(backupPath, content, "utf-8");
+  logger.debug(`Backed up ${rel2} \u2192 ${path.relative(projectRoot, backupPath)}`);
 }
 async function fileExists(filePath) {
   try {
-    await fs2.access(filePath);
+    await fs.access(filePath);
     return true;
   } catch {
     return false;
@@ -114,157 +90,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 path3 from "path";
-import * as fs4 from "fs/promises";
-function resolveSourcePath(source, variantDir, packageRoot) {
-  if (source.startsWith("_template/")) {
-    return path3.join(packageRoot, source);
+// src/core/design-pack-classify.ts
+import * as path2 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 (path2.basename(relPath) === "README.md") {
+    return null;
   }
-  return path3.join(variantDir, source);
-}
-async function walkDir(dir) {
-  const files = [];
-  const entries = await fs4.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path3.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 = path2.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 = path4.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: path2.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: path2.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 = path4.join(projectRoot, resource.target);
-  const results = [];
-  await ensureDir(targetDir);
-  const entries = await walkDir(sourcePath);
-  for (const entry of entries) {
-    const relPath = path4.relative(sourcePath, entry);
-    let targetFile = path4.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 = path4.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 path5 from "path";
-import { validateConfig, validateInstalled } from "@teamix-evo/registry";
-var TEAMIX_DIR = ".teamix-evo";
+import * as path3 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 path5.join(projectRoot, TEAMIX_DIR);
+  return path3.join(projectRoot, TEAMIX_DIR2);
 }
 async function ensureTeamixDir(projectRoot) {
   const dir = getTeamixDir(projectRoot);
@@ -272,7 +162,7 @@ async function ensureTeamixDir(projectRoot) {
   return dir;
 }
 async function readProjectConfig(projectRoot) {
-  const configPath = path5.join(projectRoot, TEAMIX_DIR, CONFIG_FILE);
+  const configPath = path3.join(projectRoot, TEAMIX_DIR2, CONFIG_FILE);
   const raw = await readFileOrNull(configPath);
   if (raw === null) return null;
   try {
@@ -289,12 +179,12 @@ async function readProjectConfig(projectRoot) {
   }
 }
 async function writeProjectConfig(projectRoot, config) {
-  const configPath = path5.join(projectRoot, TEAMIX_DIR, CONFIG_FILE);
+  const configPath = path3.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 = path5.join(projectRoot, TEAMIX_DIR, MANIFEST_FILE);
+  const manifestPath = path3.join(projectRoot, TEAMIX_DIR2, MANIFEST_FILE);
   const raw = await readFileOrNull(manifestPath);
   if (raw === null) return null;
   try {
@@ -311,90 +201,94 @@ async function readInstalledManifest(projectRoot) {
   }
 }
 async function writeInstalledManifest(projectRoot, manifest) {
-  const manifestPath = path5.join(projectRoot, TEAMIX_DIR, MANIFEST_FILE);
+  const manifestPath = path3.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
+async function readDesignPackLock(projectRoot) {
+  const lockPath = path3.join(
+    projectRoot,
+    TEAMIX_DIR2,
+    DESIGN_DIR,
+    DESIGN_LOCK_FILE
   );
-  const result = await installResources({
+  const raw = await readFileOrNull(lockPath);
+  if (raw === null) return null;
+  try {
+    const parsed = DesignPackLockSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) {
+      logger.warn(`Invalid design pack.lock.json: ${parsed.error.message}`);
+      return null;
+    }
+    return parsed.data;
+  } catch (err) {
+    logger.warn(
+      `Failed to parse design pack.lock.json: ${err.message}`
+    );
+    return null;
+  }
+}
+async function readDesignVariant(projectRoot) {
+  const lock = await readDesignPackLock(projectRoot);
+  return lock?.variant.name ?? null;
+}
+function getSkillsSourceDir(projectRoot, skillName) {
+  const base = path3.join(projectRoot, TEAMIX_DIR2, SKILLS_DIR);
+  return skillName ? path3.join(base, skillName) : base;
+}
+async function readSkillsLock(projectRoot) {
+  const lockPath = path3.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
-      }
+    TEAMIX_DIR2,
+    SKILLS_DIR,
+    SKILLS_LOCK_FILE
+  );
+  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;
     }
-  };
-  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
-  };
+    return result.data;
+  } catch (err) {
+    logger.warn(
+      `Failed to parse skills manifest.lock.json: ${err.message}`
+    );
+    return null;
+  }
+}
+async function writeSkillsLock(projectRoot, lock) {
+  const lockPath = path3.join(
+    projectRoot,
+    TEAMIX_DIR2,
+    SKILLS_DIR,
+    SKILLS_LOCK_FILE
+  );
+  await writeFileSafe(lockPath, JSON.stringify(lock, null, 2) + "\n");
+  logger.debug(`Wrote skills lock \u2192 ${lockPath}`);
 }
 
 // src/core/skills-client.ts
-import * as path6 from "path";
-import * as fs6 from "fs/promises";
-import { createRequire as createRequire2 } from "module";
+import * as path4 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 path6.dirname(pkgJsonPath);
+var require2 = createRequire(import.meta.url);
+function resolvePackageRoot(packageName) {
+  const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
+  return path4.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 = path6.join(packageRoot, "_data.json");
+  const dataPath = path4.join(packageRoot, "_data.json");
   try {
-    const raw = await fs6.readFile(dataPath, "utf-8");
+    const raw = await fs2.readFile(dataPath, "utf-8");
     data = JSON.parse(raw);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -406,13 +300,13 @@ async function loadSkillsData(packageName) {
 }
 
 // src/core/skills-installer.ts
-import * as path9 from "path";
-import * as fs7 from "fs/promises";
+import * as path8 from "path";
+import * as fs5 from "fs/promises";
 import { replaceManagedRegion } from "@teamix-evo/registry";
 
 // src/ide/QoderAdapter.ts
 import * as os from "os";
-import * as path7 from "path";
+import * as path5 from "path";
 var QoderAdapter = class {
   kind = "qoder";
   name = "qoder";
@@ -423,14 +317,14 @@ var QoderAdapter = class {
     return true;
   }
   getSkillTargetDir(skillName, scope, projectRoot) {
-    const base = scope === "global" ? path7.join(os.homedir(), ".qoder") : path7.join(projectRoot ?? this.getProjectRoot(), ".qoder");
-    return path7.join(base, "skills", skillName);
+    const base = scope === "global" ? path5.join(os.homedir(), ".qoder") : path5.join(projectRoot ?? this.getProjectRoot(), ".qoder");
+    return path5.join(base, "skills", skillName);
   }
 };
 
 // src/ide/ClaudeAdapter.ts
 import * as os2 from "os";
-import * as path8 from "path";
+import * as path6 from "path";
 var ClaudeAdapter = class {
   kind = "claude";
   name = "claude";
@@ -441,8 +335,8 @@ var ClaudeAdapter = class {
     return Boolean(process.env.CLAUDECODE);
   }
   getSkillTargetDir(skillName, scope, projectRoot) {
-    const base = scope === "global" ? path8.join(os2.homedir(), ".claude") : path8.join(projectRoot ?? this.getProjectRoot(), ".claude");
-    return path8.join(base, "skills", skillName);
+    const base = scope === "global" ? path6.join(os2.homedir(), ".claude") : path6.join(projectRoot ?? this.getProjectRoot(), ".claude");
+    return path6.join(base, "skills", skillName);
   }
 };
 
@@ -460,6 +354,57 @@ function getAdapter(kind) {
   }
 }
 
+// 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";
+function resolveSourcePath(source, variantDir, packageRoot) {
+  if (source.startsWith("_template/")) {
+    return path7.join(packageRoot, source);
+  }
+  return path7.join(variantDir, source);
+}
+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;
@@ -477,60 +422,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 = path9.resolve(packageRoot, skill.source);
-  const stat2 = await fs7.stat(sourceAbs);
-  const results = [];
+  const sourceAbs = path8.resolve(packageRoot, skill.source);
+  const targetDir = getSkillsSourceDir(projectRoot, skill.name);
+  const stat2 = await fs5.stat(sourceAbs);
+  const records = [];
   if (stat2.isFile()) {
-    const targetFile = path9.join(targetDir, "SKILL.md");
+    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 = path9.relative(sourceAbs, entry);
-    let targetFile = path9.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 fs7.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);
+    const relWritten = path8.relative(targetDir, targetFile);
+    records.push(makeSourceRecord(skill, targetFile, content, relWritten));
+    logger.debug(`  Wrote source: ${targetFile}`);
+  }
+  return records;
+}
+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);
-    results.push(
-      makeInstalledRecord(skill, targetFile, content, ide, scope, rel2)
-    );
-    logger.debug(`  Wrote ${ide}:${scope}: ${targetFile}`);
+    records.push(makeMirrorRecord(skill, targetFile, content, ide, scope, rel2));
+    logger.debug(`  Mirrored ${ide}:${scope}: ${targetFile}`);
   }
-  return results;
+  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 fs7.readFile(sourceAbs, "utf-8");
+  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 makeInstalledRecord(skill, targetAbs, content, ide, scope, rel2) {
-  const id = rel2 ? `${skill.id}:${rel2}` : skill.id;
+function makeMirrorRecord(skill, targetAbs, content, ide, scope, rel2) {
+  const id = rel2 && rel2 !== "SKILL.md" ? `${skill.id}:${rel2}` : skill.id;
   return {
     id,
     target: targetAbs,
@@ -541,55 +511,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 = path9.resolve(packageRoot, skill.source);
-  const stat2 = await fs7.stat(sourceAbs);
-  const records = [];
+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 stat2 = await fs5.stat(sourceAbs);
   if (!stat2.isFile()) {
-    const entries = await walkDir(sourceAbs);
     await ensureDir(targetDir);
+    const entries = await walkDir(sourceAbs);
+    const records = [];
     for (const entry of entries) {
-      const rel2 = path9.relative(sourceAbs, entry);
-      let targetFile2 = path9.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 fs7.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);
@@ -598,30 +559,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 = path9.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) {
@@ -631,15 +585,11 @@ 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="${escapeRegExp(
         regionId
@@ -651,7 +601,7 @@ async function updateSkillForIde(skill, ide, scope, data, packageRoot, projectRo
     if (match) {
       const region = match[1].replace(/^\n/, "").replace(/\n$/, "");
       try {
-        updated = replaceManagedRegion(updated, regionId, region);
+        merged = replaceManagedRegion(merged, regionId, region);
       } catch {
         logger.warn(
           `Managed region "${regionId}" not found in ${targetFile}. Skipped.`
@@ -660,22 +610,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;
-}
-function installedKey(r) {
-  return `${r.id}|${r.ide ?? ""}|${r.scope ?? ""}`;
+  return [makeSourceRecord(skill, targetFile, merged)];
 }
 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 fs7.unlink(r.target);
+      await fs5.unlink(r.target);
       removed.push(r.target);
     } catch (err) {
       if (err.code !== "ENOENT") {
@@ -683,11 +668,11 @@ async function removeSkillFiles(records) {
       }
     }
   }
-  const parents = new Set(records.map((r) => path9.dirname(r.target)));
+  const parents = new Set(records.map((r) => path8.dirname(r.target)));
   for (const dir of parents) {
     try {
-      const entries = await fs7.readdir(dir);
-      if (entries.length === 0) await fs7.rmdir(dir);
+      const entries = await fs5.readdir(dir);
+      if (entries.length === 0) await fs5.rmdir(dir);
     } catch {
     }
   }
@@ -717,6 +702,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));
@@ -731,9 +717,13 @@ async function runSkillsAdd(options) {
   const existingPkg = existingInstalled?.installed.find(
     (p) => p.package === packageName
   );
-  const existingSkillIds = new Set(
-    (existingPkg?.resources ?? []).map((r) => r.id.split(":")[0])
-  );
+  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) {
@@ -741,7 +731,22 @@ async function runSkillsAdd(options) {
     onlyIds = requestedNames.filter((n) => !existingSkillIds.has(n));
   } else {
     skippedSkillIds = [];
-    onlyIds = manifest.skills.map((s) => s.id);
+    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 {
@@ -779,6 +784,7 @@ async function runSkillsAdd(options) {
     scope
   };
   await writeProjectConfig(projectRoot, config);
+  const installedAt = (/* @__PURE__ */ new Date()).toISOString();
   const installedManifest = existingInstalled ?? {
     schemaVersion: 1,
     installed: []
@@ -794,12 +800,29 @@ async function runSkillsAdd(options) {
     package: packageName,
     variant: FLAT_VARIANT,
     version: manifest.version,
-    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    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,
@@ -821,12 +844,208 @@ function mergeInstalledResources(existing, next) {
   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);
+}
+
 // src/core/ui-init.ts
 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) {
@@ -841,7 +1060,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;
@@ -872,22 +1093,22 @@ async function runUiInit(options) {
 
 // src/core/ui-client.ts
 import * as path10 from "path";
-import * as fs8 from "fs/promises";
+import * as fs7 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 path10.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 = path10.join(packageRoot, "_data.json");
   try {
-    const raw = await fs8.readFile(dataPath, "utf-8");
+    const raw = await fs7.readFile(dataPath, "utf-8");
     data = JSON.parse(raw);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -900,7 +1121,7 @@ async function loadUiData(packageName) {
 
 // src/core/ui-installer.ts
 import * as path11 from "path";
-import * as fs9 from "fs/promises";
+import * as fs8 from "fs/promises";
 import { resolveUiEntryOrder } from "@teamix-evo/registry";
 
 // src/utils/transform-imports.ts
@@ -918,10 +1139,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/")) {
@@ -965,7 +1195,7 @@ async function installUiEntries(options) {
         continue;
       }
       const sourceAbs = path11.resolve(packageRoot, file.source);
-      const raw = await fs9.readFile(sourceAbs, "utf-8");
+      const raw = await fs8.readFile(sourceAbs, "utf-8");
       const transformed = rewriteImports(raw, aliases);
       await writeFileSafe(targetAbs, transformed);
       written++;
@@ -979,7 +1209,7 @@ async function installUiEntries(options) {
     }
     if (entry.meta) {
       const metaSourceAbs = path11.resolve(packageRoot, entry.meta);
-      const metaContent = await fs9.readFile(metaSourceAbs, "utf-8");
+      const metaContent = await fs8.readFile(metaSourceAbs, "utf-8");
       const metaTargetAbs = path11.join(
         projectRoot,
         DESIGN_COMPONENTS_DIR,
@@ -1021,7 +1251,7 @@ async function removeUiFiles(records) {
   const removed = [];
   for (const r of records) {
     try {
-      await fs9.unlink(r.target);
+      await fs8.unlink(r.target);
       removed.push(r.target);
     } catch (err) {
       if (err.code !== "ENOENT") {
@@ -1032,8 +1262,8 @@ async function removeUiFiles(records) {
   const parents = new Set(records.map((r) => path11.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 fs8.readdir(dir);
+      if (entries.length === 0) await fs8.rmdir(dir);
     } catch {
     }
   }
@@ -1139,6 +1369,130 @@ async function runUiList(options) {
     entries
   };
 }
+
+// src/core/installer.ts
+import * as path12 from "path";
+import * as fs9 from "fs/promises";
+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);
+    }
+  }
+  return {
+    resources: installedResources,
+    count: installedResources.length
+  };
+}
+async function installSingleResource(resource, projectRoot, data, variantDir, packageRoot) {
+  const sourcePath = resolveSourcePath(
+    resource.source,
+    variantDir,
+    packageRoot
+  );
+  const targetPath = path12.join(projectRoot, resource.target);
+  let content;
+  if (resource.template) {
+    const templateContent = await loadTemplateFile(sourcePath);
+    content = renderTemplate(templateContent, data);
+  } else {
+    content = await fs9.readFile(sourcePath, "utf-8");
+  }
+  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
+  };
+}
+async function installRecursiveResource(resource, projectRoot, data, variantDir, packageRoot) {
+  const sourcePath = resolveSourcePath(
+    resource.source,
+    variantDir,
+    packageRoot
+  );
+  const targetDir = path12.join(projectRoot, resource.target);
+  const results = [];
+  await ensureDir(targetDir);
+  const entries = await walkDir(sourcePath);
+  for (const entry of entries) {
+    const relPath = path12.relative(sourcePath, entry);
+    let targetFile = path12.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 fs9.readFile(entry, "utf-8");
+    }
+    await writeFileSafe(targetFile, content);
+    const hash = computeHash(content);
+    const targetRel = path12.relative(projectRoot, targetFile);
+    results.push({
+      id: `${resource.id}:${relPath}`,
+      target: targetRel,
+      hash,
+      strategy: resource.updateStrategy
+    });
+    logger.debug(`  Written: ${targetRel}`);
+  }
+  return results;
+}
+
+// src/core/registry-client.ts
+import * as path13 from "path";
+import * as fs10 from "fs/promises";
+import { createRequire as createRequire4 } from "module";
+import { loadVariantManifest } from "@teamix-evo/registry";
+var require5 = createRequire4(import.meta.url);
+function resolvePackageRoot3(packageName) {
+  const pkgJsonPath = require5.resolve(`${packageName}/package.json`);
+  return path13.dirname(pkgJsonPath);
+}
+async function loadVariantData(packageName, variant) {
+  const packageRoot = resolvePackageRoot3(packageName);
+  const variantDir = path13.join(packageRoot, "library", variant);
+  logger.debug(`Resolved variant dir: ${variantDir}`);
+  logger.debug(`Package root: ${packageRoot}`);
+  const manifest = await loadVariantManifest(variantDir);
+  let data = {};
+  const dataPath = path13.join(variantDir, "_data.json");
+  try {
+    const raw = await fs10.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 };
+}
 export {
   DEFAULT_UI_ALIASES,
   DEFAULT_UI_ICON_LIBRARY,
@@ -1159,6 +1513,7 @@ export {
   runUiAdd,
   runUiInit,
   runUiList,
+  syncSkillsToIdes,
   updateSkills,
   writeInstalledManifest,
   writeProjectConfig