aiblueprint-cli 1.4.45 → 1.4.48

package/dist/cli.js

@@ -32263,9 +32263,9 @@ var inquirer = {
 var lib_default = inquirer;
 
 // src/commands/setup.ts
-var import_fs_extra7 = __toESM(require_lib4(), 1);
-import path9 from "path";
-import os10 from "os";
+var import_fs_extra8 = __toESM(require_lib4(), 1);
+import path11 from "path";
+import os11 from "os";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -33039,13 +33039,232 @@ async function installStatuslineDependencies(claudeDir) {
 }
 
 // src/commands/setup/settings.ts
+var import_fs_extra3 = __toESM(require_lib4(), 1);
+import path5 from "path";
+function toPosixPath(p) {
+  return p.replace(/\\/g, "/");
+}
+async function hasExistingStatusLine(claudeDir) {
+  const settingsPath = path5.join(claudeDir, "settings.json");
+  try {
+    const existingSettings = await import_fs_extra3.default.readFile(settingsPath, "utf-8");
+    const settings = JSON.parse(existingSettings);
+    return !!settings.statusLine;
+  } catch {
+    return false;
+  }
+}
+async function updateSettings(options, claudeDir) {
+  const settingsPath = path5.join(claudeDir, "settings.json");
+  let settings = {};
+  try {
+    const existingSettings = await import_fs_extra3.default.readFile(settingsPath, "utf-8");
+    settings = JSON.parse(existingSettings);
+  } catch {}
+  if (options.customStatusline) {
+    const shouldReplace = options.replaceStatusline !== false;
+    if (shouldReplace) {
+      settings.statusLine = {
+        type: "command",
+        command: `bun ${toPosixPath(path5.join(claudeDir, "scripts/statusline/src/index.ts"))}`,
+        padding: 0
+      };
+    }
+  }
+  if (!settings.permissions) {
+    settings.permissions = {};
+  }
+  settings.permissions.defaultMode = "bypassPermissions";
+  if (!settings.permissions.deny) {
+    settings.permissions.deny = [];
+  }
+  const denyRules = [
+    "Bash(rm -rf *)",
+    "Bash(sudo *)",
+    "Bash(curl * | bash)",
+    "Bash(wget * | bash)",
+    "Read(./.env)",
+    "Read(./.env.*)"
+  ];
+  for (const rule of denyRules) {
+    if (!settings.permissions.deny.includes(rule)) {
+      settings.permissions.deny.push(rule);
+    }
+  }
+  await import_fs_extra3.default.writeJson(settingsPath, settings, { spaces: 2 });
+}
+
+// src/commands/setup/utils.ts
 var import_fs_extra4 = __toESM(require_lib4(), 1);
 import path6 from "path";
+import os6 from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+
+class SimpleSpinner {
+  message = "";
+  start(message) {
+    this.message = message;
+    console.log(source_default.gray(`⏳ ${message}...`));
+  }
+  stop(message) {
+    console.log(source_default.green(`✓ ${message}`));
+  }
+}
+var GITHUB_REPO = "https://github.com/Melvynx/aiblueprint.git";
+async function cloneRepository() {
+  const tmpDir = path6.join(os6.tmpdir(), `aiblueprint-${Date.now()}`);
+  try {
+    await import_fs_extra4.default.ensureDir(tmpDir);
+    await execAsync(`git clone --depth 1 --quiet ${GITHUB_REPO} "${tmpDir}"`);
+    return tmpDir;
+  } catch (error) {
+    console.error(source_default.yellow(`  Warning: Failed to clone repository: ${error instanceof Error ? error.message : String(error)}`));
+    await import_fs_extra4.default.remove(tmpDir).catch(() => {});
+    return null;
+  }
+}
+async function cleanupRepository(repoPath) {
+  try {
+    await import_fs_extra4.default.remove(repoPath);
+  } catch (error) {
+    console.error(source_default.yellow(`  Warning: Failed to cleanup temporary directory: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+async function resolveConfigDir(repoPath) {
+  const candidates = ["ai-config", "claude-code-config"];
+  for (const name of candidates) {
+    const candidate = path6.join(repoPath, name);
+    if (await import_fs_extra4.default.pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+// src/lib/version.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var cachedVersion = null;
+function getVersion() {
+  if (cachedVersion)
+    return cachedVersion;
+  try {
+    const __dirname2 = dirname(fileURLToPath(import.meta.url));
+    const packageJson = JSON.parse(readFileSync2(join(__dirname2, "../package.json"), "utf8"));
+    cachedVersion = packageJson.version;
+    return cachedVersion ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+// src/lib/backup-utils.ts
+var import_fs_extra5 = __toESM(require_lib4(), 1);
+import path7 from "path";
+import os7 from "os";
+var BACKUP_BASE_DIR = path7.join(os7.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_extra5.default.pathExists(BACKUP_BASE_DIR);
+  if (!exists) {
+    return [];
+  }
+  const entries = await import_fs_extra5.default.readdir(BACKUP_BASE_DIR, { withFileTypes: true });
+  const backups = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const match = entry.name.match(/^(\d{4})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-(\d{2})$/);
+    if (!match)
+      continue;
+    const [, year, month, day, hour, minute, second] = match;
+    const date = new Date(parseInt(year), parseInt(month) - 1, parseInt(day), parseInt(hour), parseInt(minute), parseInt(second));
+    backups.push({
+      name: entry.name,
+      path: path7.join(BACKUP_BASE_DIR, entry.name),
+      date
+    });
+  }
+  return backups.sort((a, b) => b.date.getTime() - a.date.getTime());
+}
+var AGENTS_BACKUP_SUBDIR = ".agents";
+var CLAUDE_ITEMS = ["commands", "agents", "skills", "scripts", "settings.json"];
+async function copyForBackup(sourcePath, destPath) {
+  await import_fs_extra5.default.copy(sourcePath, destPath, {
+    overwrite: true,
+    dereference: false,
+    filter: async (src) => {
+      try {
+        const stat = await import_fs_extra5.default.lstat(src);
+        return !stat.isSymbolicLink();
+      } catch {
+        return true;
+      }
+    }
+  });
+}
+async function hasMeaningfulContent(dir) {
+  if (!await import_fs_extra5.default.pathExists(dir))
+    return false;
+  const files = await import_fs_extra5.default.readdir(dir);
+  return files.some((f) => f !== ".DS_Store");
+}
+async function loadBackup(backupPath, claudeDir, agentsDir) {
+  const exists = await import_fs_extra5.default.pathExists(backupPath);
+  if (!exists) {
+    throw new Error(`Backup not found: ${backupPath}`);
+  }
+  await import_fs_extra5.default.ensureDir(claudeDir);
+  for (const item of CLAUDE_ITEMS) {
+    const sourcePath = path7.join(backupPath, item);
+    const destPath = path7.join(claudeDir, item);
+    if (await import_fs_extra5.default.pathExists(sourcePath)) {
+      await copyForBackup(sourcePath, destPath);
+    }
+  }
+  if (agentsDir) {
+    const agentsBackupPath = path7.join(backupPath, AGENTS_BACKUP_SUBDIR);
+    if (await import_fs_extra5.default.pathExists(agentsBackupPath)) {
+      await import_fs_extra5.default.ensureDir(agentsDir);
+      await copyForBackup(agentsBackupPath, agentsDir);
+    }
+  }
+}
+async function createBackup(claudeDir, agentsDir) {
+  const claudeHasContent = await hasMeaningfulContent(claudeDir);
+  const agentsHasContent = agentsDir ? await hasMeaningfulContent(agentsDir) : false;
+  if (!claudeHasContent && !agentsHasContent) {
+    return null;
+  }
+  const timestamp = formatDate(new Date);
+  const backupPath = path7.join(BACKUP_BASE_DIR, timestamp);
+  await import_fs_extra5.default.ensureDir(backupPath);
+  if (claudeHasContent) {
+    for (const item of CLAUDE_ITEMS) {
+      const sourcePath = path7.join(claudeDir, item);
+      const destPath = path7.join(backupPath, item);
+      if (await import_fs_extra5.default.pathExists(sourcePath)) {
+        await copyForBackup(sourcePath, destPath);
+      }
+    }
+  }
+  if (agentsHasContent && agentsDir) {
+    const destPath = path7.join(backupPath, AGENTS_BACKUP_SUBDIR);
+    await copyForBackup(agentsDir, destPath);
+  }
+  return backupPath;
+}
 
 // src/lib/platform.ts
-var import_fs_extra3 = __toESM(require_lib4(), 1);
-import os6 from "os";
-import path5 from "path";
+var import_fs_extra6 = __toESM(require_lib4(), 1);
+import os8 from "os";
+import path8 from "path";
 import { execSync as execSync2 } from "child_process";
 function escapeShellArg(arg) {
   return "'" + arg.replace(/'/g, "'\\''") + "'";
@@ -33053,15 +33272,15 @@ function escapeShellArg(arg) {
 var cachedPlatformInfo = null;
 var cachedAudioPlayer = undefined;
 function isWSL() {
-  if (os6.platform() !== "linux")
+  if (os8.platform() !== "linux")
     return false;
-  const release = os6.release().toLowerCase();
+  const release = os8.release().toLowerCase();
   return release.includes("microsoft") || release.includes("wsl");
 }
 function getPlatformInfo() {
   if (cachedPlatformInfo)
     return cachedPlatformInfo;
-  const platform = os6.platform();
+  const platform = os8.platform();
   const wsl = isWSL();
   cachedPlatformInfo = {
     platform,
@@ -33069,14 +33288,14 @@ function getPlatformInfo() {
     isMacOS: platform === "darwin",
     isLinux: platform === "linux" && !wsl,
     isWSL: wsl,
-    homeDir: os6.homedir()
+    homeDir: os8.homedir()
   };
   return cachedPlatformInfo;
 }
 function detectAudioPlayer() {
   if (cachedAudioPlayer !== undefined)
     return cachedAudioPlayer;
-  const platform = os6.platform();
+  const platform = os8.platform();
   if (platform === "darwin") {
     cachedAudioPlayer = "afplay";
     return cachedAudioPlayer;
@@ -33115,7 +33334,7 @@ function getPlaySoundCommand(soundPath) {
   const player = detectAudioPlayer();
   if (!player)
     return null;
-  const platform = os6.platform();
+  const platform = os8.platform();
   const safePath = escapeShellArg(soundPath);
   if (platform === "darwin") {
     return `afplay -v 0.1 ${safePath}`;
@@ -33152,33 +33371,6 @@ var KNOWN_CLAUDE_PATHS = [
   /\/root\/\.claude\//,
   /C:\\Users\\[^\\]+\\\.claude\\/i
 ];
-function transformHookCommand(command, claudeDir) {
-  let transformed = command;
-  for (const pattern of KNOWN_CLAUDE_PATHS) {
-    transformed = transformed.replace(pattern, `${claudeDir}/`);
-  }
-  transformed = transformed.replace(/\\/g, "/");
-  const isAudioCommand = /^(afplay|paplay|aplay|mpv|ffplay|powershell)\s/.test(transformed);
-  if (isAudioCommand) {
-    const newCommand = transformAudioCommand(transformed, claudeDir);
-    if (newCommand) {
-      return newCommand;
-    }
-  }
-  return transformed;
-}
-function transformHook(hook, claudeDir) {
-  if (!hook)
-    return hook;
-  const transformed = { ...hook };
-  if (transformed.command && typeof transformed.command === "string") {
-    transformed.command = transformHookCommand(transformed.command, claudeDir);
-  }
-  if (Array.isArray(transformed.hooks)) {
-    transformed.hooks = transformed.hooks.map((h) => transformHook(h, claudeDir));
-  }
-  return transformed;
-}
 var TEXT_FILE_EXTENSIONS = new Set([
   ".ts",
   ".tsx",
@@ -33225,16 +33417,16 @@ function replaceClaudePathPlaceholder(content, claudeDir) {
   return content.replaceAll("{CLAUDE_PATH}", claudeDir);
 }
 async function replacePathPlaceholdersInDir(dir, claudeDir) {
-  const entries = await import_fs_extra3.default.readdir(dir, { withFileTypes: true });
+  const entries = await import_fs_extra6.default.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path5.join(dir, entry.name);
+    const fullPath = path8.join(dir, entry.name);
     if (entry.isDirectory()) {
       await replacePathPlaceholdersInDir(fullPath, claudeDir);
     } else if (isTextFile(entry.name)) {
-      const content = await import_fs_extra3.default.readFile(fullPath, "utf-8");
+      const content = await import_fs_extra6.default.readFile(fullPath, "utf-8");
       const replaced = replaceClaudePathPlaceholder(content, claudeDir);
       if (replaced !== content) {
-        await import_fs_extra3.default.writeFile(fullPath, replaced, "utf-8");
+        await import_fs_extra6.default.writeFile(fullPath, replaced, "utf-8");
       }
     }
   }
@@ -33263,253 +33455,10 @@ function transformFileContent(content, claudeDir) {
   return transformed;
 }
 
-// src/commands/setup/settings.ts
-function toPosixPath(p) {
-  return p.replace(/\\/g, "/");
-}
-async function hasExistingStatusLine(claudeDir) {
-  const settingsPath = path6.join(claudeDir, "settings.json");
-  try {
-    const existingSettings = await import_fs_extra4.default.readFile(settingsPath, "utf-8");
-    const settings = JSON.parse(existingSettings);
-    return !!settings.statusLine;
-  } catch {
-    return false;
-  }
-}
-async function updateSettings(options, claudeDir) {
-  const settingsPath = path6.join(claudeDir, "settings.json");
-  let settings = {};
-  try {
-    const existingSettings = await import_fs_extra4.default.readFile(settingsPath, "utf-8");
-    settings = JSON.parse(existingSettings);
-  } catch {}
-  if (options.customStatusline) {
-    const shouldReplace = options.replaceStatusline !== false;
-    if (shouldReplace) {
-      settings.statusLine = {
-        type: "command",
-        command: `bun ${toPosixPath(path6.join(claudeDir, "scripts/statusline/src/index.ts"))}`,
-        padding: 0
-      };
-    }
-  }
-  if (!settings.permissions) {
-    settings.permissions = {};
-  }
-  settings.permissions.defaultMode = "bypassPermissions";
-  if (!settings.permissions.deny) {
-    settings.permissions.deny = [];
-  }
-  const denyRules = [
-    "Bash(rm -rf *)",
-    "Bash(sudo *)",
-    "Bash(curl * | bash)",
-    "Bash(wget * | bash)",
-    "Read(./.env)",
-    "Read(./.env.*)"
-  ];
-  for (const rule of denyRules) {
-    if (!settings.permissions.deny.includes(rule)) {
-      settings.permissions.deny.push(rule);
-    }
-  }
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  if (options.commandValidation) {
-    if (!settings.hooks.PreToolUse) {
-      settings.hooks.PreToolUse = [];
-    }
-    const bashHook = {
-      matcher: "Bash",
-      hooks: [
-        {
-          type: "command",
-          command: `bun ${toPosixPath(path6.join(claudeDir, "scripts/command-validator/src/cli.ts"))}`
-        }
-      ]
-    };
-    const existingBashHook = settings.hooks.PreToolUse.find((h) => h.matcher === "Bash");
-    if (!existingBashHook) {
-      settings.hooks.PreToolUse.push(bashHook);
-    }
-  }
-  if (options.notificationSounds) {
-    const finishSoundPath = toPosixPath(path6.join(claudeDir, "song/finish.mp3"));
-    const finishSoundCommand = getPlaySoundCommand(finishSoundPath);
-    if (finishSoundCommand) {
-      if (!settings.hooks.Stop) {
-        settings.hooks.Stop = [];
-      }
-      const stopHook = {
-        matcher: "",
-        hooks: [
-          {
-            type: "command",
-            command: finishSoundCommand
-          }
-        ]
-      };
-      const existingStopHook = settings.hooks.Stop.find((h) => h.hooks?.some((hook) => hook.command?.includes("finish.mp3")));
-      if (!existingStopHook) {
-        settings.hooks.Stop.push(stopHook);
-      }
-    }
-    const needHumanSoundPath = toPosixPath(path6.join(claudeDir, "song/need-human.mp3"));
-    const needHumanSoundCommand = getPlaySoundCommand(needHumanSoundPath);
-    if (needHumanSoundCommand) {
-      if (!settings.hooks.Notification) {
-        settings.hooks.Notification = [];
-      }
-      const notificationHook = {
-        matcher: "",
-        hooks: [
-          {
-            type: "command",
-            command: needHumanSoundCommand
-          }
-        ]
-      };
-      const existingNotificationHook = settings.hooks.Notification.find((h) => h.hooks?.some((hook) => hook.command?.includes("need-human.mp3")));
-      if (!existingNotificationHook) {
-        settings.hooks.Notification.push(notificationHook);
-      }
-    }
-  }
-  await import_fs_extra4.default.writeJson(settingsPath, settings, { spaces: 2 });
-}
-
-// src/commands/setup/utils.ts
-var import_fs_extra5 = __toESM(require_lib4(), 1);
-import path7 from "path";
-import os7 from "os";
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-
-class SimpleSpinner {
-  message = "";
-  start(message) {
-    this.message = message;
-    console.log(source_default.gray(`⏳ ${message}...`));
-  }
-  stop(message) {
-    console.log(source_default.green(`✓ ${message}`));
-  }
-}
-var GITHUB_REPO = "https://github.com/Melvynx/aiblueprint.git";
-async function cloneRepository() {
-  const tmpDir = path7.join(os7.tmpdir(), `aiblueprint-${Date.now()}`);
-  try {
-    await import_fs_extra5.default.ensureDir(tmpDir);
-    await execAsync(`git clone --depth 1 --quiet ${GITHUB_REPO} "${tmpDir}"`);
-    return tmpDir;
-  } catch (error) {
-    console.error(source_default.yellow(`  Warning: Failed to clone repository: ${error instanceof Error ? error.message : String(error)}`));
-    await import_fs_extra5.default.remove(tmpDir).catch(() => {});
-    return null;
-  }
-}
-async function cleanupRepository(repoPath) {
-  try {
-    await import_fs_extra5.default.remove(repoPath);
-  } catch (error) {
-    console.error(source_default.yellow(`  Warning: Failed to cleanup temporary directory: ${error instanceof Error ? error.message : String(error)}`));
-  }
-}
-
-// src/lib/version.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-var cachedVersion = null;
-function getVersion() {
-  if (cachedVersion)
-    return cachedVersion;
-  try {
-    const __dirname2 = dirname(fileURLToPath(import.meta.url));
-    const packageJson = JSON.parse(readFileSync2(join(__dirname2, "../package.json"), "utf8"));
-    cachedVersion = packageJson.version;
-    return cachedVersion ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-
-// src/lib/backup-utils.ts
-var import_fs_extra6 = __toESM(require_lib4(), 1);
-import path8 from "path";
-import os8 from "os";
-var BACKUP_BASE_DIR = path8.join(os8.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_extra6.default.pathExists(BACKUP_BASE_DIR);
-  if (!exists) {
-    return [];
-  }
-  const entries = await import_fs_extra6.default.readdir(BACKUP_BASE_DIR, { withFileTypes: true });
-  const backups = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory())
-      continue;
-    const match = entry.name.match(/^(\d{4})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-(\d{2})$/);
-    if (!match)
-      continue;
-    const [, year, month, day, hour, minute, second] = match;
-    const date = new Date(parseInt(year), parseInt(month) - 1, parseInt(day), parseInt(hour), parseInt(minute), parseInt(second));
-    backups.push({
-      name: entry.name,
-      path: path8.join(BACKUP_BASE_DIR, entry.name),
-      date
-    });
-  }
-  return backups.sort((a, b) => b.date.getTime() - a.date.getTime());
-}
-async function loadBackup(backupPath, claudeDir) {
-  const exists = await import_fs_extra6.default.pathExists(backupPath);
-  if (!exists) {
-    throw new Error(`Backup not found: ${backupPath}`);
-  }
-  await import_fs_extra6.default.ensureDir(claudeDir);
-  const itemsToCopy = ["commands", "agents", "skills", "scripts", "song", "settings.json"];
-  for (const item of itemsToCopy) {
-    const sourcePath = path8.join(backupPath, item);
-    const destPath = path8.join(claudeDir, item);
-    if (await import_fs_extra6.default.pathExists(sourcePath)) {
-      await import_fs_extra6.default.copy(sourcePath, destPath, { overwrite: true });
-    }
-  }
-}
-async function createBackup(claudeDir) {
-  const exists = await import_fs_extra6.default.pathExists(claudeDir);
-  if (!exists) {
-    return null;
-  }
-  const files = await import_fs_extra6.default.readdir(claudeDir);
-  const hasContent = files.some((f) => f !== ".DS_Store");
-  if (!hasContent) {
-    return null;
-  }
-  const timestamp = formatDate(new Date);
-  const backupPath = path8.join(BACKUP_BASE_DIR, timestamp);
-  await import_fs_extra6.default.ensureDir(backupPath);
-  const itemsToCopy = ["commands", "agents", "skills", "scripts", "song", "settings.json"];
-  for (const item of itemsToCopy) {
-    const sourcePath = path8.join(claudeDir, item);
-    const destPath = path8.join(backupPath, item);
-    if (await import_fs_extra6.default.pathExists(sourcePath)) {
-      await import_fs_extra6.default.copy(sourcePath, destPath, { overwrite: true });
-    }
-  }
-  return backupPath;
-}
-
 // src/lib/telemetry.ts
 import os9 from "os";
+import fs7 from "fs";
+import path9 from "path";
 var TELEMETRY_URL = "https://codelynx.dev/api/cli/events";
 var isDisabled = () => {
   return process.env.AIBLUEPRINT_TELEMETRY_DISABLED === "1";
@@ -33520,6 +33469,31 @@ var getBasePayload = () => ({
   arch: os9.arch(),
   nodeVersion: process.version
 });
+function getTokenFilePath() {
+  const homeDir = os9.homedir();
+  if (os9.platform() === "win32") {
+    const appData = process.env.APPDATA || path9.join(homeDir, "AppData", "Roaming");
+    return path9.join(appData, "aiblueprint", "token.txt");
+  }
+  const configHome = process.env.XDG_CONFIG_HOME || path9.join(homeDir, ".config");
+  return path9.join(configHome, "aiblueprint", "token.txt");
+}
+function getSystemInfo() {
+  let hasProToken = false;
+  try {
+    hasProToken = fs7.existsSync(getTokenFilePath());
+  } catch {}
+  return {
+    osVersion: os9.release(),
+    osType: os9.type(),
+    totalMemory: `${Math.round(os9.totalmem() / (1024 * 1024 * 1024))}GB`,
+    cpus: os9.cpus().length,
+    shell: process.env.SHELL || process.env.COMSPEC || "unknown",
+    homeDir: os9.homedir(),
+    locale: process.env.LANG || process.env.LC_ALL || "unknown",
+    hasProToken
+  };
+}
 var pendingRequest = null;
 function trackEvent(event, data) {
   if (isDisabled())
@@ -33542,10 +33516,11 @@ function trackError(error, context) {
   if (isDisabled())
     return;
   const message = error instanceof Error ? error.message : String(error);
-  const stack = error instanceof Error ? error.stack?.slice(0, 500) : undefined;
+  const stack = error instanceof Error ? error.stack?.slice(0, 1500) : undefined;
   trackEvent("error", {
     message,
     stack,
+    ...getSystemInfo(),
     ...context
   });
 }
@@ -33555,6 +33530,116 @@ async function flushTelemetry() {
   }
 }
 
+// src/lib/agents-installer.ts
+var import_fs_extra7 = __toESM(require_lib4(), 1);
+import os10 from "os";
+import path10 from "path";
+var AGENT_CATEGORIES = ["skills"];
+function getAgentsDir(custom) {
+  return custom ? path10.resolve(custom) : path10.join(os10.homedir(), ".agents");
+}
+async function platformSymlink(source, target) {
+  await import_fs_extra7.default.ensureDir(path10.dirname(target));
+  const isWindows2 = os10.platform() === "win32";
+  const sourceStat = await import_fs_extra7.default.stat(source).catch(() => null);
+  if (isWindows2 && sourceStat?.isDirectory()) {
+    await import_fs_extra7.default.symlink(source, target, "junction");
+  } else {
+    await import_fs_extra7.default.symlink(source, target);
+  }
+}
+async function installCategoryToAgents(sourceCategoryDir, category, agentsDir, claudeDir, options = {}) {
+  const result = {
+    copied: [],
+    migrated: [],
+    symlinked: [],
+    skipped: []
+  };
+  if (!await import_fs_extra7.default.pathExists(sourceCategoryDir)) {
+    return result;
+  }
+  const agentsCategoryDir = path10.join(agentsDir, category);
+  await import_fs_extra7.default.ensureDir(agentsCategoryDir);
+  const entries = await import_fs_extra7.default.readdir(sourceCategoryDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".DS_Store" || entry.name === "node_modules")
+      continue;
+    const sourcePath = path10.join(sourceCategoryDir, entry.name);
+    const agentsTarget = path10.join(agentsCategoryDir, entry.name);
+    const claudeTarget = path10.join(claudeDir, category, entry.name);
+    const agentsExists = await import_fs_extra7.default.pathExists(agentsTarget);
+    if (!agentsExists) {
+      let migrated = false;
+      if (options.migrateClaudeDirs) {
+        const claudeStat = await import_fs_extra7.default.lstat(claudeTarget).catch(() => null);
+        if (claudeStat && !claudeStat.isSymbolicLink()) {
+          await import_fs_extra7.default.move(claudeTarget, agentsTarget);
+          result.migrated.push(entry.name);
+          migrated = true;
+        }
+      }
+      if (!migrated) {
+        await import_fs_extra7.default.copy(sourcePath, agentsTarget, { overwrite: false });
+        await replacePathPlaceholdersInDir(agentsTarget, claudeDir);
+        result.copied.push(entry.name);
+      }
+    } else if (options.overwrite) {
+      await import_fs_extra7.default.remove(agentsTarget);
+      await import_fs_extra7.default.copy(sourcePath, agentsTarget, { overwrite: false });
+      await replacePathPlaceholdersInDir(agentsTarget, claudeDir);
+      result.copied.push(entry.name);
+    }
+  }
+  await syncCategorySymlinks(category, agentsDir, claudeDir, result, options.silent);
+  return result;
+}
+async function syncCategorySymlinks(category, agentsDir, claudeDir, result, silent = false) {
+  const agentsCategoryDir = path10.join(agentsDir, category);
+  const claudeCategoryDir = path10.join(claudeDir, category);
+  if (!await import_fs_extra7.default.pathExists(agentsCategoryDir)) {
+    return;
+  }
+  await import_fs_extra7.default.ensureDir(claudeCategoryDir);
+  const entries = await import_fs_extra7.default.readdir(agentsCategoryDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".DS_Store")
+      continue;
+    const agentsTarget = path10.join(agentsCategoryDir, entry.name);
+    const claudeTarget = path10.join(claudeCategoryDir, entry.name);
+    const claudeStat = await import_fs_extra7.default.lstat(claudeTarget).catch(() => null);
+    if (!claudeStat) {
+      await platformSymlink(agentsTarget, claudeTarget);
+      result?.symlinked.push(entry.name);
+    } else if (claudeStat.isSymbolicLink()) {
+      await import_fs_extra7.default.remove(claudeTarget);
+      await platformSymlink(agentsTarget, claudeTarget);
+      result?.symlinked.push(entry.name);
+    } else {
+      const reason = `Real directory at ${claudeTarget} - skipped to avoid destruction`;
+      result?.skipped.push({ name: entry.name, reason });
+      if (!silent) {
+        console.log(source_default.yellow(`  ⚠️  ${entry.name}: existing real ${category.slice(0, -1)} kept in place (not symlinked)`));
+      }
+    }
+  }
+  if (await import_fs_extra7.default.pathExists(claudeCategoryDir)) {
+    const claudeEntries = await import_fs_extra7.default.readdir(claudeCategoryDir, { withFileTypes: true });
+    for (const entry of claudeEntries) {
+      const claudeTarget = path10.join(claudeCategoryDir, entry.name);
+      const stat = await import_fs_extra7.default.lstat(claudeTarget).catch(() => null);
+      if (stat?.isSymbolicLink()) {
+        const exists = await import_fs_extra7.default.pathExists(claudeTarget);
+        if (!exists) {
+          await import_fs_extra7.default.remove(claudeTarget);
+        }
+      }
+    }
+  }
+}
+function isAgentCategory(category) {
+  return AGENT_CATEGORIES.includes(category);
+}
+
 // src/commands/setup.ts
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
@@ -33563,6 +33648,7 @@ async function setupCommand(params = {}) {
     claudeCodeFolder: customClaudeCodeFolder,
     codexFolder: customCodexFolder,
     openCodeFolder: customOpenCodeFolder,
+    agentsFolder: customAgentsFolder,
     skipInteractive
   } = params;
   let repoPath = null;
@@ -33575,12 +33661,10 @@ async function setupCommand(params = {}) {
     if (skipInteractive) {
       features = [
         "shellShortcuts",
-        "commandValidation",
         "customStatusline",
         "aiblueprintCommands",
         "aiblueprintAgents",
         "aiblueprintSkills",
-        "notificationSounds",
         "codexSymlink",
         "openCodeSymlink"
       ];
@@ -33597,11 +33681,6 @@ async function setupCommand(params = {}) {
               name: "Shell shortcuts (cc, ccc aliases) - Quick access to Claude Code",
               checked: true
             },
-            {
-              value: "commandValidation",
-              name: "Command validation - Security hook for bash commands",
-              checked: true
-            },
             {
               value: "customStatusline",
               name: "Custom statusline - Shows git, costs, tokens info",
@@ -33617,11 +33696,6 @@ async function setupCommand(params = {}) {
               name: "AIBlueprint agents - Specialized AI agents",
               checked: true
             },
-            {
-              value: "notificationSounds",
-              name: "Notification sounds - Audio alerts for events",
-              checked: true
-            },
             {
               value: "aiblueprintSkills",
               name: "AIBlueprint skills - Pre-built skills (apex, commit, oneshot, etc.)",
@@ -33648,22 +33722,23 @@ async function setupCommand(params = {}) {
     }
     const options = {
       shellShortcuts: features.includes("shellShortcuts"),
-      commandValidation: features.includes("commandValidation"),
       customStatusline: features.includes("customStatusline"),
       aiblueprintCommands: features.includes("aiblueprintCommands"),
       aiblueprintAgents: features.includes("aiblueprintAgents"),
       aiblueprintSkills: features.includes("aiblueprintSkills"),
-      notificationSounds: features.includes("notificationSounds"),
       codexSymlink: features.includes("codexSymlink"),
       openCodeSymlink: features.includes("openCodeSymlink"),
       skipInteractive
     };
     const s = new SimpleSpinner;
-    const claudeDir = customClaudeCodeFolder ? path9.resolve(customClaudeCodeFolder) : path9.join(os10.homedir(), ".claude");
+    const claudeDir = customClaudeCodeFolder ? path11.resolve(customClaudeCodeFolder) : path11.join(os11.homedir(), ".claude");
+    const agentsDir = getAgentsDir(customAgentsFolder);
     console.log(source_default.gray(`Installing to: ${claudeDir}`));
-    await import_fs_extra7.default.ensureDir(claudeDir);
+    console.log(source_default.gray(`Skills source: ${agentsDir}/skills`));
+    await import_fs_extra8.default.ensureDir(claudeDir);
+    await import_fs_extra8.default.ensureDir(agentsDir);
     s.start("Creating backup of existing configuration");
-    const backupPath = await createBackup(claudeDir);
+    const backupPath = await createBackup(claudeDir, agentsDir);
     if (backupPath) {
       s.stop(`Backup created: ${source_default.gray(backupPath)}`);
     } else {
@@ -33674,10 +33749,10 @@ async function setupCommand(params = {}) {
     if (!repoPath) {
       throw new Error("Failed to clone repository. Please check your internet connection and try again.");
     }
-    const sourceDir = path9.join(repoPath, "claude-code-config");
-    if (!await import_fs_extra7.default.pathExists(sourceDir)) {
+    const sourceDir = await resolveConfigDir(repoPath);
+    if (!sourceDir) {
       await cleanupRepository(repoPath);
-      throw new Error("Configuration directory not found in cloned repository");
+      throw new Error("Configuration directory not found in cloned repository (looked for ai-config/ and claude-code-config/)");
     }
     s.stop("Repository cloned successfully");
     if (options.shellShortcuts) {
@@ -33685,21 +33760,21 @@ async function setupCommand(params = {}) {
       await setupShellShortcuts();
       s.stop("Shell shortcuts configured");
     }
-    if (options.commandValidation || options.customStatusline || options.notificationSounds) {
+    if (options.customStatusline) {
       s.start("Setting up scripts");
-      await import_fs_extra7.default.copy(path9.join(sourceDir, "scripts"), path9.join(claudeDir, "scripts"), { overwrite: true });
-      await replacePathPlaceholdersInDir(path9.join(claudeDir, "scripts"), claudeDir);
+      await import_fs_extra8.default.copy(path11.join(sourceDir, "scripts"), path11.join(claudeDir, "scripts"), { overwrite: true });
+      await replacePathPlaceholdersInDir(path11.join(claudeDir, "scripts"), claudeDir);
       if (options.customStatusline) {
-        await import_fs_extra7.default.ensureDir(path9.join(claudeDir, "scripts/statusline/data"));
+        await import_fs_extra8.default.ensureDir(path11.join(claudeDir, "scripts/statusline/data"));
       }
       s.stop("Scripts installed");
     }
     if (options.aiblueprintCommands) {
       s.start("Setting up AIBlueprint commands");
-      const commandsSourcePath = path9.join(sourceDir, "commands");
-      if (await import_fs_extra7.default.pathExists(commandsSourcePath)) {
-        await import_fs_extra7.default.copy(commandsSourcePath, path9.join(claudeDir, "commands"), { overwrite: true });
-        await replacePathPlaceholdersInDir(path9.join(claudeDir, "commands"), claudeDir);
+      const commandsSourcePath = path11.join(sourceDir, "commands");
+      if (await import_fs_extra8.default.pathExists(commandsSourcePath)) {
+        await import_fs_extra8.default.copy(commandsSourcePath, path11.join(claudeDir, "commands"), { overwrite: true });
+        await replacePathPlaceholdersInDir(path11.join(claudeDir, "commands"), claudeDir);
         s.stop("Commands installed");
       } else {
         s.stop("Commands not available in repository");
@@ -33717,26 +33792,31 @@ async function setupCommand(params = {}) {
     }
     if (options.aiblueprintAgents) {
       s.start("Setting up AIBlueprint agents");
-      await import_fs_extra7.default.copy(path9.join(sourceDir, "agents"), path9.join(claudeDir, "agents"), { overwrite: true });
-      await replacePathPlaceholdersInDir(path9.join(claudeDir, "agents"), claudeDir);
+      await import_fs_extra8.default.copy(path11.join(sourceDir, "agents"), path11.join(claudeDir, "agents"), { overwrite: true });
+      await replacePathPlaceholdersInDir(path11.join(claudeDir, "agents"), claudeDir);
       s.stop("Agents installed");
     }
     if (options.aiblueprintSkills) {
       s.start("Setting up AIBlueprint Skills");
-      const skillsSourcePath = path9.join(sourceDir, "skills");
-      if (await import_fs_extra7.default.pathExists(skillsSourcePath)) {
-        await import_fs_extra7.default.copy(skillsSourcePath, path9.join(claudeDir, "skills"), { overwrite: true });
-        await replacePathPlaceholdersInDir(path9.join(claudeDir, "skills"), claudeDir);
-        s.stop("Skills installed");
+      const skillsSourcePath = path11.join(sourceDir, "skills");
+      if (await import_fs_extra8.default.pathExists(skillsSourcePath)) {
+        const installResult = await installCategoryToAgents(skillsSourcePath, "skills", agentsDir, claudeDir, { migrateClaudeDirs: true, silent: true });
+        const summary = [
+          installResult.copied.length && `${installResult.copied.length} copied`,
+          installResult.migrated.length && `${installResult.migrated.length} migrated`,
+          installResult.symlinked.length && `${installResult.symlinked.length} linked`,
+          installResult.skipped.length && `${installResult.skipped.length} skipped`
+        ].filter(Boolean).join(", ");
+        s.stop(`Skills installed${summary ? ` (${summary})` : ""}`);
+        if (installResult.skipped.length > 0) {
+          for (const sk of installResult.skipped) {
+            console.log(source_default.yellow(`  ⚠️  ${sk.name}: ${sk.reason}`));
+          }
+        }
       } else {
         s.stop("Skills not available in repository");
       }
     }
-    if (options.notificationSounds) {
-      s.start("Setting up notification sounds");
-      await import_fs_extra7.default.copy(path9.join(sourceDir, "song"), path9.join(claudeDir, "song"), { overwrite: true });
-      s.stop("Notification sounds installed");
-    }
     if (options.customStatusline) {
       s.start("Checking dependencies");
       await checkAndInstallDependencies();
@@ -33773,7 +33853,7 @@ async function setupCommand(params = {}) {
     console.log(source_default.gray(`
 Next steps:`));
     if (options.shellShortcuts) {
-      const platform = os10.platform();
+      const platform = os11.platform();
       if (platform === "win32") {
         console.log(source_default.gray("  • Restart PowerShell to load the new functions"));
       } else {
@@ -33799,9 +33879,9 @@ Next steps:`));
 }
 
 // src/commands/setup-terminal.ts
-var import_fs_extra8 = __toESM(require_lib4(), 1);
-import path10 from "path";
-import os11 from "os";
+var import_fs_extra9 = __toESM(require_lib4(), 1);
+import path12 from "path";
+import os12 from "os";
 import { execSync as execSync3, exec as exec2 } from "child_process";
 var OHMYZSH_INSTALL_URL = "https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh";
 var INSTALL_TIMEOUT = 120000;
@@ -33835,16 +33915,16 @@ function commandExists(cmd) {
   }
 }
 function isOhMyZshInstalled(homeDir) {
-  const ohMyZshDir = path10.join(homeDir, ".oh-my-zsh");
-  return import_fs_extra8.default.existsSync(ohMyZshDir);
+  const ohMyZshDir = path12.join(homeDir, ".oh-my-zsh");
+  return import_fs_extra9.default.existsSync(ohMyZshDir);
 }
 function backupFile(filePath) {
-  if (!import_fs_extra8.default.existsSync(filePath))
+  if (!import_fs_extra9.default.existsSync(filePath))
     return null;
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   const backupPath = `${filePath}.backup-${timestamp}`;
   try {
-    import_fs_extra8.default.copyFileSync(filePath, backupPath);
+    import_fs_extra9.default.copyFileSync(filePath, backupPath);
     return backupPath;
   } catch (error) {
     throw new Error(`Failed to create backup: ${error.message}`);
@@ -33883,7 +33963,7 @@ function installPrerequisiteSync(packageName, installCmd) {
 async function installOhMyZsh(homeDir) {
   return new Promise((resolve, reject) => {
     const installCmd = `sh -c "$(curl -fsSL ${OHMYZSH_INSTALL_URL})" "" --unattended`;
-    const env2 = { ...process.env, HOME: homeDir, ZSH: path10.join(homeDir, ".oh-my-zsh") };
+    const env2 = { ...process.env, HOME: homeDir, ZSH: path12.join(homeDir, ".oh-my-zsh") };
     exec2(installCmd, { timeout: INSTALL_TIMEOUT, env: env2 }, (error, stdout, stderr) => {
       if (error) {
         if ("killed" in error && error.killed) {
@@ -33904,8 +33984,8 @@ async function installPlugin(pluginName, repoUrl, homeDir) {
   if (!/^https:\/\/github\.com\/[\w-]+\/[\w-]+$/.test(repoUrl)) {
     throw new Error(`Invalid repository URL: ${repoUrl}`);
   }
-  const customPluginsDir = path10.join(homeDir, ".oh-my-zsh/custom/plugins", pluginName);
-  if (import_fs_extra8.default.existsSync(customPluginsDir)) {
+  const customPluginsDir = path12.join(homeDir, ".oh-my-zsh/custom/plugins", pluginName);
+  if (import_fs_extra9.default.existsSync(customPluginsDir)) {
     return;
   }
   return new Promise((resolve, reject) => {
@@ -33923,20 +34003,20 @@ async function installPlugin(pluginName, repoUrl, homeDir) {
   });
 }
 function updateZshrcTheme(theme, homeDir) {
-  const zshrcPath = path10.join(homeDir, ".zshrc");
+  const zshrcPath = path12.join(homeDir, ".zshrc");
   const sanitizedTheme = sanitizeThemeName(theme);
-  if (!import_fs_extra8.default.existsSync(zshrcPath)) {
+  if (!import_fs_extra9.default.existsSync(zshrcPath)) {
     throw new Error(".zshrc file not found. Please ensure Oh My ZSH is installed correctly.");
   }
   try {
-    let content = import_fs_extra8.default.readFileSync(zshrcPath, "utf-8");
+    let content = import_fs_extra9.default.readFileSync(zshrcPath, "utf-8");
     if (content.match(/^ZSH_THEME=/m)) {
       content = content.replace(/^ZSH_THEME=.*/m, `ZSH_THEME="${sanitizedTheme}"`);
     } else {
       content = `ZSH_THEME="${sanitizedTheme}"
 ${content}`;
     }
-    import_fs_extra8.default.writeFileSync(zshrcPath, content);
+    import_fs_extra9.default.writeFileSync(zshrcPath, content);
   } catch (error) {
     if (error.message.includes(".zshrc file not found")) {
       throw error;
@@ -33945,12 +34025,12 @@ ${content}`;
   }
 }
 function updateZshrcPlugins(plugins, homeDir) {
-  const zshrcPath = path10.join(homeDir, ".zshrc");
-  if (!import_fs_extra8.default.existsSync(zshrcPath)) {
+  const zshrcPath = path12.join(homeDir, ".zshrc");
+  if (!import_fs_extra9.default.existsSync(zshrcPath)) {
     throw new Error(".zshrc file not found. Please ensure Oh My ZSH is installed correctly.");
   }
   try {
-    let content = import_fs_extra8.default.readFileSync(zshrcPath, "utf-8");
+    let content = import_fs_extra9.default.readFileSync(zshrcPath, "utf-8");
     const pluginsString = plugins.join(" ");
     if (content.match(/^plugins=\(/m)) {
       content = content.replace(/^plugins=\([^)]*\)/m, `plugins=(${pluginsString})`);
@@ -33958,7 +34038,7 @@ function updateZshrcPlugins(plugins, homeDir) {
       content = `${content}
 plugins=(${pluginsString})`;
     }
-    import_fs_extra8.default.writeFileSync(zshrcPath, content);
+    import_fs_extra9.default.writeFileSync(zshrcPath, content);
   } catch (error) {
     if (error.message.includes(".zshrc file not found")) {
       throw error;
@@ -33968,7 +34048,7 @@ plugins=(${pluginsString})`;
 }
 async function setupTerminalCommand(options = {}) {
   const { skipInteractive, homeDir: customHomeDir } = options;
-  const homeDir = customHomeDir || os11.homedir();
+  const homeDir = customHomeDir || os12.homedir();
   try {
     console.log(source_default.blue.bold(`
 \uD83D\uDDA5️  AIBlueprint Terminal Setup ${source_default.gray(`v${getVersion()}`)}
@@ -34065,8 +34145,8 @@ Installing missing prerequisites: ${missingPrereqs.join(", ")}`));
         selectedTheme = themeAnswer.theme;
       }
     }
-    const zshrcPath = path10.join(homeDir, ".zshrc");
-    if (import_fs_extra8.default.existsSync(zshrcPath)) {
+    const zshrcPath = path12.join(homeDir, ".zshrc");
+    if (import_fs_extra9.default.existsSync(zshrcPath)) {
       s.start("Backing up .zshrc");
       const backupPath = backupFile(zshrcPath);
       if (backupPath) {
@@ -34997,20 +35077,27 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 };
 
 // src/commands/pro.ts
-import os14 from "os";
-import path13 from "path";
+import os15 from "os";
+import path15 from "path";
 
 // src/lib/pro-installer.ts
-var import_fs_extra9 = __toESM(require_lib4(), 1);
-import os12 from "os";
-import path11 from "path";
+var import_fs_extra10 = __toESM(require_lib4(), 1);
+import os13 from "os";
+import path13 from "path";
 import { exec as exec3 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec3);
 var PREMIUM_REPO = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH = "main";
+function resolveBaseDir(relativePath, claudeDir, agentsDir) {
+  const firstSeg = relativePath.split(path13.sep)[0];
+  if (isAgentCategory(firstSeg)) {
+    return { base: agentsDir, isAgentTarget: true };
+  }
+  return { base: claudeDir, isAgentTarget: false };
+}
 function getCacheRepoDir() {
-  return path11.join(os12.homedir(), ".config", "aiblueprint", "pro-repos", "aiblueprint-cli-premium");
+  return path13.join(os13.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?:\/\//, "")}`;
@@ -35024,43 +35111,61 @@ 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_extra9.default.pathExists(path11.join(cacheDir, ".git"))) {
+  if (await import_fs_extra10.default.pathExists(path13.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra9.default.remove(cacheDir);
-      await import_fs_extra9.default.ensureDir(path11.dirname(cacheDir));
+      await import_fs_extra10.default.remove(cacheDir);
+      await import_fs_extra10.default.ensureDir(path13.dirname(cacheDir));
       await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra9.default.ensureDir(path11.dirname(cacheDir));
+    await import_fs_extra10.default.ensureDir(path13.dirname(cacheDir));
     await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
-  return path11.join(cacheDir, "claude-code-config");
+  for (const candidate of ["ai-config", "claude-code-config"]) {
+    const candidatePath = path13.join(cacheDir, candidate);
+    if (await import_fs_extra10.default.pathExists(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  throw new Error("Premium repo missing config folder (ai-config or claude-code-config)");
 }
-async function copyConfigFromCache(cacheConfigDir, targetDir, onProgress) {
+async function copyConfigFromCache(cacheConfigDir, claudeDir, agentsDir, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra9.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra10.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = path11.join(dir, entry.name);
-      const relativePath = path11.relative(baseDir, sourcePath);
+      const sourcePath = path13.join(dir, entry.name);
+      const relativePath = path13.relative(baseDir, sourcePath);
       if (entry.isDirectory() && entry.name === ".claude" && dir === baseDir) {
         await walk(sourcePath, sourcePath);
         continue;
       }
-      const targetPath = path11.join(targetDir, relativePath);
+      const { base, isAgentTarget } = resolveBaseDir(relativePath, claudeDir, agentsDir);
+      const targetPath = path13.join(base, relativePath);
+      if (isAgentTarget) {
+        const segments = relativePath.split(path13.sep);
+        if (segments.length >= 2) {
+          const claudeTop = path13.join(claudeDir, segments[0], segments[1]);
+          const claudeStat = await import_fs_extra10.default.lstat(claudeTop).catch(() => null);
+          if (claudeStat && !claudeStat.isSymbolicLink()) {
+            onProgress?.(`${relativePath} (skipped - real dir)`, "file");
+            continue;
+          }
+        }
+      }
       if (entry.isDirectory()) {
-        await import_fs_extra9.default.ensureDir(targetPath);
+        await import_fs_extra10.default.ensureDir(targetPath);
         onProgress?.(relativePath, "directory");
         await walk(sourcePath, baseDir);
       } else if (isTextFile(entry.name)) {
-        const content = await import_fs_extra9.default.readFile(sourcePath, "utf-8");
-        const replaced = replaceClaudePathPlaceholder(content, targetDir);
-        await import_fs_extra9.default.ensureDir(path11.dirname(targetPath));
-        await import_fs_extra9.default.writeFile(targetPath, replaced, "utf-8");
+        const content = await import_fs_extra10.default.readFile(sourcePath, "utf-8");
+        const replaced = replaceClaudePathPlaceholder(content, claudeDir);
+        await import_fs_extra10.default.ensureDir(path13.dirname(targetPath));
+        await import_fs_extra10.default.writeFile(targetPath, replaced, "utf-8");
         onProgress?.(relativePath, "file");
       } else {
-        await import_fs_extra9.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra10.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -35081,8 +35186,8 @@ async function downloadFromPrivateGitHub(repo, branch, relativePath, targetPath,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra9.default.ensureDir(path11.dirname(targetPath));
-    await import_fs_extra9.default.writeFile(targetPath, Buffer.from(content));
+    await import_fs_extra10.default.ensureDir(path13.dirname(targetPath));
+    await import_fs_extra10.default.writeFile(targetPath, Buffer.from(content));
     return true;
   } catch (error) {
     console.error(`Error downloading ${relativePath}:`, error);
@@ -35107,11 +35212,11 @@ async function downloadDirectoryFromPrivateGitHub(repo, branch, dirPath, targetD
       console.error(`Unexpected response for directory ${dirPath}`);
       return false;
     }
-    await import_fs_extra9.default.ensureDir(targetDir);
+    await import_fs_extra10.default.ensureDir(targetDir);
     for (const file of files) {
       const relativePath = dirPath ? `${dirPath}/${file.name}` : file.name;
-      const targetPath = path11.join(targetDir, file.name);
-      const displayPath = relativePath.replace("claude-code-config/", "");
+      const targetPath = path13.join(targetDir, file.name);
+      const displayPath = relativePath.replace("ai-config/", "");
       if (file.type === "file") {
         onProgress?.(displayPath, "file");
         await downloadFromPrivateGitHub(repo, branch, relativePath, targetPath, githubToken);
@@ -35126,60 +35231,102 @@ async function downloadDirectoryFromPrivateGitHub(repo, branch, dirPath, targetD
   }
 }
 async function installProConfigs(options) {
-  const { githubToken, claudeCodeFolder, onProgress } = options;
-  const claudeFolder = claudeCodeFolder || path11.join(os12.homedir(), ".claude");
+  const { githubToken, claudeCodeFolder, agentsFolder, onProgress } = options;
+  const claudeFolder = claudeCodeFolder || path13.join(os13.homedir(), ".claude");
+  const agentsDir = getAgentsDir(agentsFolder);
+  await import_fs_extra10.default.ensureDir(claudeFolder);
+  await import_fs_extra10.default.ensureDir(agentsDir);
   try {
     const cacheConfigDir = await cloneOrUpdateRepo(githubToken);
-    await copyConfigFromCache(cacheConfigDir, claudeFolder, onProgress);
+    await copyConfigFromCache(cacheConfigDir, claudeFolder, agentsDir, onProgress);
+    await syncAllAgentSymlinks(agentsDir, claudeFolder);
     return;
   } catch (error) {
     console.warn("Git caching failed, falling back to API download");
   }
-  const tempDir = path11.join(os12.tmpdir(), `aiblueprint-premium-${Date.now()}`);
+  const tempDir = path13.join(os13.tmpdir(), `aiblueprint-premium-${Date.now()}`);
   try {
-    const success = await downloadDirectoryFromPrivateGitHub(PREMIUM_REPO, PREMIUM_BRANCH, "claude-code-config", tempDir, githubToken, onProgress);
+    let success = false;
+    for (const candidate of ["ai-config", "claude-code-config"]) {
+      success = await downloadDirectoryFromPrivateGitHub(PREMIUM_REPO, PREMIUM_BRANCH, candidate, tempDir, githubToken, onProgress);
+      if (success)
+        break;
+    }
     if (!success) {
       throw new Error("Failed to download premium configurations");
     }
-    const dotClaudeDir = path11.join(tempDir, ".claude");
-    if (await import_fs_extra9.default.pathExists(dotClaudeDir)) {
-      await import_fs_extra9.default.copy(dotClaudeDir, tempDir, { overwrite: true });
-      await import_fs_extra9.default.remove(dotClaudeDir);
+    const dotClaudeDir = path13.join(tempDir, ".claude");
+    if (await import_fs_extra10.default.pathExists(dotClaudeDir)) {
+      await import_fs_extra10.default.copy(dotClaudeDir, tempDir, { overwrite: true });
+      await import_fs_extra10.default.remove(dotClaudeDir);
     }
-    await import_fs_extra9.default.copy(tempDir, claudeFolder, {
-      overwrite: true
-    });
+    await copyTreeWithRouting(tempDir, claudeFolder, agentsDir);
+    await replacePathPlaceholdersInDir(claudeFolder, claudeFolder);
+    for (const category of AGENT_CATEGORIES) {
+      const agentsCategoryDir = path13.join(agentsDir, category);
+      if (await import_fs_extra10.default.pathExists(agentsCategoryDir)) {
+        await replacePathPlaceholdersInDir(agentsCategoryDir, claudeFolder);
+      }
+    }
+    await syncAllAgentSymlinks(agentsDir, claudeFolder);
   } catch (error) {
     throw new Error(`Failed to install premium configs: ${error instanceof Error ? error.message : "Unknown error"}`);
   } finally {
     try {
-      await import_fs_extra9.default.remove(tempDir);
+      await import_fs_extra10.default.remove(tempDir);
     } catch {}
   }
 }
+async function copyTreeWithRouting(source, claudeDir, agentsDir) {
+  const entries = await import_fs_extra10.default.readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const src = path13.join(source, entry.name);
+    const { base } = resolveBaseDir(entry.name, claudeDir, agentsDir);
+    const dst = path13.join(base, entry.name);
+    if (entry.isDirectory() && isAgentCategory(entry.name)) {
+      const inner = await import_fs_extra10.default.readdir(src, { withFileTypes: true });
+      for (const innerEntry of inner) {
+        const innerSrc = path13.join(src, innerEntry.name);
+        const innerDst = path13.join(dst, innerEntry.name);
+        const claudeTop = path13.join(claudeDir, entry.name, innerEntry.name);
+        const claudeStat = await import_fs_extra10.default.lstat(claudeTop).catch(() => null);
+        if (claudeStat && !claudeStat.isSymbolicLink())
+          continue;
+        await import_fs_extra10.default.copy(innerSrc, innerDst, { overwrite: true });
+      }
+    } else {
+      await import_fs_extra10.default.copy(src, dst, { overwrite: true });
+    }
+  }
+}
+async function syncAllAgentSymlinks(agentsDir, claudeDir) {
+  for (const category of AGENT_CATEGORIES) {
+    await syncCategorySymlinks(category, agentsDir, claudeDir, undefined, true);
+  }
+}
 
 // src/lib/token-storage.ts
-var import_fs_extra10 = __toESM(require_lib4(), 1);
-import os13 from "os";
-import path12 from "path";
+var import_fs_extra11 = __toESM(require_lib4(), 1);
+import os14 from "os";
+import path14 from "path";
 function getConfigDir() {
-  const platform = os13.platform();
+  const platform = os14.platform();
   if (platform === "win32") {
-    const appData = process.env.APPDATA || path12.join(os13.homedir(), "AppData", "Roaming");
-    return path12.join(appData, "aiblueprint");
+    const appData = process.env.APPDATA || path14.join(os14.homedir(), "AppData", "Roaming");
+    return path14.join(appData, "aiblueprint");
   } else {
-    const configHome = process.env.XDG_CONFIG_HOME || path12.join(os13.homedir(), ".config");
-    return path12.join(configHome, "aiblueprint");
+    const configHome = process.env.XDG_CONFIG_HOME || path14.join(os14.homedir(), ".config");
+    return path14.join(configHome, "aiblueprint");
   }
 }
-function getTokenFilePath() {
-  return path12.join(getConfigDir(), "token.txt");
+function getTokenFilePath2() {
+  return path14.join(getConfigDir(), "token.txt");
 }
 async function saveToken(githubToken) {
-  const tokenFile = getTokenFilePath();
-  const configDir = path12.dirname(tokenFile);
+  const tokenFile = getTokenFilePath2();
+  const configDir = path14.dirname(tokenFile);
   try {
-    await import_fs_extra10.default.ensureDir(configDir);
+    await import_fs_extra11.default.ensureDir(configDir);
   } catch (error) {
     if (error.code === "EACCES") {
       throw new Error(`Permission denied creating config directory: ${configDir}
@@ -35187,15 +35334,15 @@ async function saveToken(githubToken) {
     }
     throw error;
   }
-  await import_fs_extra10.default.writeFile(tokenFile, githubToken, { mode: 384 });
+  await import_fs_extra11.default.writeFile(tokenFile, githubToken, { mode: 384 });
 }
 async function getToken() {
-  const tokenFile = getTokenFilePath();
-  if (!await import_fs_extra10.default.pathExists(tokenFile)) {
+  const tokenFile = getTokenFilePath2();
+  if (!await import_fs_extra11.default.pathExists(tokenFile)) {
     return null;
   }
   try {
-    const token = await import_fs_extra10.default.readFile(tokenFile, "utf-8");
+    const token = await import_fs_extra11.default.readFile(tokenFile, "utf-8");
     return token.trim();
   } catch (error) {
     return null;
@@ -35203,13 +35350,13 @@ async function getToken() {
 }
 function getTokenInfo() {
   return {
-    path: getTokenFilePath(),
-    platform: os13.platform()
+    path: getTokenFilePath2(),
+    platform: os14.platform()
   };
 }
 
 // src/commands/pro.ts
-var import_fs_extra11 = __toESM(require_lib4(), 1);
+var import_fs_extra12 = __toESM(require_lib4(), 1);
 var API_URL = "https://codeline.app/api/products";
 var PRODUCT_IDS = ["prd_XJVgxVPbGG", "prd_NKabAkdOkw"];
 async function countInstalledItems(claudeDir) {
@@ -35219,29 +35366,29 @@ async function countInstalledItems(claudeDir) {
     skills: 0
   };
   try {
-    const commandsDir = path13.join(claudeDir, "commands");
-    if (await import_fs_extra11.default.pathExists(commandsDir)) {
-      const files = await import_fs_extra11.default.readdir(commandsDir);
+    const commandsDir = path15.join(claudeDir, "commands");
+    if (await import_fs_extra12.default.pathExists(commandsDir)) {
+      const files = await import_fs_extra12.default.readdir(commandsDir);
       counts.commands = files.filter((f) => f.endsWith(".md")).length;
     }
   } catch (error) {
     console.error("Failed to count commands:", error instanceof Error ? error.message : error);
   }
   try {
-    const agentsDir = path13.join(claudeDir, "agents");
-    if (await import_fs_extra11.default.pathExists(agentsDir)) {
-      const files = await import_fs_extra11.default.readdir(agentsDir);
+    const agentsDir = path15.join(claudeDir, "agents");
+    if (await import_fs_extra12.default.pathExists(agentsDir)) {
+      const files = await import_fs_extra12.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 = path13.join(claudeDir, "skills");
-    if (await import_fs_extra11.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra11.default.readdir(skillsDir);
+    const skillsDir = path15.join(claudeDir, "skills");
+    if (await import_fs_extra12.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra12.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra11.default.stat(path13.join(skillsDir, item));
+        const stat = await import_fs_extra12.default.stat(path15.join(skillsDir, item));
         return stat.isDirectory();
       }));
       counts.skills = dirs.filter(Boolean).length;
@@ -35357,7 +35504,7 @@ async function proSetupCommand(options = {}) {
       Se(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const claudeDir = options.folder ? path13.resolve(options.folder) : path13.join(os14.homedir(), ".claude");
+    const claudeDir = options.folder ? path15.resolve(options.folder) : path15.join(os15.homedir(), ".claude");
     const spinner = Y2();
     const onProgress = (file, type) => {
       spinner.message(`Installing: ${source_default.cyan(file)} ${source_default.gray(`(${type})`)}`);
@@ -35366,6 +35513,7 @@ async function proSetupCommand(options = {}) {
     await installProConfigs({
       githubToken,
       claudeCodeFolder: claudeDir,
+      agentsFolder: options.agentsFolder,
       onProgress
     });
     spinner.stop("Premium configurations installed");
@@ -35381,12 +35529,10 @@ async function proSetupCommand(options = {}) {
     spinner.start("Updating settings.json...");
     await updateSettings({
       shellShortcuts: false,
-      commandValidation: true,
       customStatusline: true,
       aiblueprintCommands: false,
       aiblueprintAgents: false,
       aiblueprintSkills: false,
-      notificationSounds: true,
       codexSymlink: false,
       openCodeSymlink: false
     }, claudeDir);
@@ -35406,7 +35552,7 @@ async function proSetupCommand(options = {}) {
     M2.info(`  • Premium Skills (${counts.skills})`);
     M2.info("  • Premium statusline (advanced)");
     M2.info("  • Shell shortcuts (cc, ccc)");
-    M2.info("  • Settings.json with hooks and statusline");
+    M2.info("  • Settings.json with statusline");
     Se(source_default.green("\uD83D\uDE80 Ready to use!"));
   } catch (error) {
     trackError(error, { command: "pro-setup" });
@@ -35432,7 +35578,8 @@ async function proUpdateCommand(options = {}) {
     spinner.start("Updating premium configurations...");
     await installProConfigs({
       githubToken,
-      claudeCodeFolder: options.folder
+      claudeCodeFolder: options.folder,
+      agentsFolder: options.agentsFolder
     });
     spinner.stop("Premium configurations updated");
     trackEvent("pro-update");
@@ -35449,12 +35596,12 @@ async function proUpdateCommand(options = {}) {
 }
 
 // src/commands/sync.ts
-import os15 from "os";
-import path15 from "path";
+import os16 from "os";
+import path17 from "path";
 
 // src/lib/sync-utils.ts
-var import_fs_extra12 = __toESM(require_lib4(), 1);
-import path14 from "path";
+var import_fs_extra13 = __toESM(require_lib4(), 1);
+import path16 from "path";
 import crypto from "crypto";
 var PREMIUM_REPO2 = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH2 = "main";
@@ -35464,8 +35611,29 @@ function computeFileSha(content) {
   const fullContent = Buffer.concat([Buffer.from(header), content]);
   return crypto.createHash("sha1").update(fullContent).digest("hex");
 }
+var resolvedConfigFolder = null;
+async function resolveRemoteConfigFolder(githubToken) {
+  if (resolvedConfigFolder)
+    return resolvedConfigFolder;
+  for (const candidate of ["ai-config", "claude-code-config"]) {
+    const apiUrl = `https://api.github.com/repos/${PREMIUM_REPO2}/contents/${candidate}?ref=${PREMIUM_BRANCH2}`;
+    const response = await fetch(apiUrl, {
+      headers: {
+        Authorization: `token ${githubToken}`,
+        Accept: "application/vnd.github.v3+json"
+      }
+    });
+    if (response.ok) {
+      resolvedConfigFolder = candidate;
+      return candidate;
+    }
+  }
+  resolvedConfigFolder = "ai-config";
+  return "ai-config";
+}
 async function listRemoteDirectory(dirPath, githubToken) {
-  const apiUrl = `https://api.github.com/repos/${PREMIUM_REPO2}/contents/claude-code-config/${dirPath}?ref=${PREMIUM_BRANCH2}`;
+  const configFolder = await resolveRemoteConfigFolder(githubToken);
+  const apiUrl = `https://api.github.com/repos/${PREMIUM_REPO2}/contents/${configFolder}/${dirPath}?ref=${PREMIUM_BRANCH2}`;
   const response = await fetch(apiUrl, {
     headers: {
       Authorization: `token ${githubToken}`,
@@ -35503,7 +35671,7 @@ async function listRemoteFilesRecursive(dirPath, githubToken, basePath = "") {
 }
 async function computeLocalFileSha(filePath) {
   try {
-    const content = await import_fs_extra12.default.readFile(filePath);
+    const content = await import_fs_extra13.default.readFile(filePath);
     return computeFileSha(content);
   } catch {
     return null;
@@ -35511,15 +35679,17 @@ async function computeLocalFileSha(filePath) {
 }
 async function listLocalFiles(dir) {
   const files = [];
-  if (!await import_fs_extra12.default.pathExists(dir)) {
+  if (!await import_fs_extra13.default.pathExists(dir)) {
     return files;
   }
-  const items = await import_fs_extra12.default.readdir(dir);
+  const items = await import_fs_extra13.default.readdir(dir);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path14.join(dir, item);
-    const stat = await import_fs_extra12.default.stat(fullPath);
+    const fullPath = path16.join(dir, item);
+    const stat = await import_fs_extra13.default.stat(fullPath).catch(() => null);
+    if (!stat)
+      continue;
     if (stat.isDirectory()) {
       files.push(item);
       const subFiles = await listLocalFilesRecursive(fullPath, item);
@@ -35532,13 +35702,15 @@ async function listLocalFiles(dir) {
 }
 async function listLocalFilesRecursive(dir, basePath) {
   const files = [];
-  const items = await import_fs_extra12.default.readdir(dir);
+  const items = await import_fs_extra13.default.readdir(dir).catch(() => []);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path14.join(dir, item);
+    const fullPath = path16.join(dir, item);
     const relativePath = `${basePath}/${item}`;
-    const stat = await import_fs_extra12.default.stat(fullPath);
+    const stat = await import_fs_extra13.default.stat(fullPath).catch(() => null);
+    if (!stat)
+      continue;
     if (stat.isDirectory()) {
       files.push(relativePath);
       const subFiles = await listLocalFilesRecursive(fullPath, relativePath);
@@ -35549,18 +35721,40 @@ async function listLocalFilesRecursive(dir, basePath) {
   }
   return files;
 }
-async function analyzeCategory(category, claudeDir, githubToken) {
+async function listClaudeRealTopLevel(claudeCategoryDir) {
+  if (!await import_fs_extra13.default.pathExists(claudeCategoryDir))
+    return [];
+  const entries = await import_fs_extra13.default.readdir(claudeCategoryDir).catch(() => []);
+  const real = [];
+  for (const name of entries) {
+    if (name === "node_modules" || name === ".DS_Store")
+      continue;
+    const stat = await import_fs_extra13.default.lstat(path16.join(claudeCategoryDir, name)).catch(() => null);
+    if (!stat)
+      continue;
+    if (stat.isDirectory())
+      real.push(name);
+  }
+  return real;
+}
+async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
   const items = [];
-  const localDir = path14.join(claudeDir, category);
+  const useAgents = isAgentCategory(category);
+  const localBase = useAgents ? agentsDir : claudeDir;
+  const localDir = path16.join(localBase, category);
   const remoteFiles = await listRemoteFilesRecursive(category, githubToken);
   const localFiles = await listLocalFiles(localDir);
   const remoteSet = new Map;
   for (const rf of remoteFiles) {
     remoteSet.set(rf.path, { sha: rf.sha, isFolder: rf.isFolder });
   }
+  const remoteTopLevels = new Set;
+  for (const remotePath of remoteSet.keys()) {
+    remoteTopLevels.add(remotePath.split("/")[0]);
+  }
   const localSet = new Set(localFiles);
   for (const [remotePath, { sha, isFolder }] of remoteSet) {
-    const localPath = path14.join(localDir, remotePath);
+    const localPath = path16.join(localDir, remotePath);
     if (isFolder) {
       continue;
     }
@@ -35590,102 +35784,85 @@ async function analyzeCategory(category, claudeDir, githubToken) {
       }
     }
   }
-  const deletedPaths = new Set;
-  for (const localPath of localSet) {
-    if (!remoteSet.has(localPath)) {
-      const pathParts = localPath.split("/");
-      const parentAlreadyDeleted = pathParts.some((_4, idx) => {
-        if (idx === 0)
-          return false;
-        const parentPath = pathParts.slice(0, idx).join("/");
-        return deletedPaths.has(parentPath);
+  const migrationTopLevels = new Set;
+  if (useAgents) {
+    const agentsTopLevels = new Set;
+    for (const localPath of localSet) {
+      agentsTopLevels.add(localPath.split("/")[0]);
+    }
+    for (const top of agentsTopLevels) {
+      if (remoteTopLevels.has(top))
+        continue;
+      if (migrationTopLevels.has(top))
+        continue;
+      const fullPath = path16.join(localDir, top);
+      const stat = await import_fs_extra13.default.stat(fullPath).catch(() => null);
+      if (!stat)
+        continue;
+      migrationTopLevels.add(top);
+      items.push({
+        name: top,
+        relativePath: `${category}/${top}`,
+        status: "migration",
+        category,
+        isFolder: stat.isDirectory(),
+        migrationKind: "preserve-in-agents"
       });
-      if (parentAlreadyDeleted) {
+    }
+    const claudeCategoryDir = path16.join(claudeDir, category);
+    const claudeRealEntries = await listClaudeRealTopLevel(claudeCategoryDir);
+    for (const top of claudeRealEntries) {
+      if (agentsTopLevels.has(top))
         continue;
-      }
-      const fullPath = path14.join(localDir, localPath);
-      const stat = await import_fs_extra12.default.stat(fullPath).catch(() => null);
-      if (stat) {
-        const isFolder = stat.isDirectory();
-        items.push({
-          name: localPath,
-          relativePath: `${category}/${localPath}`,
-          status: "deleted",
-          category,
-          isFolder
-        });
-        if (isFolder) {
-          deletedPaths.add(localPath);
-        }
-      }
+      if (migrationTopLevels.has(top))
+        continue;
+      migrationTopLevels.add(top);
+      items.push({
+        name: top,
+        relativePath: `${category}/${top}`,
+        status: "migration",
+        category,
+        isFolder: true,
+        migrationKind: "move-from-claude"
+      });
     }
   }
-  return items;
-}
-async function fetchRemoteSettings(githubToken) {
-  try {
-    const url = `https://raw.githubusercontent.com/${PREMIUM_REPO2}/${PREMIUM_BRANCH2}/claude-code-config/settings.json`;
-    const response = await fetch(url, {
-      headers: {
-        Authorization: `token ${githubToken}`,
-        Accept: "application/vnd.github.v3.raw"
-      }
+  const deletedPaths = new Set;
+  for (const localPath of localSet) {
+    if (remoteSet.has(localPath))
+      continue;
+    const topLevel = localPath.split("/")[0];
+    if (migrationTopLevels.has(topLevel))
+      continue;
+    const pathParts = localPath.split("/");
+    const parentAlreadyDeleted = pathParts.some((_4, idx) => {
+      if (idx === 0)
+        return false;
+      const parentPath = pathParts.slice(0, idx).join("/");
+      return deletedPaths.has(parentPath);
     });
-    if (!response.ok) {
-      return null;
-    }
-    return await response.json();
-  } catch {
-    return null;
-  }
-}
-async function getLocalSettings(claudeDir) {
-  const settingsPath = path14.join(claudeDir, "settings.json");
-  try {
-    const content = await import_fs_extra12.default.readFile(settingsPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-function analyzeHooksChanges(remoteSettings, localSettings) {
-  const hookItems = [];
-  if (!remoteSettings?.hooks) {
-    return hookItems;
-  }
-  const localHooks = localSettings?.hooks || {};
-  for (const [hookType, remoteHookArray] of Object.entries(remoteSettings.hooks)) {
-    if (!Array.isArray(remoteHookArray))
+    if (parentAlreadyDeleted) {
       continue;
-    const localHookArray = localHooks[hookType] || [];
-    for (const remoteHook of remoteHookArray) {
-      const matcher = remoteHook.matcher || "";
-      const existingLocal = localHookArray.find((h2) => h2.matcher === matcher);
-      if (!existingLocal) {
-        hookItems.push({
-          hookType,
-          matcher,
-          status: "new",
-          remoteHook
-        });
-      } else {
-        const remoteStr = JSON.stringify(remoteHook);
-        const localStr = JSON.stringify(existingLocal);
-        if (remoteStr !== localStr) {
-          hookItems.push({
-            hookType,
-            matcher,
-            status: "modified",
-            remoteHook,
-            localHook: existingLocal
-          });
-        }
+    }
+    const fullPath = path16.join(localDir, localPath);
+    const stat = await import_fs_extra13.default.stat(fullPath).catch(() => null);
+    if (stat) {
+      const isFolder = stat.isDirectory();
+      items.push({
+        name: localPath,
+        relativePath: `${category}/${localPath}`,
+        status: "deleted",
+        category,
+        isFolder
+      });
+      if (isFolder) {
+        deletedPaths.add(localPath);
       }
     }
   }
-  return hookItems;
+  return items;
 }
-async function analyzeSyncChanges(claudeDir, githubToken) {
+async function analyzeSyncChanges(claudeDir, githubToken, agentsDir) {
   const allItems = [];
   const categories = [
     "commands",
@@ -35694,26 +35871,22 @@ async function analyzeSyncChanges(claudeDir, githubToken) {
     "scripts"
   ];
   for (const category of categories) {
-    const items = await analyzeCategory(category, claudeDir, githubToken);
+    const items = await analyzeCategory(category, claudeDir, agentsDir, githubToken);
     allItems.push(...items);
   }
-  const remoteSettings = await fetchRemoteSettings(githubToken);
-  const localSettings = await getLocalSettings(claudeDir);
-  const hooks = remoteSettings ? analyzeHooksChanges(remoteSettings, localSettings) : [];
-  const hooksNewCount = hooks.filter((h2) => h2.status === "new").length;
-  const hooksModifiedCount = hooks.filter((h2) => h2.status === "modified").length;
   return {
     items: allItems,
-    hooks,
-    newCount: allItems.filter((i) => i.status === "new").length + hooksNewCount,
-    modifiedCount: allItems.filter((i) => i.status === "modified").length + hooksModifiedCount,
+    newCount: allItems.filter((i) => i.status === "new").length,
+    modifiedCount: allItems.filter((i) => i.status === "modified").length,
     deletedCount: allItems.filter((i) => i.status === "deleted").length,
-    unchangedCount: allItems.filter((i) => i.status === "unchanged").length
+    unchangedCount: allItems.filter((i) => i.status === "unchanged").length,
+    migrationCount: allItems.filter((i) => i.status === "migration").length
   };
 }
 async function downloadFromPrivateGitHub2(relativePath, targetPath, githubToken, claudeDir) {
   try {
-    const url = `https://raw.githubusercontent.com/${PREMIUM_REPO2}/${PREMIUM_BRANCH2}/claude-code-config/${relativePath}`;
+    const configFolder = await resolveRemoteConfigFolder(githubToken);
+    const url = `https://raw.githubusercontent.com/${PREMIUM_REPO2}/${PREMIUM_BRANCH2}/${configFolder}/${relativePath}`;
     const response = await fetch(url, {
       headers: {
         Authorization: `token ${githubToken}`,
@@ -35724,68 +35897,83 @@ async function downloadFromPrivateGitHub2(relativePath, targetPath, githubToken,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra12.default.ensureDir(path14.dirname(targetPath));
+    await import_fs_extra13.default.ensureDir(path16.dirname(targetPath));
     if (isTextFile(relativePath)) {
       const textContent = Buffer.from(content).toString("utf-8");
       const transformedContent = transformFileContent(textContent, claudeDir);
-      await import_fs_extra12.default.writeFile(targetPath, transformedContent, "utf-8");
+      await import_fs_extra13.default.writeFile(targetPath, transformedContent, "utf-8");
     } else {
-      await import_fs_extra12.default.writeFile(targetPath, Buffer.from(content));
+      await import_fs_extra13.default.writeFile(targetPath, Buffer.from(content));
     }
     return true;
   } catch {
     return false;
   }
 }
-async function syncSelectedHooks(claudeDir, hooks, onProgress) {
-  if (hooks.length === 0) {
-    return { success: 0, failed: 0 };
-  }
-  const settingsPath = path14.join(claudeDir, "settings.json");
-  let settings = {};
-  try {
-    const content = await import_fs_extra12.default.readFile(settingsPath, "utf-8");
-    settings = JSON.parse(content);
-  } catch {
-    settings = {};
-  }
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
+async function syncSelectedItems(claudeDir, items, githubToken, agentsDir, onProgress) {
   let success = 0;
   let failed = 0;
-  for (const hook of hooks) {
-    onProgress?.(`${hook.hookType}[${hook.matcher || "*"}]`, hook.status === "new" ? "adding" : "updating");
-    try {
-      if (!settings.hooks[hook.hookType]) {
-        settings.hooks[hook.hookType] = [];
+  let deleted = 0;
+  let migrated = 0;
+  const touchedAgentCategories = new Set;
+  for (const item of items) {
+    const useAgents = isAgentCategory(item.category);
+    const baseDir = useAgents ? agentsDir : claudeDir;
+    const targetPath = path16.join(baseDir, item.relativePath);
+    if (item.status === "migration" && useAgents) {
+      const topName = item.name.split("/")[0];
+      const agentsTop = path16.join(agentsDir, item.category, topName);
+      const claudeTop = path16.join(claudeDir, item.category, topName);
+      try {
+        if (item.migrationKind === "move-from-claude") {
+          const claudeStat = await import_fs_extra13.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_extra13.default.pathExists(agentsTop);
+          if (agentsExists) {
+            onProgress?.(item.relativePath, "skipping (already in .agents)");
+            failed++;
+            continue;
+          }
+          onProgress?.(item.relativePath, "moving to .agents");
+          await import_fs_extra13.default.ensureDir(path16.dirname(agentsTop));
+          await import_fs_extra13.default.move(claudeTop, agentsTop);
+        } else {
+          const claudeStat = await import_fs_extra13.default.lstat(claudeTop).catch(() => null);
+          if (claudeStat && !claudeStat.isSymbolicLink()) {
+            onProgress?.(item.relativePath, "skipping (real dir in .claude)");
+            failed++;
+            continue;
+          }
+          onProgress?.(item.relativePath, "preserving in .agents");
+        }
+        migrated++;
+        touchedAgentCategories.add(item.category);
+      } catch {
+        failed++;
       }
-      const existingIndex = settings.hooks[hook.hookType].findIndex((h2) => h2.matcher === hook.matcher);
-      const transformedHook = transformHook(hook.remoteHook, claudeDir);
-      if (existingIndex >= 0) {
-        settings.hooks[hook.hookType][existingIndex] = transformedHook;
-      } else {
-        settings.hooks[hook.hookType].push(transformedHook);
+      continue;
+    }
+    if (useAgents) {
+      const topName = item.name.split("/")[0];
+      const claudeTop = path16.join(claudeDir, item.category, topName);
+      const claudeTopStat = await import_fs_extra13.default.lstat(claudeTop).catch(() => null);
+      if (claudeTopStat && !claudeTopStat.isSymbolicLink()) {
+        onProgress?.(item.relativePath, "skipping (real dir in .claude)");
+        failed++;
+        continue;
       }
-      success++;
-    } catch {
-      failed++;
     }
-  }
-  await import_fs_extra12.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
-  return { success, failed };
-}
-async function syncSelectedItems(claudeDir, items, githubToken, onProgress) {
-  let success = 0;
-  let failed = 0;
-  let deleted = 0;
-  for (const item of items) {
-    const targetPath = path14.join(claudeDir, item.relativePath);
     if (item.status === "deleted") {
       onProgress?.(item.relativePath, "deleting");
       try {
-        await import_fs_extra12.default.remove(targetPath);
+        await import_fs_extra13.default.remove(targetPath);
         deleted++;
+        if (useAgents)
+          touchedAgentCategories.add(item.category);
       } catch {
         failed++;
       }
@@ -35794,12 +35982,19 @@ async function syncSelectedItems(claudeDir, items, githubToken, onProgress) {
       const ok = await downloadFromPrivateGitHub2(item.relativePath, targetPath, githubToken, claudeDir);
       if (ok) {
         success++;
+        if (useAgents)
+          touchedAgentCategories.add(item.category);
       } else {
         failed++;
       }
     }
   }
-  return { success, failed, deleted };
+  for (const category of touchedAgentCategories) {
+    if (isAgentCategory(category)) {
+      await syncCategorySymlinks(category, agentsDir, claudeDir, undefined, true);
+    }
+  }
+  return { success, failed, deleted, migrated };
 }
 
 // src/commands/sync.ts
@@ -35808,16 +36003,19 @@ function formatItem(item) {
     new: "\uD83C\uDD95",
     modified: "\uD83D\uDCDD",
     deleted: "\uD83D\uDDD1️",
-    unchanged: "✅"
+    unchanged: "✅",
+    migration: "\uD83D\uDCE6"
   };
   const colors12 = {
     new: source_default.green,
     modified: source_default.yellow,
     deleted: source_default.red,
-    unchanged: source_default.gray
+    unchanged: source_default.gray,
+    migration: source_default.blue
   };
   const folderPrefix = item.isFolder ? "\uD83D\uDCC1 " : "";
-  return `${icons[item.status]} ${folderPrefix}${colors12[item.status](item.relativePath)}`;
+  const suffix = item.status === "migration" && item.migrationKind === "move-from-claude" ? source_default.gray(" (move .claude → .agents)") : item.status === "migration" ? source_default.gray(" (preserve in .agents)") : "";
+  return `${icons[item.status]} ${folderPrefix}${colors12[item.status](item.relativePath)}${suffix}`;
 }
 function groupByCategory(items) {
   const grouped = new Map;
@@ -35834,7 +36032,13 @@ function aggregateByTopLevelFolder(items) {
     const parts = item.name.split("/");
     const topLevel = parts[0];
     if (!folderMap.has(topLevel)) {
-      folderMap.set(topLevel, { name: topLevel, newCount: 0, modifiedCount: 0, deletedCount: 0 });
+      folderMap.set(topLevel, {
+        name: topLevel,
+        newCount: 0,
+        modifiedCount: 0,
+        deletedCount: 0,
+        migrationCount: 0
+      });
     }
     const summary = folderMap.get(topLevel);
     if (item.status === "new")
@@ -35843,6 +36047,8 @@ function aggregateByTopLevelFolder(items) {
       summary.modifiedCount++;
     else if (item.status === "deleted")
       summary.deletedCount++;
+    else if (item.status === "migration")
+      summary.migrationCount++;
   }
   return Array.from(folderMap.values());
 }
@@ -35854,10 +36060,12 @@ function formatFolderSummary(summary) {
     parts.push(source_default.yellow(`~${summary.modifiedCount}`));
   if (summary.deletedCount > 0)
     parts.push(source_default.red(`-${summary.deletedCount}`));
+  if (summary.migrationCount > 0)
+    parts.push(source_default.blue(`→${summary.migrationCount}`));
   const countStr = parts.length > 0 ? ` (${parts.join(", ")})` : "";
   return `\uD83D\uDCC1 ${summary.name}${countStr}`;
 }
-function createSelectionChoices(changedItems, hooks = []) {
+function createSelectionChoices(changedItems) {
   const choices = [];
   const folderedCategories = ["scripts", "skills"];
   const grouped = groupByCategory(changedItems);
@@ -35880,8 +36088,20 @@ function createSelectionChoices(changedItems, hooks = []) {
       }
     } else {
       for (const item of items) {
-        const icons = { new: "\uD83C\uDD95", modified: "\uD83D\uDCDD", deleted: "\uD83D\uDDD1️", unchanged: "" };
-        const actions = { new: "add", modified: "update", deleted: "remove", unchanged: "" };
+        const icons = {
+          new: "\uD83C\uDD95",
+          modified: "\uD83D\uDCDD",
+          deleted: "\uD83D\uDDD1️",
+          unchanged: "",
+          migration: "\uD83D\uDCE6"
+        };
+        const actions = {
+          new: "add",
+          modified: "update",
+          deleted: "remove",
+          unchanged: "",
+          migration: "migrate"
+        };
         choices.push({
           value: { type: "file", item },
           label: `${icons[item.status]} ${item.relativePath}`,
@@ -35890,16 +36110,6 @@ function createSelectionChoices(changedItems, hooks = []) {
       }
     }
   }
-  for (const hook of hooks) {
-    const icon = hook.status === "new" ? "\uD83C\uDD95" : "\uD83D\uDCDD";
-    const action = hook.status === "new" ? "add" : "update";
-    const matcherDisplay = hook.matcher || "*";
-    choices.push({
-      value: { type: "hook", hook },
-      label: `${icon} settings.json → ${hook.hookType}[${matcherDisplay}]`,
-      hint: action
-    });
-  }
   return choices;
 }
 function formatFolderHint(summary) {
@@ -35910,21 +36120,20 @@ function formatFolderHint(summary) {
     parts.push(`~${summary.modifiedCount}`);
   if (summary.deletedCount > 0)
     parts.push(`-${summary.deletedCount}`);
+  if (summary.migrationCount > 0)
+    parts.push(`→${summary.migrationCount}`);
   return parts.join(", ");
 }
 function expandSelections(selections) {
   const items = [];
-  const hooks = [];
   for (const sel of selections) {
     if (sel.type === "file") {
       items.push(sel.item);
     } else if (sel.type === "folder") {
       items.push(...sel.items);
-    } else if (sel.type === "hook") {
-      hooks.push(sel.hook);
     }
   }
-  return { items, hooks };
+  return { items };
 }
 async function proSyncCommand(options = {}) {
   Ie(source_default.blue(`\uD83D\uDD04 Sync Premium Configurations ${source_default.gray(`v${getVersion()}`)}`));
@@ -35936,19 +36145,28 @@ async function proSyncCommand(options = {}) {
       Se(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const claudeDir = options.folder ? path15.resolve(options.folder) : path15.join(os15.homedir(), ".claude");
+    const claudeDir = options.folder ? path17.resolve(options.folder) : path17.join(os16.homedir(), ".claude");
+    const agentsDir = getAgentsDir(options.agentsFolder);
     const spinner = Y2();
     spinner.start("Analyzing changes...");
-    const result = await analyzeSyncChanges(claudeDir, githubToken);
+    const result = await analyzeSyncChanges(claudeDir, githubToken, agentsDir);
     spinner.stop("Analysis complete");
     const changedItems = result.items.filter((i) => i.status !== "unchanged");
-    const changedHooks = result.hooks;
-    if (changedItems.length === 0 && changedHooks.length === 0) {
+    if (changedItems.length === 0) {
       M2.success("Everything is up to date!");
       Se(source_default.green("✅ No changes needed"));
       return;
     }
-    M2.info(`Found: ${source_default.green(`${result.newCount} new`)}, ${source_default.yellow(`${result.modifiedCount} modified`)}, ${source_default.red(`${result.deletedCount} to remove`)}, ${source_default.gray(`${result.unchangedCount} unchanged`)}`);
+    const summaryParts = [
+      source_default.green(`${result.newCount} new`),
+      source_default.yellow(`${result.modifiedCount} modified`)
+    ];
+    if (result.migrationCount > 0) {
+      summaryParts.push(source_default.blue(`${result.migrationCount} to migrate`));
+    }
+    summaryParts.push(source_default.red(`${result.deletedCount} to remove`));
+    summaryParts.push(source_default.gray(`${result.unchangedCount} unchanged`));
+    M2.info(`Found: ${summaryParts.join(", ")}`);
     M2.message("");
     M2.message(source_default.bold("Changes by category:"));
     const grouped = groupByCategory(changedItems);
@@ -35967,36 +36185,34 @@ async function proSyncCommand(options = {}) {
         }
       }
     }
-    if (changedHooks.length > 0) {
-      M2.message("");
-      M2.message(source_default.cyan.bold(`  SETTINGS (hooks)`));
-      for (const hook of changedHooks) {
-        const icon = hook.status === "new" ? "\uD83C\uDD95" : "\uD83D\uDCDD";
-        const color = hook.status === "new" ? source_default.green : source_default.yellow;
-        const matcherDisplay = hook.matcher || "*";
-        M2.message(`    ${icon} ${color(`${hook.hookType}[${matcherDisplay}]`)}`);
-      }
-    }
     M2.message("");
-    const choices = createSelectionChoices(changedItems, changedHooks);
+    const choices = createSelectionChoices(changedItems);
     const newItems = changedItems.filter((i) => i.status === "new");
     const modifiedItems = changedItems.filter((i) => i.status === "modified");
     const deletedItems = changedItems.filter((i) => i.status === "deleted");
-    const newHooks = changedHooks.filter((h2) => h2.status === "new");
-    const modifiedHooks = changedHooks.filter((h2) => h2.status === "modified");
+    const migrationItems = changedItems.filter((i) => i.status === "migration");
     const hasDeletions = deletedItems.length > 0;
+    const hasMigrations = migrationItems.length > 0;
+    const updatesHintParts = [
+      `add ${newItems.length}`,
+      `update ${modifiedItems.length}`
+    ];
+    if (hasMigrations) {
+      updatesHintParts.push(`migrate ${migrationItems.length}`);
+    }
     const syncModeOptions = [
       {
         value: "updates",
         label: "Import all updates",
-        hint: `add ${newItems.length} + update ${modifiedItems.length} files`
+        hint: `${updatesHintParts.join(" + ")} files`
       }
     ];
     if (hasDeletions) {
+      const deleteHintParts = [...updatesHintParts, `delete ${deletedItems.length}`];
       syncModeOptions.push({
         value: "updates_and_delete",
         label: "Import all updates and delete files",
-        hint: `add ${newItems.length} + update ${modifiedItems.length} + delete ${deletedItems.length} files`
+        hint: `${deleteHintParts.join(" + ")} files`
       });
     }
     syncModeOptions.push({
@@ -36013,16 +36229,17 @@ async function proSyncCommand(options = {}) {
       process.exit(0);
     }
     let selectedItems = [];
-    let selectedHooks = [];
     if (syncMode === "updates") {
-      selectedItems = [...newItems, ...modifiedItems];
+      selectedItems = [...newItems, ...modifiedItems, ...migrationItems];
     } else if (syncMode === "updates_and_delete") {
       M2.message("");
       M2.message(source_default.red.bold("⚠️  WARNING: DESTRUCTIVE ACTION"));
       M2.message(source_default.red("━".repeat(50)));
-      M2.message(source_default.red("All your custom skills, commands, agents, and configuration files"));
-      M2.message(source_default.red("that are not in the premium version will be PERMANENTLY DELETED"));
-      M2.message(source_default.red("and replaced by the new version."));
+      M2.message(source_default.red(`${deletedItems.length} commands/agents/scripts not in the premium version`));
+      M2.message(source_default.red("will be PERMANENTLY DELETED and replaced by the new version."));
+      if (hasMigrations) {
+        M2.message(source_default.gray(`(Skills are NOT deleted - they will be migrated to ~/.agents instead.)`));
+      }
       M2.message(source_default.red("━".repeat(50)));
       M2.message("");
       const deleteConfirm = await ye({
@@ -36033,9 +36250,9 @@ async function proSyncCommand(options = {}) {
         xe("Sync cancelled");
         process.exit(0);
       }
-      selectedItems = [...newItems, ...modifiedItems, ...deletedItems];
+      selectedItems = [...newItems, ...modifiedItems, ...migrationItems, ...deletedItems];
     } else {
-      const fileChoices = choices.filter((c) => c.value.type !== "hook");
+      const fileChoices = choices;
       const nonDeleteChoices = fileChoices.filter((c) => {
         if (c.value.type === "file")
           return c.value.item.status !== "deleted";
@@ -36065,12 +36282,15 @@ async function proSyncCommand(options = {}) {
     const toAdd = selectedItems.filter((i) => i.status === "new").length;
     const toUpdate = selectedItems.filter((i) => i.status === "modified").length;
     const toRemove = selectedItems.filter((i) => i.status === "deleted").length;
+    const toMigrate = selectedItems.filter((i) => i.status === "migration").length;
     M2.message("");
     M2.message(source_default.bold("What will happen:"));
     if (toAdd > 0)
       M2.message(source_default.green(`  ✓ Add ${toAdd} new file${toAdd > 1 ? "s" : ""}`));
     if (toUpdate > 0)
       M2.message(source_default.yellow(`  ✓ Update ${toUpdate} file${toUpdate > 1 ? "s" : ""}`));
+    if (toMigrate > 0)
+      M2.message(source_default.blue(`  ✓ Migrate ${toMigrate} item${toMigrate > 1 ? "s" : ""} to .agents (preserve, no data loss)`));
     if (toRemove > 0)
       M2.message(source_default.red(`  ✓ Delete ${toRemove} file${toRemove > 1 ? "s" : ""}`));
     M2.message(source_default.gray(`  ✓ Backup current config to ~/.config/aiblueprint/backup/`));
@@ -36084,86 +36304,27 @@ async function proSyncCommand(options = {}) {
       process.exit(0);
     }
     spinner.start("Creating backup...");
-    const backupPath = await createBackup(claudeDir);
+    const backupPath = await createBackup(claudeDir, agentsDir);
     if (backupPath) {
       spinner.stop(`Backup created: ${source_default.gray(backupPath)}`);
     } else {
       spinner.stop("No existing config to backup");
     }
     spinner.start("Syncing...");
-    const syncResult = await syncSelectedItems(claudeDir, selectedItems, githubToken, (file, action) => {
+    const syncResult = await syncSelectedItems(claudeDir, selectedItems, githubToken, agentsDir, (file, action) => {
       spinner.message(`${action}: ${source_default.cyan(file)}`);
     });
     spinner.stop("Files synced");
     const results = [];
     if (syncResult.success > 0)
       results.push(source_default.green(`${syncResult.success} added/updated`));
+    if (syncResult.migrated > 0)
+      results.push(source_default.blue(`${syncResult.migrated} migrated`));
     if (syncResult.deleted > 0)
       results.push(source_default.red(`${syncResult.deleted} removed`));
     if (syncResult.failed > 0)
       results.push(source_default.yellow(`${syncResult.failed} failed`));
     M2.success(results.join(", "));
-    if (changedHooks.length > 0) {
-      const hookDescriptions = {
-        Stop: "Play sound when Claude finishes a task",
-        Notification: "Play sound when Claude needs human input",
-        PreToolUse: "Run before Claude uses a tool (e.g., command validation)",
-        PostToolUse: "Run after Claude uses a tool (e.g., auto-format)"
-      };
-      const getHookCommand = (hookData) => {
-        if (hookData?.hooks?.[0]?.command)
-          return hookData.hooks[0].command;
-        if (hookData?.command)
-          return hookData.command;
-        return null;
-      };
-      M2.message("");
-      M2.message(source_default.bold.yellow("⚠️  Settings.json Sync (Optional)"));
-      M2.message(source_default.gray("The following hooks can be synced to your settings.json:"));
-      M2.message("");
-      for (const hook of changedHooks) {
-        const icon = hook.status === "new" ? "\uD83C\uDD95" : "\uD83D\uDCDD";
-        const color = hook.status === "new" ? source_default.green : source_default.yellow;
-        const matcherDisplay = hook.matcher ? `[${hook.matcher}]` : "";
-        const description = hookDescriptions[hook.hookType] || "";
-        M2.message(`  ${icon} ${color(`${hook.hookType}${matcherDisplay}`)} ${source_default.gray(description)}`);
-        const transformedHook = transformHook(hook.remoteHook, claudeDir);
-        const newCommand = getHookCommand(transformedHook);
-        if (hook.status === "modified" && hook.localHook) {
-          const oldCommand = getHookCommand(hook.localHook);
-          if (oldCommand) {
-            M2.message(source_default.red(`     - ${oldCommand}`));
-          }
-        }
-        if (newCommand) {
-          M2.message(source_default.green(`     + ${newCommand}`));
-        }
-        M2.message("");
-      }
-      M2.message(source_default.gray("This will add/update hooks in ~/.claude/settings.json"));
-      M2.message("");
-      const syncSettingsResult = await ye({
-        message: "Do you want to sync these hooks to settings.json?",
-        initialValue: false
-      });
-      if (!pD(syncSettingsResult) && syncSettingsResult) {
-        const spinner2 = Y2();
-        spinner2.start("Syncing hooks to settings.json...");
-        selectedHooks = [...changedHooks];
-        const hooksResult = await syncSelectedHooks(claudeDir, selectedHooks, (hook, action) => {
-          spinner2.message(`${action}: ${source_default.cyan(hook)}`);
-        });
-        spinner2.stop("Hooks synced to settings.json");
-        if (hooksResult.success > 0) {
-          M2.success(source_default.green(`${hooksResult.success} hook${hooksResult.success > 1 ? "s" : ""} synced`));
-        }
-        if (hooksResult.failed > 0) {
-          M2.warn(source_default.yellow(`${hooksResult.failed} hook${hooksResult.failed > 1 ? "s" : ""} failed`));
-        }
-      } else {
-        M2.info(source_default.gray("Skipped settings.json sync"));
-      }
-    }
     const scriptsWereSynced = selectedItems.some((i) => i.category === "scripts");
     if (scriptsWereSynced) {
       spinner.start("Installing scripts dependencies...");
@@ -36172,9 +36333,9 @@ async function proSyncCommand(options = {}) {
     }
     trackEvent("pro-sync", {
       added: syncResult.success,
+      migrated: syncResult.migrated,
       deleted: syncResult.deleted,
-      failed: syncResult.failed,
-      hookssynced: selectedHooks.length
+      failed: syncResult.failed
     });
     Se(source_default.green("✅ Sync completed"));
   } catch (error) {
@@ -36189,8 +36350,8 @@ async function proSyncCommand(options = {}) {
 }
 
 // src/commands/backup.ts
-import os16 from "os";
-import path16 from "path";
+import os17 from "os";
+import path18 from "path";
 function formatBackupDate(date) {
   const now = new Date;
   const diffMs = now.getTime() - date.getTime();
@@ -36210,7 +36371,8 @@ function formatBackupDate(date) {
   return `${date.toLocaleString()} (${relative})`;
 }
 async function backupLoadCommand(options = {}) {
-  const claudeDir = options.folder || path16.join(os16.homedir(), ".claude");
+  const claudeDir = options.folder || path18.join(os17.homedir(), ".claude");
+  const agentsDir = getAgentsDir(options.agentsFolder);
   Ie(source_default.blue("\uD83D\uDCE6 Load Backup"));
   const spinner = Y2();
   spinner.start("Scanning for backups...");
@@ -36246,7 +36408,7 @@ async function backupLoadCommand(options = {}) {
     process.exit(0);
   }
   spinner.start("Creating backup of current configuration...");
-  const currentBackup = await createBackup(claudeDir);
+  const currentBackup = await createBackup(claudeDir, agentsDir);
   if (currentBackup) {
     spinner.stop(`Current config backed up to: ${source_default.gray(currentBackup)}`);
   } else {
@@ -36254,7 +36416,7 @@ async function backupLoadCommand(options = {}) {
   }
   spinner.start("Restoring backup...");
   try {
-    await loadBackup(selected.path, claudeDir);
+    await loadBackup(selected.path, claudeDir, agentsDir);
     spinner.stop("Backup restored successfully");
     M2.success(`Restored configuration from ${source_default.cyan(selected.name)}`);
     Se(source_default.green("✅ Backup loaded successfully"));
@@ -36266,19 +36428,19 @@ async function backupLoadCommand(options = {}) {
 }
 
 // src/commands/openclaw-pro.ts
-import os19 from "os";
-import path19 from "path";
+import os20 from "os";
+import path21 from "path";
 
 // src/lib/openclaw-installer.ts
-var import_fs_extra13 = __toESM(require_lib4(), 1);
-import os17 from "os";
-import path17 from "path";
+var import_fs_extra14 = __toESM(require_lib4(), 1);
+import os18 from "os";
+import path19 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 path17.join(os17.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
+  return path19.join(os18.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
 }
 async function execGitWithAuth2(command, token, repoUrl, cwd) {
   const authenticatedUrl = `https://x-access-token:${token}@${repoUrl.replace(/^https?:\/\//, "")}`;
@@ -36292,33 +36454,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_extra13.default.pathExists(path17.join(cacheDir, ".git"))) {
+  if (await import_fs_extra14.default.pathExists(path19.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth2("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra13.default.remove(cacheDir);
-      await import_fs_extra13.default.ensureDir(path17.dirname(cacheDir));
+      await import_fs_extra14.default.remove(cacheDir);
+      await import_fs_extra14.default.ensureDir(path19.dirname(cacheDir));
       await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra13.default.ensureDir(path17.dirname(cacheDir));
+    await import_fs_extra14.default.ensureDir(path19.dirname(cacheDir));
     await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
-  return path17.join(cacheDir, "openclaw-config");
+  return path19.join(cacheDir, "openclaw-config");
 }
 async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra13.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra14.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = path17.join(dir, entry.name);
-      const relativePath = path17.relative(baseDir, sourcePath);
-      const targetPath = path17.join(targetDir, relativePath);
+      const sourcePath = path19.join(dir, entry.name);
+      const relativePath = path19.relative(baseDir, sourcePath);
+      const targetPath = path19.join(targetDir, relativePath);
       if (entry.isDirectory()) {
-        await import_fs_extra13.default.ensureDir(targetPath);
+        await import_fs_extra14.default.ensureDir(targetPath);
         onProgress?.(relativePath, "directory");
         await walk(sourcePath, baseDir);
       } else {
-        await import_fs_extra13.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra14.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -36327,7 +36489,7 @@ async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
 }
 async function installOpenclawProConfigs(options) {
   const { githubToken, openclawFolder, onProgress } = options;
-  const targetFolder = openclawFolder || path17.join(os17.homedir(), ".openclaw");
+  const targetFolder = openclawFolder || path19.join(os18.homedir(), ".openclaw");
   try {
     const cacheConfigDir = await cloneOrUpdateRepo2(githubToken);
     await copyConfigFromCache2(cacheConfigDir, targetFolder, onProgress);
@@ -36338,28 +36500,28 @@ async function installOpenclawProConfigs(options) {
 }
 
 // src/lib/openclaw-token-storage.ts
-var import_fs_extra14 = __toESM(require_lib4(), 1);
-import os18 from "os";
-import path18 from "path";
+var import_fs_extra15 = __toESM(require_lib4(), 1);
+import os19 from "os";
+import path20 from "path";
 function getConfigDir2() {
-  const platform = os18.platform();
+  const platform = os19.platform();
   if (platform === "win32") {
-    return path18.join(process.env.APPDATA || os18.homedir(), "openclaw");
+    return path20.join(process.env.APPDATA || os19.homedir(), "openclaw");
   }
-  return path18.join(os18.homedir(), ".config", "openclaw");
+  return path20.join(os19.homedir(), ".config", "openclaw");
 }
 function getTokenPath() {
-  return path18.join(getConfigDir2(), "token.txt");
+  return path20.join(getConfigDir2(), "token.txt");
 }
 async function saveOpenclawToken(githubToken) {
   const configDir = getConfigDir2();
-  await import_fs_extra14.default.ensureDir(configDir);
-  await import_fs_extra14.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
+  await import_fs_extra15.default.ensureDir(configDir);
+  await import_fs_extra15.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
 }
 async function getOpenclawToken() {
   const tokenPath = getTokenPath();
-  if (await import_fs_extra14.default.pathExists(tokenPath)) {
-    const token = await import_fs_extra14.default.readFile(tokenPath, "utf8");
+  if (await import_fs_extra15.default.pathExists(tokenPath)) {
+    const token = await import_fs_extra15.default.readFile(tokenPath, "utf8");
     return token.trim();
   }
   return null;
@@ -36367,12 +36529,12 @@ async function getOpenclawToken() {
 function getOpenclawTokenInfo() {
   return {
     path: getTokenPath(),
-    platform: os18.platform()
+    platform: os19.platform()
   };
 }
 
 // src/commands/openclaw-pro.ts
-var import_fs_extra15 = __toESM(require_lib4(), 1);
+var import_fs_extra16 = __toESM(require_lib4(), 1);
 var API_URL2 = "https://codeline.app/api/products";
 var OPENCLAW_PRODUCT_ID = "prd_t2GRwX3aH1";
 var CLAUDE_CODE_TOOLS_INSTRUCTIONS = `
@@ -36479,7 +36641,7 @@ async function openclawProSetupCommand(options = {}) {
       Se(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const openclawDir = options.folder ? path19.resolve(options.folder) : path19.join(os19.homedir(), ".openclaw");
+    const openclawDir = options.folder ? path21.resolve(options.folder) : path21.join(os20.homedir(), ".openclaw");
     const spinner = Y2();
     const onProgress = (file, type) => {
       spinner.message(`Installing: ${source_default.cyan(file)} ${source_default.gray(`(${type})`)}`);
@@ -36492,23 +36654,23 @@ async function openclawProSetupCommand(options = {}) {
     });
     spinner.stop("OpenClaw Pro configurations installed");
     let skillCount = 0;
-    const skillsDir = path19.join(openclawDir, "skills");
-    if (await import_fs_extra15.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra15.default.readdir(skillsDir);
+    const skillsDir = path21.join(openclawDir, "skills");
+    if (await import_fs_extra16.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra16.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra15.default.stat(path19.join(skillsDir, item));
+        const stat = await import_fs_extra16.default.stat(path21.join(skillsDir, item));
         return stat.isDirectory();
       }));
       skillCount = dirs.filter(Boolean).length;
     }
     spinner.start("Setting up workspace TOOLS.md...");
-    const workspaceDir = path19.join(openclawDir, "workspace");
-    const toolsPath = path19.join(workspaceDir, "TOOLS.md");
-    await import_fs_extra15.default.ensureDir(workspaceDir);
-    if (await import_fs_extra15.default.pathExists(toolsPath)) {
-      const existingContent = await import_fs_extra15.default.readFile(toolsPath, "utf-8");
+    const workspaceDir = path21.join(openclawDir, "workspace");
+    const toolsPath = path21.join(workspaceDir, "TOOLS.md");
+    await import_fs_extra16.default.ensureDir(workspaceDir);
+    if (await import_fs_extra16.default.pathExists(toolsPath)) {
+      const existingContent = await import_fs_extra16.default.readFile(toolsPath, "utf-8");
       if (!existingContent.includes("Claude Code CLI")) {
-        await import_fs_extra15.default.appendFile(toolsPath, `
+        await import_fs_extra16.default.appendFile(toolsPath, `
 
 ` + CLAUDE_CODE_TOOLS_INSTRUCTIONS);
         spinner.stop("TOOLS.md updated with Claude Code instructions");
@@ -36522,7 +36684,7 @@ Skills define _how_ tools work. This file is for _your_ specifics — the stuff
 
 ${CLAUDE_CODE_TOOLS_INSTRUCTIONS}
 `;
-      await import_fs_extra15.default.writeFile(toolsPath, defaultToolsMd);
+      await import_fs_extra16.default.writeFile(toolsPath, defaultToolsMd);
       spinner.stop("TOOLS.md created with Claude Code instructions");
     }
     spinner.start("Creating claude-run wrapper...");
@@ -36533,9 +36695,9 @@ ${CLAUDE_CODE_TOOLS_INSTRUCTIONS}
 script -q -c "claude $*" /dev/null
 `;
     const binDir = "/usr/local/bin";
-    const wrapperPath = path19.join(binDir, "claude-run");
+    const wrapperPath = path21.join(binDir, "claude-run");
     try {
-      await import_fs_extra15.default.writeFile(wrapperPath, claudeRunWrapper, { mode: 493 });
+      await import_fs_extra16.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)");
@@ -36584,12 +36746,12 @@ async function openclawProUpdateCommand(options = {}) {
 }
 
 // src/commands/dynamic-scripts.ts
-import path22 from "path";
+import path24 from "path";
 import { homedir } from "os";
 
 // src/lib/script-parser.ts
-var import_fs_extra16 = __toESM(require_lib4(), 1);
-import path20 from "path";
+var import_fs_extra17 = __toESM(require_lib4(), 1);
+import path22 from "path";
 var EXCLUDED_SCRIPTS = ["test", "lint", "format", "start"];
 var EXCLUDED_SUFFIXES = [":test", ":lint", ":test-fixtures", ":start"];
 function shouldIncludeScript(scriptName) {
@@ -36600,12 +36762,12 @@ function shouldIncludeScript(scriptName) {
   return true;
 }
 async function readScriptsPackageJson(claudeDir) {
-  const packageJsonPath = path20.join(claudeDir, "scripts", "package.json");
+  const packageJsonPath = path22.join(claudeDir, "scripts", "package.json");
   try {
-    if (!await import_fs_extra16.default.pathExists(packageJsonPath)) {
+    if (!await import_fs_extra17.default.pathExists(packageJsonPath)) {
       return null;
     }
-    const content = await import_fs_extra16.default.readFile(packageJsonPath, "utf-8");
+    const content = await import_fs_extra17.default.readFile(packageJsonPath, "utf-8");
     const parsed = JSON.parse(content);
     return parsed.scripts || null;
   } catch (error) {
@@ -36649,14 +36811,14 @@ function groupScriptsByPrefix(commands) {
 }
 
 // src/commands/script-runner.ts
-var import_fs_extra17 = __toESM(require_lib4(), 1);
+var import_fs_extra18 = __toESM(require_lib4(), 1);
 import { spawn as spawn2 } from "child_process";
 import { execSync as execSync4 } from "child_process";
-import path21 from "path";
-import os20 from "os";
+import path23 from "path";
+import os21 from "os";
 function checkCommand2(cmd) {
   try {
-    const isWindows2 = os20.platform() === "win32";
+    const isWindows2 = os21.platform() === "win32";
     const whichCmd = isWindows2 ? `where ${cmd}` : `which ${cmd}`;
     execSync4(whichCmd, { stdio: "ignore" });
     return true;
@@ -36682,18 +36844,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 = path21.join(claudeDir, "scripts");
-  if (!await import_fs_extra17.default.pathExists(scriptsDir)) {
+  const scriptsDir = path23.join(claudeDir, "scripts");
+  if (!await import_fs_extra18.default.pathExists(scriptsDir)) {
     console.error(source_default.red(`Scripts directory not found at ${scriptsDir}`));
     console.log(source_default.gray("Run: aiblueprint claude-code setup"));
     return 1;
   }
-  const packageJsonPath = path21.join(scriptsDir, "package.json");
-  if (!await import_fs_extra17.default.pathExists(packageJsonPath)) {
+  const packageJsonPath = path23.join(scriptsDir, "package.json");
+  if (!await import_fs_extra18.default.pathExists(packageJsonPath)) {
     console.error(source_default.red(`package.json not found in ${scriptsDir}`));
     return 1;
   }
-  const packageJson = await import_fs_extra17.default.readJson(packageJsonPath);
+  const packageJson = await import_fs_extra18.default.readJson(packageJsonPath);
   if (!packageJson.scripts || !packageJson.scripts[scriptName]) {
     console.error(source_default.red(`Script "${scriptName}" not found in package.json`));
     return 1;
@@ -36716,7 +36878,7 @@ async function executeScript(scriptName, claudeDir) {
 
 // src/commands/dynamic-scripts.ts
 function getClaudeDir(parentOptions) {
-  return parentOptions.claudeCodeFolder || parentOptions.folder ? path22.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path22.join(homedir(), ".claude");
+  return parentOptions.claudeCodeFolder || parentOptions.folder ? path24.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path24.join(homedir(), ".claude");
 }
 async function registerDynamicScriptCommands(claudeCodeCmd, claudeDir) {
   const scripts = await readScriptsPackageJson(claudeDir);
@@ -36751,13 +36913,14 @@ var __dirname3 = dirname3(fileURLToPath3(import.meta.url));
 var packageJson = JSON.parse(readFileSync3(join2(__dirname3, "../package.json"), "utf8"));
 var program2 = new Command;
 program2.name("aiblueprint").description("AIBlueprint CLI for setting up Claude Code configurations").version(packageJson.version);
-var claudeCodeCmd = program2.command("claude-code").description("Claude Code configuration commands").option("-f, --folder <path>", "Specify custom Claude Code folder path (default: ~/.claude) - alias for --claudeCodeFolder").option("--claudeCodeFolder <path>", "Specify custom Claude Code folder path (default: ~/.claude)").option("--codexFolder <path>", "Specify custom Codex folder path (default: ~/.codex)").option("--openCodeFolder <path>", "Specify custom OpenCode folder path (default: ~/.config/opencode)").option("--factoryAiFolder <path>", "Specify custom FactoryAI folder path (default: ~/.factory)").option("-s, --skip", "Skip interactive prompts and install all features");
+var claudeCodeCmd = program2.command("claude-code").description("Claude Code configuration commands").option("-f, --folder <path>", "Specify custom Claude Code folder path (default: ~/.claude) - alias for --claudeCodeFolder").option("--claudeCodeFolder <path>", "Specify custom Claude Code folder path (default: ~/.claude)").option("--codexFolder <path>", "Specify custom Codex folder path (default: ~/.codex)").option("--openCodeFolder <path>", "Specify custom OpenCode folder path (default: ~/.config/opencode)").option("--factoryAiFolder <path>", "Specify custom FactoryAI folder path (default: ~/.factory)").option("--agentsFolder <path>", "Specify custom agents folder path (default: ~/.agents)").option("-s, --skip", "Skip interactive prompts and install all features");
 claudeCodeCmd.command("setup").description("Setup Claude Code configuration with AIBlueprint defaults").action((options, command) => {
   const parentOptions = command.parent.opts();
   setupCommand({
     claudeCodeFolder: parentOptions.claudeCodeFolder || parentOptions.folder,
     codexFolder: parentOptions.codexFolder,
     openCodeFolder: parentOptions.openCodeFolder,
+    agentsFolder: parentOptions.agentsFolder,
     skipInteractive: parentOptions.skip
   });
 });
@@ -36787,23 +36950,26 @@ proCmd.command("status").description("Check your Premium token status").action((
 proCmd.command("setup").description("Install premium configurations (requires activation)").action((options, command) => {
   const parentOptions = command.parent.parent.opts();
   const claudeCodeFolder = parentOptions.claudeCodeFolder || parentOptions.folder;
-  proSetupCommand({ folder: claudeCodeFolder });
+  proSetupCommand({ folder: claudeCodeFolder, agentsFolder: parentOptions.agentsFolder });
 });
 proCmd.command("update").description("Update premium configurations").action((options, command) => {
   const parentOptions = command.parent.parent.opts();
   const claudeCodeFolder = parentOptions.claudeCodeFolder || parentOptions.folder;
-  proUpdateCommand({ folder: claudeCodeFolder });
+  proUpdateCommand({ folder: claudeCodeFolder, agentsFolder: parentOptions.agentsFolder });
 });
 proCmd.command("sync").description("Sync premium configurations with selective update").action((options, command) => {
   const parentOptions = command.parent.parent.opts();
   const claudeCodeFolder = parentOptions.claudeCodeFolder || parentOptions.folder;
-  proSyncCommand({ folder: claudeCodeFolder });
+  proSyncCommand({ folder: claudeCodeFolder, agentsFolder: parentOptions.agentsFolder });
 });
 var backupCmd = claudeCodeCmd.command("backup").description("Manage Claude Code configuration backups");
 backupCmd.command("load").description("Load a previous backup interactively").action((options, command) => {
   const parentOptions = command.parent.parent.opts();
   const claudeCodeFolder = parentOptions.claudeCodeFolder || parentOptions.folder;
-  backupLoadCommand({ folder: claudeCodeFolder });
+  backupLoadCommand({
+    folder: claudeCodeFolder,
+    agentsFolder: parentOptions.agentsFolder
+  });
 });
 var openclawCmd = program2.command("openclaw").description("OpenClaw configuration commands").option("-f, --folder <path>", "Specify custom OpenClaw folder path (default: ~/.openclaw)");
 var openclawProCmd = openclawCmd.command("pro").description("Manage OpenClaw Pro features");