aiblueprint-cli 1.4.58 → 1.4.59

package/dist/cli.js

@@ -34710,6 +34710,433 @@ async function symlinkCommand(params = {}) {
   }
 }
 
+// src/lib/agents-unifier.ts
+var import_fs_extra11 = __toESM(require_lib4(), 1);
+import crypto from "crypto";
+import os13 from "os";
+import path15 from "path";
+var IGNORED_ENTRY_NAMES = new Set([
+  ".DS_Store",
+  ".git",
+  "node_modules"
+]);
+function uniqueByPath(candidates) {
+  const seen = new Set;
+  const unique = [];
+  for (const candidate of candidates) {
+    const resolved = path15.resolve(candidate.path);
+    if (seen.has(resolved))
+      continue;
+    seen.add(resolved);
+    unique.push({ ...candidate, path: resolved });
+  }
+  return unique;
+}
+function getContainerCandidates(options) {
+  const folders = resolveFolders(options);
+  const cursorDir = path15.join(folders.rootDir, ".cursor");
+  const factoryDir = path15.join(folders.rootDir, ".factory");
+  const opencodeDir = path15.join(folders.rootDir, ".config", "opencode");
+  return uniqueByPath([
+    {
+      category: "skills",
+      label: "agents-skills",
+      path: path15.join(folders.agentsDir, "skills"),
+      isDestination: true
+    },
+    {
+      category: "skills",
+      label: "claude-skills",
+      path: path15.join(folders.claudeDir, "skills"),
+      linkWhenMissing: true
+    },
+    {
+      category: "skills",
+      label: "codex-skills",
+      path: path15.join(folders.codexDir, "skills"),
+      linkWhenMissing: true
+    },
+    {
+      category: "skills",
+      label: "cursor-skills",
+      path: path15.join(cursorDir, "skills"),
+      linkWhenParentExists: true
+    },
+    {
+      category: "skills",
+      label: "cursor-skills-cursor",
+      path: path15.join(cursorDir, "skills-cursor"),
+      linkWhenParentExists: true
+    },
+    {
+      category: "skills",
+      label: "factory-skills",
+      path: path15.join(factoryDir, "skills"),
+      linkWhenParentExists: true
+    },
+    {
+      category: "skills",
+      label: "opencode-skill",
+      path: path15.join(opencodeDir, "skill"),
+      linkWhenParentExists: true
+    },
+    {
+      category: "skills",
+      label: "opencode-skills",
+      path: path15.join(opencodeDir, "skills"),
+      linkWhenParentExists: true
+    },
+    {
+      category: "agents",
+      label: "agents-agents",
+      path: path15.join(folders.agentsDir, "agents"),
+      isDestination: true
+    },
+    {
+      category: "agents",
+      label: "claude-agents",
+      path: path15.join(folders.claudeDir, "agents"),
+      linkWhenMissing: true
+    },
+    {
+      category: "agents",
+      label: "claude-agnets",
+      path: path15.join(folders.claudeDir, "agnets")
+    },
+    {
+      category: "agents",
+      label: "codex-agents",
+      path: path15.join(folders.codexDir, "agents"),
+      linkWhenMissing: true
+    },
+    {
+      category: "agents",
+      label: "cursor-agents",
+      path: path15.join(cursorDir, "agents"),
+      linkWhenParentExists: true
+    },
+    {
+      category: "agents",
+      label: "factory-droids",
+      path: path15.join(factoryDir, "droids"),
+      linkWhenParentExists: true
+    },
+    {
+      category: "agents",
+      label: "opencode-agent",
+      path: path15.join(opencodeDir, "agent"),
+      linkWhenParentExists: true
+    },
+    {
+      category: "agents",
+      label: "opencode-agents",
+      path: path15.join(opencodeDir, "agents"),
+      linkWhenParentExists: true
+    }
+  ]);
+}
+function shouldCollectEntry(category, entry) {
+  if (IGNORED_ENTRY_NAMES.has(entry.name))
+    return false;
+  if (category === "skills" && entry.name === ".cursor-managed-skills-manifest.json") {
+    return true;
+  }
+  return entry.isFile() || entry.isDirectory() || entry.isSymbolicLink();
+}
+async function pathExistsOrSymlink(targetPath) {
+  const stat = await import_fs_extra11.default.lstat(targetPath).catch(() => null);
+  return Boolean(stat);
+}
+async function realPathIfPossible(targetPath) {
+  try {
+    return await import_fs_extra11.default.realpath(targetPath);
+  } catch {
+    return null;
+  }
+}
+function samePath(a, b) {
+  return path15.resolve(a) === path15.resolve(b);
+}
+function hashString(value) {
+  return crypto.createHash("sha256").update(value).digest("hex");
+}
+async function hashPath(targetPath) {
+  const stat = await import_fs_extra11.default.lstat(targetPath);
+  if (stat.isSymbolicLink()) {
+    const linkTarget = await import_fs_extra11.default.readlink(targetPath);
+    return hashString(`symlink:${linkTarget}`);
+  }
+  if (stat.isFile()) {
+    const fileHash = crypto.createHash("sha256");
+    fileHash.update("file:");
+    fileHash.update(await import_fs_extra11.default.readFile(targetPath));
+    return fileHash.digest("hex");
+  }
+  if (stat.isDirectory()) {
+    const entries = (await import_fs_extra11.default.readdir(targetPath, { withFileTypes: true })).filter((entry) => !IGNORED_ENTRY_NAMES.has(entry.name)).sort((a, b) => a.name.localeCompare(b.name));
+    const dirHash = crypto.createHash("sha256");
+    dirHash.update("dir:");
+    for (const entry of entries) {
+      dirHash.update(entry.name);
+      dirHash.update("\x00");
+      dirHash.update(await hashPath(path15.join(targetPath, entry.name)));
+      dirHash.update("\x00");
+    }
+    return dirHash.digest("hex");
+  }
+  return hashString(`other:${stat.mode}:${stat.size}`);
+}
+function suffixFromLabel(label) {
+  return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "source";
+}
+function nameWithSuffix(name, suffix, index) {
+  const parsed = path15.parse(name);
+  const numberedSuffix = index === 1 ? suffix : `${suffix}-${index}`;
+  if (parsed.ext && parsed.name) {
+    return `${parsed.name}--${numberedSuffix}${parsed.ext}`;
+  }
+  return `${name}--${numberedSuffix}`;
+}
+async function findTargetName(destinationDir, originalName, label) {
+  const suffix = suffixFromLabel(label);
+  let index = 1;
+  while (true) {
+    const candidate = nameWithSuffix(originalName, suffix, index);
+    if (!await pathExistsOrSymlink(path15.join(destinationDir, candidate))) {
+      return candidate;
+    }
+    index++;
+  }
+}
+async function addExistingDestinationHashes(destinationDir, knownHashes) {
+  if (!await import_fs_extra11.default.pathExists(destinationDir))
+    return;
+  const entries = await import_fs_extra11.default.readdir(destinationDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (IGNORED_ENTRY_NAMES.has(entry.name))
+      continue;
+    const entryPath = path15.join(destinationDir, entry.name);
+    knownHashes.set(await hashPath(entryPath), entry.name);
+  }
+}
+async function importCategoryEntries(category, candidates, destinationDir, result) {
+  await import_fs_extra11.default.ensureDir(destinationDir);
+  const destinationRealPath = await realPathIfPossible(destinationDir);
+  const knownHashes = new Map;
+  await addExistingDestinationHashes(destinationDir, knownHashes);
+  for (const candidate of candidates) {
+    if (candidate.category !== category || candidate.isDestination)
+      continue;
+    const candidateStat = await import_fs_extra11.default.lstat(candidate.path).catch(() => null);
+    if (!candidateStat)
+      continue;
+    const candidateRealPath = await realPathIfPossible(candidate.path);
+    if (destinationRealPath && candidateRealPath && samePath(destinationRealPath, candidateRealPath)) {
+      continue;
+    }
+    const entries = await import_fs_extra11.default.readdir(candidate.path, { withFileTypes: true }).catch(() => null);
+    if (!entries) {
+      result.skipped.push({
+        category,
+        path: candidate.path,
+        reason: "Could not read directory"
+      });
+      continue;
+    }
+    for (const entry of entries) {
+      if (!shouldCollectEntry(category, entry))
+        continue;
+      const sourcePath = path15.join(candidate.path, entry.name);
+      const sourceHash = await hashPath(sourcePath);
+      const existingName = knownHashes.get(sourceHash);
+      if (existingName) {
+        result.duplicates.push({
+          category,
+          name: entry.name,
+          from: sourcePath,
+          keptAs: path15.join(destinationDir, existingName)
+        });
+        continue;
+      }
+      let targetName = entry.name;
+      let targetPath = path15.join(destinationDir, targetName);
+      if (await pathExistsOrSymlink(targetPath)) {
+        targetName = await findTargetName(destinationDir, entry.name, candidate.label);
+        targetPath = path15.join(destinationDir, targetName);
+        result.renamed.push({
+          category,
+          name: entry.name,
+          from: sourcePath,
+          to: targetPath,
+          reason: "Same name with different content"
+        });
+      }
+      await import_fs_extra11.default.copy(sourcePath, targetPath, {
+        dereference: false,
+        overwrite: false
+      });
+      knownHashes.set(sourceHash, targetName);
+      result.imported.push({
+        category,
+        name: entry.name,
+        from: sourcePath,
+        to: targetPath
+      });
+    }
+  }
+}
+function timestamp2(date = new Date) {
+  return date.toISOString().replace(/\.\d{3}Z$/, "").replace(/[:T]/g, "-");
+}
+function safeRelativePath(rootDir, targetPath) {
+  const relativePath = path15.relative(rootDir, targetPath);
+  if (!relativePath || relativePath.startsWith("..") || path15.isAbsolute(relativePath)) {
+    return path15.join("external", targetPath.replace(/[^a-zA-Z0-9._-]+/g, "-"));
+  }
+  return relativePath;
+}
+function createBackupPath(rootDir) {
+  return path15.join(rootDir, ".aiblueprint", "backups", "agents-unify-sources", timestamp2());
+}
+async function ensureBackupPath(result) {
+  if (!result.backupPath) {
+    result.backupPath = createBackupPath(result.rootDir);
+    await import_fs_extra11.default.ensureDir(result.backupPath);
+  }
+  return result.backupPath;
+}
+async function createDirectorySymlink(source, target) {
+  await import_fs_extra11.default.ensureDir(path15.dirname(target));
+  if (os13.platform() === "win32") {
+    await import_fs_extra11.default.symlink(source, target, "junction");
+    return;
+  }
+  await import_fs_extra11.default.symlink(source, target, "dir");
+}
+async function shouldLinkMissingContainer(candidate) {
+  if (candidate.linkWhenMissing)
+    return true;
+  if (!candidate.linkWhenParentExists)
+    return false;
+  return import_fs_extra11.default.pathExists(path15.dirname(candidate.path));
+}
+async function linkContainer(candidate, destinationDir, result) {
+  if (candidate.isDestination || samePath(candidate.path, destinationDir)) {
+    return;
+  }
+  const destinationRealPath = await realPathIfPossible(destinationDir);
+  const stat = await import_fs_extra11.default.lstat(candidate.path).catch(() => null);
+  if (!stat) {
+    if (!await shouldLinkMissingContainer(candidate))
+      return;
+    await createDirectorySymlink(destinationDir, candidate.path);
+    result.linked.push({
+      category: candidate.category,
+      from: candidate.path,
+      to: destinationDir
+    });
+    return;
+  }
+  if (stat.isSymbolicLink()) {
+    const existingRealPath = await realPathIfPossible(candidate.path);
+    if (destinationRealPath && existingRealPath && samePath(destinationRealPath, existingRealPath)) {
+      result.alreadyLinked.push({
+        category: candidate.category,
+        from: candidate.path,
+        to: destinationDir
+      });
+      return;
+    }
+    await import_fs_extra11.default.remove(candidate.path);
+    await createDirectorySymlink(destinationDir, candidate.path);
+    result.linked.push({
+      category: candidate.category,
+      from: candidate.path,
+      to: destinationDir
+    });
+    return;
+  }
+  const backupRoot = await ensureBackupPath(result);
+  const backupTarget = path15.join(backupRoot, safeRelativePath(result.rootDir, candidate.path));
+  await import_fs_extra11.default.ensureDir(path15.dirname(backupTarget));
+  await import_fs_extra11.default.move(candidate.path, backupTarget, { overwrite: false });
+  await createDirectorySymlink(destinationDir, candidate.path);
+  result.linked.push({
+    category: candidate.category,
+    from: candidate.path,
+    to: destinationDir,
+    movedToBackup: backupTarget
+  });
+}
+async function unifyAgentsConfiguration(options = {}) {
+  const folders = resolveFolders(options);
+  const candidates = getContainerCandidates(options);
+  const result = {
+    rootDir: folders.rootDir,
+    agentsDir: folders.agentsDir,
+    backupPath: null,
+    imported: [],
+    duplicates: [],
+    renamed: [],
+    linked: [],
+    alreadyLinked: [],
+    skipped: []
+  };
+  const destinationByCategory = {
+    skills: path15.join(folders.agentsDir, "skills"),
+    agents: path15.join(folders.agentsDir, "agents")
+  };
+  await import_fs_extra11.default.ensureDir(folders.agentsDir);
+  for (const category of ["skills", "agents"]) {
+    await importCategoryEntries(category, candidates, destinationByCategory[category], result);
+  }
+  for (const candidate of candidates) {
+    await linkContainer(candidate, destinationByCategory[candidate.category], result);
+  }
+  return result;
+}
+
+// src/commands/agents-unify.ts
+function countByCategory(result, key, category) {
+  return result[key].filter((entry) => entry.category === category).length;
+}
+function printCategorySummary(result, category) {
+  const imported = countByCategory(result, "imported", category);
+  const duplicates = countByCategory(result, "duplicates", category);
+  const renamed = countByCategory(result, "renamed", category);
+  const linked = countByCategory(result, "linked", category);
+  const alreadyLinked = countByCategory(result, "alreadyLinked", category);
+  console.log(source_default.gray(`  ${category}: ${imported} imported, ${duplicates} duplicates skipped, ${renamed} renamed, ${linked} linked, ${alreadyLinked} already linked`));
+}
+async function agentsUnifyCommand(params = {}) {
+  try {
+    console.log(source_default.blue.bold(`
+AIBlueprint agents unify ${source_default.gray(`v${getVersion()}`)}
+`));
+    console.log(source_default.gray("Centralizing reusable skills and agents into .agents"));
+    const result = await unifyAgentsConfiguration(params);
+    console.log(source_default.green(`
+Unify complete`));
+    console.log(source_default.gray(`  Shared folder: ${result.agentsDir}`));
+    printCategorySummary(result, "skills");
+    printCategorySummary(result, "agents");
+    if (result.backupPath) {
+      console.log(source_default.gray(`  Source backups: ${result.backupPath}`));
+    }
+    if (result.skipped.length > 0) {
+      console.log(source_default.yellow(`
+Skipped paths:`));
+      for (const skipped of result.skipped) {
+        console.log(source_default.yellow(`  ${skipped.path}: ${skipped.reason}`));
+      }
+    }
+  } catch (error) {
+    console.error(source_default.red(`
+Agents unify failed:`), error);
+    process.exit(1);
+  }
+}
+
 // node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
 var import_picocolors = __toESM(require_picocolors(), 1);
@@ -35426,12 +35853,12 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 };
 
 // src/commands/pro.ts
-import path17 from "path";
+import path18 from "path";
 
 // src/lib/pro-installer.ts
-var import_fs_extra11 = __toESM(require_lib4(), 1);
-import os13 from "os";
-import path15 from "path";
+var import_fs_extra12 = __toESM(require_lib4(), 1);
+import os14 from "os";
+import path16 from "path";
 import { exec as exec3 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec3);
@@ -35439,9 +35866,9 @@ var PREMIUM_REPO = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH = "main";
 var CONFIG_FOLDER_CANDIDATES2 = ["agents-config", "ai-coding", "claude-code-config", "ai-config"];
 function routePath(relativePath) {
-  const segments = relativePath.split(path15.sep);
+  const segments = relativePath.split(path16.sep);
   const first = segments[0];
-  const rest = segments.slice(1).join(path15.sep);
+  const rest = segments.slice(1).join(path16.sep);
   if (first === "claude-config") {
     return { kind: "claude", relativePath: rest };
   }
@@ -35457,7 +35884,7 @@ function routePath(relativePath) {
   return { kind: "claude", relativePath };
 }
 function getCacheRepoDir() {
-  return path15.join(os13.homedir(), ".config", "aiblueprint", "pro-repos", "aiblueprint-cli-premium");
+  return path16.join(os14.homedir(), ".config", "aiblueprint", "pro-repos", "aiblueprint-cli-premium");
 }
 async function execGitWithAuth(command, token, repoUrl, cwd) {
   const authenticatedUrl = `https://x-access-token:${token}@${repoUrl.replace(/^https?:\/\//, "")}`;
@@ -35471,21 +35898,21 @@ async function execGitWithAuth(command, token, repoUrl, cwd) {
 async function cloneOrUpdateRepo(token) {
   const cacheDir = getCacheRepoDir();
   const repoUrl = `https://github.com/${PREMIUM_REPO}.git`;
-  if (await import_fs_extra11.default.pathExists(path15.join(cacheDir, ".git"))) {
+  if (await import_fs_extra12.default.pathExists(path16.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra11.default.remove(cacheDir);
-      await import_fs_extra11.default.ensureDir(path15.dirname(cacheDir));
+      await import_fs_extra12.default.remove(cacheDir);
+      await import_fs_extra12.default.ensureDir(path16.dirname(cacheDir));
       await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra11.default.ensureDir(path15.dirname(cacheDir));
+    await import_fs_extra12.default.ensureDir(path16.dirname(cacheDir));
     await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
   for (const candidate of CONFIG_FOLDER_CANDIDATES2) {
-    const candidatePath = path15.join(cacheDir, candidate);
-    if (await import_fs_extra11.default.pathExists(candidatePath)) {
+    const candidatePath = path16.join(cacheDir, candidate);
+    if (await import_fs_extra12.default.pathExists(candidatePath)) {
       return candidatePath;
     }
   }
@@ -35493,38 +35920,38 @@ async function cloneOrUpdateRepo(token) {
 }
 async function copyConfigFromCache(cacheConfigDir, dest, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra11.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra12.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name === ".DS_Store" || entry.name === "node_modules")
         continue;
-      const sourcePath = path15.join(dir, entry.name);
-      const relativePath = path15.relative(baseDir, sourcePath);
+      const sourcePath = path16.join(dir, entry.name);
+      const relativePath = path16.relative(baseDir, sourcePath);
       const route = routePath(relativePath);
       if (route.kind === "skip")
         continue;
       if (route.kind === "agents-category") {
-        if (relativePath.split(path15.sep).length === 1) {
+        if (relativePath.split(path16.sep).length === 1) {
           await copyAgentCategory(sourcePath, route.category, dest.agentsDir, dest.claudeDir, onProgress);
         }
         continue;
       }
       const targetBase = route.kind === "claude" ? dest.claudeDir : dest.codexDir;
-      const targetPath = path15.join(targetBase, route.relativePath);
+      const targetPath = path16.join(targetBase, route.relativePath);
       if (entry.isDirectory()) {
-        await import_fs_extra11.default.ensureDir(targetPath);
+        await import_fs_extra12.default.ensureDir(targetPath);
         onProgress?.(relativePath, "directory");
         await walk(sourcePath, baseDir);
       } else if (route.kind === "codex" && route.relativePath === "config.toml") {
         await mergeCodexConfigFile(sourcePath, dest.codexDir);
         onProgress?.(relativePath, "file");
       } else if (isTextFile(entry.name)) {
-        const content = await import_fs_extra11.default.readFile(sourcePath, "utf-8");
+        const content = await import_fs_extra12.default.readFile(sourcePath, "utf-8");
         const replaced = replaceClaudePathPlaceholder(content, dest.claudeDir);
-        await import_fs_extra11.default.ensureDir(path15.dirname(targetPath));
-        await import_fs_extra11.default.writeFile(targetPath, replaced, "utf-8");
+        await import_fs_extra12.default.ensureDir(path16.dirname(targetPath));
+        await import_fs_extra12.default.writeFile(targetPath, replaced, "utf-8");
         onProgress?.(relativePath, "file");
       } else {
-        await import_fs_extra11.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra12.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -35532,21 +35959,21 @@ async function copyConfigFromCache(cacheConfigDir, dest, onProgress) {
   await walk(cacheConfigDir);
 }
 async function copyAgentCategory(sourceCategoryDir, category, agentsDir, claudeDir, onProgress) {
-  const agentsCategoryDir = path15.join(agentsDir, category);
-  await import_fs_extra11.default.ensureDir(agentsCategoryDir);
-  const entries = await import_fs_extra11.default.readdir(sourceCategoryDir, { withFileTypes: true });
+  const agentsCategoryDir = path16.join(agentsDir, category);
+  await import_fs_extra12.default.ensureDir(agentsCategoryDir);
+  const entries = await import_fs_extra12.default.readdir(sourceCategoryDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".DS_Store")
       continue;
-    const src = path15.join(sourceCategoryDir, entry.name);
-    const dst = path15.join(agentsCategoryDir, entry.name);
-    const claudeTop = path15.join(claudeDir, category, entry.name);
-    const claudeStat = await import_fs_extra11.default.lstat(claudeTop).catch(() => null);
+    const src = path16.join(sourceCategoryDir, entry.name);
+    const dst = path16.join(agentsCategoryDir, entry.name);
+    const claudeTop = path16.join(claudeDir, category, entry.name);
+    const claudeStat = await import_fs_extra12.default.lstat(claudeTop).catch(() => null);
     if (claudeStat && !claudeStat.isSymbolicLink()) {
       onProgress?.(`${category}/${entry.name} (skipped - real dir in claude)`, "file");
       continue;
     }
-    await import_fs_extra11.default.copy(src, dst, { overwrite: true });
+    await import_fs_extra12.default.copy(src, dst, { overwrite: true });
     await applyPathPlaceholders(dst, claudeDir);
     onProgress?.(`${category}/${entry.name}`, entry.isDirectory() ? "directory" : "file");
   }
@@ -35565,8 +35992,8 @@ async function downloadFromPrivateGitHub(repo, branch, relativePath, targetPath,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra11.default.ensureDir(path15.dirname(targetPath));
-    await import_fs_extra11.default.writeFile(targetPath, Buffer.from(content));
+    await import_fs_extra12.default.ensureDir(path16.dirname(targetPath));
+    await import_fs_extra12.default.writeFile(targetPath, Buffer.from(content));
     return true;
   } catch (error) {
     console.error(`Error downloading ${relativePath}:`, error);
@@ -35591,10 +36018,10 @@ async function downloadDirectoryFromPrivateGitHub(repo, branch, dirPath, targetD
       console.error(`Unexpected response for directory ${dirPath}`);
       return false;
     }
-    await import_fs_extra11.default.ensureDir(targetDir);
+    await import_fs_extra12.default.ensureDir(targetDir);
     for (const file of files) {
       const relativePath = dirPath ? `${dirPath}/${file.name}` : file.name;
-      const targetPath = path15.join(targetDir, file.name);
+      const targetPath = path16.join(targetDir, file.name);
       const displayPath = relativePath.replace(/^(agents-config|ai-coding|claude-code-config|ai-config)\//, "");
       if (file.type === "file") {
         onProgress?.(displayPath, "file");
@@ -35617,8 +36044,8 @@ async function installProConfigs(options) {
     codexFolder,
     agentsFolder
   });
-  await import_fs_extra11.default.ensureDir(claudeDir);
-  await import_fs_extra11.default.ensureDir(agentsDir);
+  await import_fs_extra12.default.ensureDir(claudeDir);
+  await import_fs_extra12.default.ensureDir(agentsDir);
   const dest = { claudeDir, codexDir, agentsDir };
   try {
     const cacheConfigDir = await cloneOrUpdateRepo(githubToken);
@@ -35628,7 +36055,7 @@ async function installProConfigs(options) {
   } catch (error) {
     console.warn("Git caching failed, falling back to API download");
   }
-  const tempDir = path15.join(os13.tmpdir(), `aiblueprint-premium-${Date.now()}`);
+  const tempDir = path16.join(os14.tmpdir(), `aiblueprint-premium-${Date.now()}`);
   try {
     let success = false;
     for (const candidate of CONFIG_FOLDER_CANDIDATES2) {
@@ -35642,8 +36069,8 @@ async function installProConfigs(options) {
     await copyConfigFromCache(tempDir, dest, onProgress);
     await replacePathPlaceholdersInDir(claudeDir, claudeDir);
     for (const category of AGENT_CATEGORIES) {
-      const agentsCategoryDir = path15.join(agentsDir, category);
-      if (await import_fs_extra11.default.pathExists(agentsCategoryDir)) {
+      const agentsCategoryDir = path16.join(agentsDir, category);
+      if (await import_fs_extra12.default.pathExists(agentsCategoryDir)) {
         await replacePathPlaceholdersInDir(agentsCategoryDir, claudeDir);
       }
     }
@@ -35652,7 +36079,7 @@ async function installProConfigs(options) {
     throw new Error(`Failed to install premium configs: ${error instanceof Error ? error.message : "Unknown error"}`);
   } finally {
     try {
-      await import_fs_extra11.default.remove(tempDir);
+      await import_fs_extra12.default.remove(tempDir);
     } catch {}
   }
 }
@@ -35663,27 +36090,27 @@ async function syncAllAgentSymlinks(agentsDir, claudeDir) {
 }
 
 // src/lib/token-storage.ts
-var import_fs_extra12 = __toESM(require_lib4(), 1);
-import os14 from "os";
-import path16 from "path";
+var import_fs_extra13 = __toESM(require_lib4(), 1);
+import os15 from "os";
+import path17 from "path";
 function getConfigDir() {
-  const platform = os14.platform();
+  const platform = os15.platform();
   if (platform === "win32") {
-    const appData = process.env.APPDATA || path16.join(os14.homedir(), "AppData", "Roaming");
-    return path16.join(appData, "aiblueprint");
+    const appData = process.env.APPDATA || path17.join(os15.homedir(), "AppData", "Roaming");
+    return path17.join(appData, "aiblueprint");
   } else {
-    const configHome = process.env.XDG_CONFIG_HOME || path16.join(os14.homedir(), ".config");
-    return path16.join(configHome, "aiblueprint");
+    const configHome = process.env.XDG_CONFIG_HOME || path17.join(os15.homedir(), ".config");
+    return path17.join(configHome, "aiblueprint");
   }
 }
 function getTokenFilePath2() {
-  return path16.join(getConfigDir(), "token.txt");
+  return path17.join(getConfigDir(), "token.txt");
 }
 async function saveToken(githubToken) {
   const tokenFile = getTokenFilePath2();
-  const configDir = path16.dirname(tokenFile);
+  const configDir = path17.dirname(tokenFile);
   try {
-    await import_fs_extra12.default.ensureDir(configDir);
+    await import_fs_extra13.default.ensureDir(configDir);
   } catch (error) {
     if (error.code === "EACCES") {
       throw new Error(`Permission denied creating config directory: ${configDir}
@@ -35691,15 +36118,15 @@ async function saveToken(githubToken) {
     }
     throw error;
   }
-  await import_fs_extra12.default.writeFile(tokenFile, githubToken, { mode: 384 });
+  await import_fs_extra13.default.writeFile(tokenFile, githubToken, { mode: 384 });
 }
 async function getToken() {
   const tokenFile = getTokenFilePath2();
-  if (!await import_fs_extra12.default.pathExists(tokenFile)) {
+  if (!await import_fs_extra13.default.pathExists(tokenFile)) {
     return null;
   }
   try {
-    const token = await import_fs_extra12.default.readFile(tokenFile, "utf-8");
+    const token = await import_fs_extra13.default.readFile(tokenFile, "utf-8");
     return token.trim();
   } catch (error) {
     return null;
@@ -35708,12 +36135,12 @@ async function getToken() {
 function getTokenInfo() {
   return {
     path: getTokenFilePath2(),
-    platform: os14.platform()
+    platform: os15.platform()
   };
 }
 
 // src/commands/pro.ts
-var import_fs_extra13 = __toESM(require_lib4(), 1);
+var import_fs_extra14 = __toESM(require_lib4(), 1);
 var API_URL = "https://codeline.app/api/products";
 var PRODUCT_IDS = ["prd_XJVgxVPbGG", "prd_NKabAkdOkw"];
 async function countInstalledItems(claudeDir) {
@@ -35722,20 +36149,20 @@ async function countInstalledItems(claudeDir) {
     skills: 0
   };
   try {
-    const agentsDir = path17.join(claudeDir, "agents");
-    if (await import_fs_extra13.default.pathExists(agentsDir)) {
-      const files = await import_fs_extra13.default.readdir(agentsDir);
+    const agentsDir = path18.join(claudeDir, "agents");
+    if (await import_fs_extra14.default.pathExists(agentsDir)) {
+      const files = await import_fs_extra14.default.readdir(agentsDir);
       counts.agents = files.filter((f) => f.endsWith(".md")).length;
     }
   } catch (error) {
     console.error("Failed to count agents:", error instanceof Error ? error.message : error);
   }
   try {
-    const skillsDir = path17.join(claudeDir, "skills");
-    if (await import_fs_extra13.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra13.default.readdir(skillsDir);
+    const skillsDir = path18.join(claudeDir, "skills");
+    if (await import_fs_extra14.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra14.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra13.default.stat(path17.join(skillsDir, item));
+        const stat = await import_fs_extra14.default.stat(path18.join(skillsDir, item));
         return stat.isDirectory();
       }));
       counts.skills = dirs.filter(Boolean).length;
@@ -35943,9 +36370,9 @@ async function proUpdateCommand(options = {}) {
 }
 
 // src/lib/sync-utils.ts
-var import_fs_extra14 = __toESM(require_lib4(), 1);
-import path18 from "path";
-import crypto from "crypto";
+var import_fs_extra15 = __toESM(require_lib4(), 1);
+import path19 from "path";
+import crypto2 from "crypto";
 var PREMIUM_REPO2 = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH2 = "main";
 var CONFIG_FOLDER_CANDIDATES3 = ["agents-config", "ai-coding", "claude-code-config", "ai-config"];
@@ -35953,7 +36380,7 @@ function computeFileSha(content) {
   const size = content.length;
   const header = `blob ${size}\x00`;
   const fullContent = Buffer.concat([Buffer.from(header), content]);
-  return crypto.createHash("sha1").update(fullContent).digest("hex");
+  return crypto2.createHash("sha1").update(fullContent).digest("hex");
 }
 var resolvedConfigFolder = null;
 async function resolveRemoteConfigFolder(githubToken) {
@@ -36015,7 +36442,7 @@ async function listRemoteFilesRecursive(dirPath, githubToken, basePath = "") {
 }
 async function computeLocalFileSha(filePath) {
   try {
-    const content = await import_fs_extra14.default.readFile(filePath);
+    const content = await import_fs_extra15.default.readFile(filePath);
     return computeFileSha(content);
   } catch {
     return null;
@@ -36023,15 +36450,15 @@ async function computeLocalFileSha(filePath) {
 }
 async function listLocalFiles(dir) {
   const files = [];
-  if (!await import_fs_extra14.default.pathExists(dir)) {
+  if (!await import_fs_extra15.default.pathExists(dir)) {
     return files;
   }
-  const items = await import_fs_extra14.default.readdir(dir);
+  const items = await import_fs_extra15.default.readdir(dir);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path18.join(dir, item);
-    const stat = await import_fs_extra14.default.stat(fullPath).catch(() => null);
+    const fullPath = path19.join(dir, item);
+    const stat = await import_fs_extra15.default.stat(fullPath).catch(() => null);
     if (!stat)
       continue;
     if (stat.isDirectory()) {
@@ -36046,13 +36473,13 @@ async function listLocalFiles(dir) {
 }
 async function listLocalFilesRecursive(dir, basePath) {
   const files = [];
-  const items = await import_fs_extra14.default.readdir(dir).catch(() => []);
+  const items = await import_fs_extra15.default.readdir(dir).catch(() => []);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path18.join(dir, item);
+    const fullPath = path19.join(dir, item);
     const relativePath = `${basePath}/${item}`;
-    const stat = await import_fs_extra14.default.stat(fullPath).catch(() => null);
+    const stat = await import_fs_extra15.default.stat(fullPath).catch(() => null);
     if (!stat)
       continue;
     if (stat.isDirectory()) {
@@ -36066,14 +36493,14 @@ async function listLocalFilesRecursive(dir, basePath) {
   return files;
 }
 async function listClaudeRealTopLevel(claudeCategoryDir) {
-  if (!await import_fs_extra14.default.pathExists(claudeCategoryDir))
+  if (!await import_fs_extra15.default.pathExists(claudeCategoryDir))
     return [];
-  const entries = await import_fs_extra14.default.readdir(claudeCategoryDir).catch(() => []);
+  const entries = await import_fs_extra15.default.readdir(claudeCategoryDir).catch(() => []);
   const real = [];
   for (const name of entries) {
     if (name === "node_modules" || name === ".DS_Store")
       continue;
-    const stat = await import_fs_extra14.default.lstat(path18.join(claudeCategoryDir, name)).catch(() => null);
+    const stat = await import_fs_extra15.default.lstat(path19.join(claudeCategoryDir, name)).catch(() => null);
     if (!stat)
       continue;
     if (stat.isDirectory())
@@ -36090,7 +36517,7 @@ async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
   const items = [];
   const useAgents = isAgentCategory(category);
   const localBase = useAgents ? agentsDir : claudeDir;
-  const localDir = path18.join(localBase, category);
+  const localDir = path19.join(localBase, category);
   const remoteCategoryPath = getRemoteCategoryPath(category);
   const remoteFiles = await listRemoteFilesRecursive(remoteCategoryPath, githubToken);
   const localFiles = await listLocalFiles(localDir);
@@ -36104,7 +36531,7 @@ async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
   }
   const localSet = new Set(localFiles);
   for (const [remotePath, { sha, isFolder }] of remoteSet) {
-    const localPath = path18.join(localDir, remotePath);
+    const localPath = path19.join(localDir, remotePath);
     if (isFolder) {
       continue;
     }
@@ -36139,7 +36566,7 @@ async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
     for (const localPath of localSet) {
       agentsTopLevels.add(localPath.split("/")[0]);
     }
-    const claudeCategoryDir = path18.join(claudeDir, category);
+    const claudeCategoryDir = path19.join(claudeDir, category);
     const claudeRealEntries = await listClaudeRealTopLevel(claudeCategoryDir);
     for (const top of claudeRealEntries) {
       if (!remoteTopLevels.has(top))
@@ -36198,13 +36625,13 @@ async function downloadFromPrivateGitHub2(relativePath, targetPath, githubToken,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra14.default.ensureDir(path18.dirname(targetPath));
+    await import_fs_extra15.default.ensureDir(path19.dirname(targetPath));
     if (isTextFile(relativePath)) {
       const textContent = Buffer.from(content).toString("utf-8");
       const transformedContent = transformFileContent(textContent, claudeDir);
-      await import_fs_extra14.default.writeFile(targetPath, transformedContent, "utf-8");
+      await import_fs_extra15.default.writeFile(targetPath, transformedContent, "utf-8");
     } else {
-      await import_fs_extra14.default.writeFile(targetPath, Buffer.from(content));
+      await import_fs_extra15.default.writeFile(targetPath, Buffer.from(content));
     }
     return true;
   } catch {
@@ -36220,27 +36647,27 @@ async function syncSelectedItems(claudeDir, items, githubToken, agentsDir, onPro
   for (const item of items) {
     const useAgents = isAgentCategory(item.category);
     const baseDir = useAgents ? agentsDir : claudeDir;
-    const targetPath = path18.join(baseDir, item.relativePath);
+    const targetPath = path19.join(baseDir, item.relativePath);
     if (item.status === "migration" && useAgents) {
       const topName = item.name.split("/")[0];
-      const agentsTop = path18.join(agentsDir, item.category, topName);
-      const claudeTop = path18.join(claudeDir, item.category, topName);
+      const agentsTop = path19.join(agentsDir, item.category, topName);
+      const claudeTop = path19.join(claudeDir, item.category, topName);
       try {
-        const claudeStat = await import_fs_extra14.default.lstat(claudeTop).catch(() => null);
+        const claudeStat = await import_fs_extra15.default.lstat(claudeTop).catch(() => null);
         if (!claudeStat || claudeStat.isSymbolicLink()) {
           onProgress?.(item.relativePath, "skipping (no real dir to migrate)");
           failed++;
           continue;
         }
-        const agentsExists = await import_fs_extra14.default.pathExists(agentsTop);
+        const agentsExists = await import_fs_extra15.default.pathExists(agentsTop);
         if (agentsExists) {
           onProgress?.(item.relativePath, "skipping (already in .agents)");
           failed++;
           continue;
         }
         onProgress?.(item.relativePath, "moving to .agents");
-        await import_fs_extra14.default.ensureDir(path18.dirname(agentsTop));
-        await import_fs_extra14.default.move(claudeTop, agentsTop);
+        await import_fs_extra15.default.ensureDir(path19.dirname(agentsTop));
+        await import_fs_extra15.default.move(claudeTop, agentsTop);
         migrated++;
         touchedAgentCategories.add(item.category);
       } catch {
@@ -36250,8 +36677,8 @@ async function syncSelectedItems(claudeDir, items, githubToken, agentsDir, onPro
     }
     if (useAgents) {
       const topName = item.name.split("/")[0];
-      const claudeTop = path18.join(claudeDir, item.category, topName);
-      const claudeTopStat = await import_fs_extra14.default.lstat(claudeTop).catch(() => null);
+      const claudeTop = path19.join(claudeDir, item.category, topName);
+      const claudeTopStat = await import_fs_extra15.default.lstat(claudeTop).catch(() => null);
       if (claudeTopStat && !claudeTopStat.isSymbolicLink()) {
         onProgress?.(item.relativePath, "skipping (real dir in .claude)");
         failed++;
@@ -36261,7 +36688,7 @@ async function syncSelectedItems(claudeDir, items, githubToken, agentsDir, onPro
     if (item.status === "deleted") {
       onProgress?.(item.relativePath, "deleting");
       try {
-        await import_fs_extra14.default.remove(targetPath);
+        await import_fs_extra15.default.remove(targetPath);
         deleted++;
         if (useAgents)
           touchedAgentCategories.add(item.category);
@@ -36599,20 +37026,20 @@ async function proSyncCommand(options = {}) {
 }
 
 // src/lib/backup-utils.ts
-var import_fs_extra15 = __toESM(require_lib4(), 1);
-import path19 from "path";
-import os15 from "os";
-var BACKUP_BASE_DIR = path19.join(os15.homedir(), ".config", "aiblueprint", "backup");
+var import_fs_extra16 = __toESM(require_lib4(), 1);
+import path20 from "path";
+import os16 from "os";
+var BACKUP_BASE_DIR = path20.join(os16.homedir(), ".config", "aiblueprint", "backup");
 function formatDate(date) {
   const pad = (n) => n.toString().padStart(2, "0");
   return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}-${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
 }
 async function listBackups() {
-  const exists = await import_fs_extra15.default.pathExists(BACKUP_BASE_DIR);
+  const exists = await import_fs_extra16.default.pathExists(BACKUP_BASE_DIR);
   if (!exists) {
     return [];
   }
-  const entries = await import_fs_extra15.default.readdir(BACKUP_BASE_DIR, { withFileTypes: true });
+  const entries = await import_fs_extra16.default.readdir(BACKUP_BASE_DIR, { withFileTypes: true });
   const backups = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
@@ -36624,7 +37051,7 @@ async function listBackups() {
     const date = new Date(parseInt(year), parseInt(month) - 1, parseInt(day), parseInt(hour), parseInt(minute), parseInt(second));
     backups.push({
       name: entry.name,
-      path: path19.join(BACKUP_BASE_DIR, entry.name),
+      path: path20.join(BACKUP_BASE_DIR, entry.name),
       date
     });
   }
@@ -36633,12 +37060,12 @@ async function listBackups() {
 var AGENTS_BACKUP_SUBDIR = ".agents";
 var CLAUDE_ITEMS = ["commands", "agents", "skills", "scripts", "settings.json"];
 async function copyForBackup(sourcePath, destPath) {
-  await import_fs_extra15.default.copy(sourcePath, destPath, {
+  await import_fs_extra16.default.copy(sourcePath, destPath, {
     overwrite: true,
     dereference: false,
     filter: async (src) => {
       try {
-        const stat = await import_fs_extra15.default.lstat(src);
+        const stat = await import_fs_extra16.default.lstat(src);
         return !stat.isSymbolicLink();
       } catch {
         return true;
@@ -36647,28 +37074,28 @@ async function copyForBackup(sourcePath, destPath) {
   });
 }
 async function hasMeaningfulContent(dir) {
-  if (!await import_fs_extra15.default.pathExists(dir))
+  if (!await import_fs_extra16.default.pathExists(dir))
     return false;
-  const files = await import_fs_extra15.default.readdir(dir);
+  const files = await import_fs_extra16.default.readdir(dir);
   return files.some((f) => f !== ".DS_Store");
 }
 async function loadBackup(backupPath, claudeDir, agentsDir) {
-  const exists = await import_fs_extra15.default.pathExists(backupPath);
+  const exists = await import_fs_extra16.default.pathExists(backupPath);
   if (!exists) {
     throw new Error(`Backup not found: ${backupPath}`);
   }
-  await import_fs_extra15.default.ensureDir(claudeDir);
+  await import_fs_extra16.default.ensureDir(claudeDir);
   for (const item of CLAUDE_ITEMS) {
-    const sourcePath = path19.join(backupPath, item);
-    const destPath = path19.join(claudeDir, item);
-    if (await import_fs_extra15.default.pathExists(sourcePath)) {
+    const sourcePath = path20.join(backupPath, item);
+    const destPath = path20.join(claudeDir, item);
+    if (await import_fs_extra16.default.pathExists(sourcePath)) {
       await copyForBackup(sourcePath, destPath);
     }
   }
   if (agentsDir) {
-    const agentsBackupPath = path19.join(backupPath, AGENTS_BACKUP_SUBDIR);
-    if (await import_fs_extra15.default.pathExists(agentsBackupPath)) {
-      await import_fs_extra15.default.ensureDir(agentsDir);
+    const agentsBackupPath = path20.join(backupPath, AGENTS_BACKUP_SUBDIR);
+    if (await import_fs_extra16.default.pathExists(agentsBackupPath)) {
+      await import_fs_extra16.default.ensureDir(agentsDir);
       await copyForBackup(agentsBackupPath, agentsDir);
     }
   }
@@ -36679,20 +37106,20 @@ async function createBackup(claudeDir, agentsDir) {
   if (!claudeHasContent && !agentsHasContent) {
     return null;
   }
-  const timestamp2 = formatDate(new Date);
-  const backupPath = path19.join(BACKUP_BASE_DIR, timestamp2);
-  await import_fs_extra15.default.ensureDir(backupPath);
+  const timestamp3 = formatDate(new Date);
+  const backupPath = path20.join(BACKUP_BASE_DIR, timestamp3);
+  await import_fs_extra16.default.ensureDir(backupPath);
   if (claudeHasContent) {
     for (const item of CLAUDE_ITEMS) {
-      const sourcePath = path19.join(claudeDir, item);
-      const destPath = path19.join(backupPath, item);
-      if (await import_fs_extra15.default.pathExists(sourcePath)) {
+      const sourcePath = path20.join(claudeDir, item);
+      const destPath = path20.join(backupPath, item);
+      if (await import_fs_extra16.default.pathExists(sourcePath)) {
         await copyForBackup(sourcePath, destPath);
       }
     }
   }
   if (agentsHasContent && agentsDir) {
-    const destPath = path19.join(backupPath, AGENTS_BACKUP_SUBDIR);
+    const destPath = path20.join(backupPath, AGENTS_BACKUP_SUBDIR);
     await copyForBackup(agentsDir, destPath);
   }
   return backupPath;
@@ -36875,19 +37302,19 @@ async function configsBackupsCreateCommand(reason, options = {}) {
 }
 
 // src/commands/openclaw-pro.ts
-import os18 from "os";
-import path22 from "path";
+import os19 from "os";
+import path23 from "path";
 
 // src/lib/openclaw-installer.ts
-var import_fs_extra16 = __toESM(require_lib4(), 1);
-import os16 from "os";
-import path20 from "path";
+var import_fs_extra17 = __toESM(require_lib4(), 1);
+import os17 from "os";
+import path21 from "path";
 import { exec as exec4 } from "child_process";
 import { promisify as promisify3 } from "util";
 var execAsync3 = promisify3(exec4);
 var OPENCLAW_PRO_REPO = "Melvynx/openclawpro";
 function getCacheRepoDir2() {
-  return path20.join(os16.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
+  return path21.join(os17.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
 }
 async function execGitWithAuth2(command, token, repoUrl, cwd) {
   const authenticatedUrl = `https://x-access-token:${token}@${repoUrl.replace(/^https?:\/\//, "")}`;
@@ -36901,33 +37328,33 @@ async function execGitWithAuth2(command, token, repoUrl, cwd) {
 async function cloneOrUpdateRepo2(token) {
   const cacheDir = getCacheRepoDir2();
   const repoUrl = `https://github.com/${OPENCLAW_PRO_REPO}.git`;
-  if (await import_fs_extra16.default.pathExists(path20.join(cacheDir, ".git"))) {
+  if (await import_fs_extra17.default.pathExists(path21.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth2("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra16.default.remove(cacheDir);
-      await import_fs_extra16.default.ensureDir(path20.dirname(cacheDir));
+      await import_fs_extra17.default.remove(cacheDir);
+      await import_fs_extra17.default.ensureDir(path21.dirname(cacheDir));
       await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra16.default.ensureDir(path20.dirname(cacheDir));
+    await import_fs_extra17.default.ensureDir(path21.dirname(cacheDir));
     await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
-  return path20.join(cacheDir, "openclaw-config");
+  return path21.join(cacheDir, "openclaw-config");
 }
 async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra16.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra17.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = path20.join(dir, entry.name);
-      const relativePath = path20.relative(baseDir, sourcePath);
-      const targetPath = path20.join(targetDir, relativePath);
+      const sourcePath = path21.join(dir, entry.name);
+      const relativePath = path21.relative(baseDir, sourcePath);
+      const targetPath = path21.join(targetDir, relativePath);
       if (entry.isDirectory()) {
-        await import_fs_extra16.default.ensureDir(targetPath);
+        await import_fs_extra17.default.ensureDir(targetPath);
         onProgress?.(relativePath, "directory");
         await walk(sourcePath, baseDir);
       } else {
-        await import_fs_extra16.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra17.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -36936,7 +37363,7 @@ async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
 }
 async function installOpenclawProConfigs(options) {
   const { githubToken, openclawFolder, onProgress } = options;
-  const targetFolder = openclawFolder || path20.join(os16.homedir(), ".openclaw");
+  const targetFolder = openclawFolder || path21.join(os17.homedir(), ".openclaw");
   try {
     const cacheConfigDir = await cloneOrUpdateRepo2(githubToken);
     await copyConfigFromCache2(cacheConfigDir, targetFolder, onProgress);
@@ -36947,28 +37374,28 @@ async function installOpenclawProConfigs(options) {
 }
 
 // src/lib/openclaw-token-storage.ts
-var import_fs_extra17 = __toESM(require_lib4(), 1);
-import os17 from "os";
-import path21 from "path";
+var import_fs_extra18 = __toESM(require_lib4(), 1);
+import os18 from "os";
+import path22 from "path";
 function getConfigDir2() {
-  const platform = os17.platform();
+  const platform = os18.platform();
   if (platform === "win32") {
-    return path21.join(process.env.APPDATA || os17.homedir(), "openclaw");
+    return path22.join(process.env.APPDATA || os18.homedir(), "openclaw");
   }
-  return path21.join(os17.homedir(), ".config", "openclaw");
+  return path22.join(os18.homedir(), ".config", "openclaw");
 }
 function getTokenPath() {
-  return path21.join(getConfigDir2(), "token.txt");
+  return path22.join(getConfigDir2(), "token.txt");
 }
 async function saveOpenclawToken(githubToken) {
   const configDir = getConfigDir2();
-  await import_fs_extra17.default.ensureDir(configDir);
-  await import_fs_extra17.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
+  await import_fs_extra18.default.ensureDir(configDir);
+  await import_fs_extra18.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
 }
 async function getOpenclawToken() {
   const tokenPath = getTokenPath();
-  if (await import_fs_extra17.default.pathExists(tokenPath)) {
-    const token = await import_fs_extra17.default.readFile(tokenPath, "utf8");
+  if (await import_fs_extra18.default.pathExists(tokenPath)) {
+    const token = await import_fs_extra18.default.readFile(tokenPath, "utf8");
     return token.trim();
   }
   return null;
@@ -36976,12 +37403,12 @@ async function getOpenclawToken() {
 function getOpenclawTokenInfo() {
   return {
     path: getTokenPath(),
-    platform: os17.platform()
+    platform: os18.platform()
   };
 }
 
 // src/commands/openclaw-pro.ts
-var import_fs_extra18 = __toESM(require_lib4(), 1);
+var import_fs_extra19 = __toESM(require_lib4(), 1);
 var API_URL2 = "https://codeline.app/api/products";
 var OPENCLAW_PRODUCT_ID = "prd_t2GRwX3aH1";
 var CLAUDE_CODE_TOOLS_INSTRUCTIONS = `
@@ -37088,7 +37515,7 @@ async function openclawProSetupCommand(options = {}) {
       Se(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const openclawDir = options.folder ? path22.resolve(options.folder) : path22.join(os18.homedir(), ".openclaw");
+    const openclawDir = options.folder ? path23.resolve(options.folder) : path23.join(os19.homedir(), ".openclaw");
     const spinner = Y2();
     const onProgress = (file, type) => {
       spinner.message(`Installing: ${source_default.cyan(file)} ${source_default.gray(`(${type})`)}`);
@@ -37101,23 +37528,23 @@ async function openclawProSetupCommand(options = {}) {
     });
     spinner.stop("OpenClaw Pro configurations installed");
     let skillCount = 0;
-    const skillsDir = path22.join(openclawDir, "skills");
-    if (await import_fs_extra18.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra18.default.readdir(skillsDir);
+    const skillsDir = path23.join(openclawDir, "skills");
+    if (await import_fs_extra19.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra19.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra18.default.stat(path22.join(skillsDir, item));
+        const stat = await import_fs_extra19.default.stat(path23.join(skillsDir, item));
         return stat.isDirectory();
       }));
       skillCount = dirs.filter(Boolean).length;
     }
     spinner.start("Setting up workspace TOOLS.md...");
-    const workspaceDir = path22.join(openclawDir, "workspace");
-    const toolsPath = path22.join(workspaceDir, "TOOLS.md");
-    await import_fs_extra18.default.ensureDir(workspaceDir);
-    if (await import_fs_extra18.default.pathExists(toolsPath)) {
-      const existingContent = await import_fs_extra18.default.readFile(toolsPath, "utf-8");
+    const workspaceDir = path23.join(openclawDir, "workspace");
+    const toolsPath = path23.join(workspaceDir, "TOOLS.md");
+    await import_fs_extra19.default.ensureDir(workspaceDir);
+    if (await import_fs_extra19.default.pathExists(toolsPath)) {
+      const existingContent = await import_fs_extra19.default.readFile(toolsPath, "utf-8");
       if (!existingContent.includes("Claude Code CLI")) {
-        await import_fs_extra18.default.appendFile(toolsPath, `
+        await import_fs_extra19.default.appendFile(toolsPath, `
 
 ` + CLAUDE_CODE_TOOLS_INSTRUCTIONS);
         spinner.stop("TOOLS.md updated with Claude Code instructions");
@@ -37131,7 +37558,7 @@ Skills define _how_ tools work. This file is for _your_ specifics — the stuff
 
 ${CLAUDE_CODE_TOOLS_INSTRUCTIONS}
 `;
-      await import_fs_extra18.default.writeFile(toolsPath, defaultToolsMd);
+      await import_fs_extra19.default.writeFile(toolsPath, defaultToolsMd);
       spinner.stop("TOOLS.md created with Claude Code instructions");
     }
     spinner.start("Creating claude-run wrapper...");
@@ -37142,9 +37569,9 @@ ${CLAUDE_CODE_TOOLS_INSTRUCTIONS}
 script -q -c "claude $*" /dev/null
 `;
     const binDir = "/usr/local/bin";
-    const wrapperPath = path22.join(binDir, "claude-run");
+    const wrapperPath = path23.join(binDir, "claude-run");
     try {
-      await import_fs_extra18.default.writeFile(wrapperPath, claudeRunWrapper, { mode: 493 });
+      await import_fs_extra19.default.writeFile(wrapperPath, claudeRunWrapper, { mode: 493 });
       spinner.stop("claude-run wrapper created");
     } catch {
       spinner.stop("claude-run wrapper skipped (no write access to /usr/local/bin)");
@@ -37193,12 +37620,12 @@ async function openclawProUpdateCommand(options = {}) {
 }
 
 // src/commands/dynamic-scripts.ts
-import path25 from "path";
+import path26 from "path";
 import { homedir } from "os";
 
 // src/lib/script-parser.ts
-var import_fs_extra19 = __toESM(require_lib4(), 1);
-import path23 from "path";
+var import_fs_extra20 = __toESM(require_lib4(), 1);
+import path24 from "path";
 var EXCLUDED_SCRIPTS = ["test", "lint", "format", "start"];
 var EXCLUDED_SUFFIXES = [":test", ":lint", ":test-fixtures", ":start"];
 function shouldIncludeScript(scriptName) {
@@ -37209,12 +37636,12 @@ function shouldIncludeScript(scriptName) {
   return true;
 }
 async function readScriptsPackageJson(claudeDir) {
-  const packageJsonPath = path23.join(claudeDir, "scripts", "package.json");
+  const packageJsonPath = path24.join(claudeDir, "scripts", "package.json");
   try {
-    if (!await import_fs_extra19.default.pathExists(packageJsonPath)) {
+    if (!await import_fs_extra20.default.pathExists(packageJsonPath)) {
       return null;
     }
-    const content = await import_fs_extra19.default.readFile(packageJsonPath, "utf-8");
+    const content = await import_fs_extra20.default.readFile(packageJsonPath, "utf-8");
     const parsed = JSON.parse(content);
     return parsed.scripts || null;
   } catch (error) {
@@ -37258,14 +37685,14 @@ function groupScriptsByPrefix(commands) {
 }
 
 // src/commands/script-runner.ts
-var import_fs_extra20 = __toESM(require_lib4(), 1);
+var import_fs_extra21 = __toESM(require_lib4(), 1);
 import { spawn as spawn2 } from "child_process";
 import { execSync as execSync4 } from "child_process";
-import path24 from "path";
-import os19 from "os";
+import path25 from "path";
+import os20 from "os";
 function checkCommand2(cmd) {
   try {
-    const isWindows2 = os19.platform() === "win32";
+    const isWindows2 = os20.platform() === "win32";
     const whichCmd = isWindows2 ? `where ${cmd}` : `which ${cmd}`;
     execSync4(whichCmd, { stdio: "ignore" });
     return true;
@@ -37291,18 +37718,18 @@ async function executeScript(scriptName, claudeDir) {
     console.error(source_default.red("Bun is not installed. Install with: npm install -g bun"));
     return 1;
   }
-  const scriptsDir = path24.join(claudeDir, "scripts");
-  if (!await import_fs_extra20.default.pathExists(scriptsDir)) {
+  const scriptsDir = path25.join(claudeDir, "scripts");
+  if (!await import_fs_extra21.default.pathExists(scriptsDir)) {
     console.error(source_default.red(`Scripts directory not found at ${scriptsDir}`));
     console.log(source_default.gray("Run: aiblueprint agents setup"));
     return 1;
   }
-  const packageJsonPath = path24.join(scriptsDir, "package.json");
-  if (!await import_fs_extra20.default.pathExists(packageJsonPath)) {
+  const packageJsonPath = path25.join(scriptsDir, "package.json");
+  if (!await import_fs_extra21.default.pathExists(packageJsonPath)) {
     console.error(source_default.red(`package.json not found in ${scriptsDir}`));
     return 1;
   }
-  const packageJson = await import_fs_extra20.default.readJson(packageJsonPath);
+  const packageJson = await import_fs_extra21.default.readJson(packageJsonPath);
   if (!packageJson.scripts || !packageJson.scripts[scriptName]) {
     console.error(source_default.red(`Script "${scriptName}" not found in package.json`));
     return 1;
@@ -37325,7 +37752,7 @@ async function executeScript(scriptName, claudeDir) {
 
 // src/commands/dynamic-scripts.ts
 function getClaudeDir(parentOptions) {
-  return parentOptions.claudeCodeFolder || parentOptions.folder ? path25.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path25.join(homedir(), ".claude");
+  return parentOptions.claudeCodeFolder || parentOptions.folder ? path26.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path26.join(homedir(), ".claude");
 }
 async function registerDynamicScriptCommands(claudeCodeCmd, claudeDir) {
   const scripts = await readScriptsPackageJson(claudeDir);
@@ -37387,6 +37814,15 @@ function registerAgentsCommands(cmd) {
       codexFolder: parentOptions.codexFolder
     });
   });
+  cmd.command("unify").description("Unify skills and agents into .agents and symlink tool folders back to it").action((options, command) => {
+    const parentOptions = command.parent.opts();
+    return agentsUnifyCommand({
+      folder: parentOptions.folder,
+      claudeCodeFolder: parentOptions.claudeCodeFolder,
+      codexFolder: parentOptions.codexFolder,
+      agentsFolder: parentOptions.agentsFolder
+    });
+  });
   const proCmd = cmd.command("pro").description("Manage AIBlueprint CLI Premium features");
   proCmd.command("activate [token]").description("Activate AIBlueprint CLI Premium with your access token").action((token) => {
     proActivateCommand(token);