aiblueprint-cli 1.4.56 → 1.4.57

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 path11 from "path";
-import os11 from "os";
+var import_fs_extra8 = __toESM(require_lib4(), 1);
+import path12 from "path";
+import os10 from "os";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -33051,110 +33051,10 @@ function getVersion() {
   }
 }
 
-// src/lib/backup-utils.ts
+// src/lib/platform.ts
 var import_fs_extra4 = __toESM(require_lib4(), 1);
-import path6 from "path";
 import os6 from "os";
-var BACKUP_BASE_DIR = path6.join(os6.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_extra4.default.pathExists(BACKUP_BASE_DIR);
-  if (!exists) {
-    return [];
-  }
-  const entries = await import_fs_extra4.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: path6.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_extra4.default.copy(sourcePath, destPath, {
-    overwrite: true,
-    dereference: false,
-    filter: async (src) => {
-      try {
-        const stat = await import_fs_extra4.default.lstat(src);
-        return !stat.isSymbolicLink();
-      } catch {
-        return true;
-      }
-    }
-  });
-}
-async function hasMeaningfulContent(dir) {
-  if (!await import_fs_extra4.default.pathExists(dir))
-    return false;
-  const files = await import_fs_extra4.default.readdir(dir);
-  return files.some((f) => f !== ".DS_Store");
-}
-async function loadBackup(backupPath, claudeDir, agentsDir) {
-  const exists = await import_fs_extra4.default.pathExists(backupPath);
-  if (!exists) {
-    throw new Error(`Backup not found: ${backupPath}`);
-  }
-  await import_fs_extra4.default.ensureDir(claudeDir);
-  for (const item of CLAUDE_ITEMS) {
-    const sourcePath = path6.join(backupPath, item);
-    const destPath = path6.join(claudeDir, item);
-    if (await import_fs_extra4.default.pathExists(sourcePath)) {
-      await copyForBackup(sourcePath, destPath);
-    }
-  }
-  if (agentsDir) {
-    const agentsBackupPath = path6.join(backupPath, AGENTS_BACKUP_SUBDIR);
-    if (await import_fs_extra4.default.pathExists(agentsBackupPath)) {
-      await import_fs_extra4.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 = path6.join(BACKUP_BASE_DIR, timestamp);
-  await import_fs_extra4.default.ensureDir(backupPath);
-  if (claudeHasContent) {
-    for (const item of CLAUDE_ITEMS) {
-      const sourcePath = path6.join(claudeDir, item);
-      const destPath = path6.join(backupPath, item);
-      if (await import_fs_extra4.default.pathExists(sourcePath)) {
-        await copyForBackup(sourcePath, destPath);
-      }
-    }
-  }
-  if (agentsHasContent && agentsDir) {
-    const destPath = path6.join(backupPath, AGENTS_BACKUP_SUBDIR);
-    await copyForBackup(agentsDir, destPath);
-  }
-  return backupPath;
-}
-
-// src/lib/platform.ts
-var import_fs_extra5 = __toESM(require_lib4(), 1);
-import os7 from "os";
-import path7 from "path";
+import path6 from "path";
 import { execSync as execSync2 } from "child_process";
 function escapeShellArg(arg) {
   return "'" + arg.replace(/'/g, "'\\''") + "'";
@@ -33162,15 +33062,15 @@ function escapeShellArg(arg) {
 var cachedPlatformInfo = null;
 var cachedAudioPlayer = undefined;
 function isWSL() {
-  if (os7.platform() !== "linux")
+  if (os6.platform() !== "linux")
     return false;
-  const release = os7.release().toLowerCase();
+  const release = os6.release().toLowerCase();
   return release.includes("microsoft") || release.includes("wsl");
 }
 function getPlatformInfo() {
   if (cachedPlatformInfo)
     return cachedPlatformInfo;
-  const platform = os7.platform();
+  const platform = os6.platform();
   const wsl = isWSL();
   cachedPlatformInfo = {
     platform,
@@ -33178,14 +33078,14 @@ function getPlatformInfo() {
     isMacOS: platform === "darwin",
     isLinux: platform === "linux" && !wsl,
     isWSL: wsl,
-    homeDir: os7.homedir()
+    homeDir: os6.homedir()
   };
   return cachedPlatformInfo;
 }
 function detectAudioPlayer() {
   if (cachedAudioPlayer !== undefined)
     return cachedAudioPlayer;
-  const platform = os7.platform();
+  const platform = os6.platform();
   if (platform === "darwin") {
     cachedAudioPlayer = "afplay";
     return cachedAudioPlayer;
@@ -33224,7 +33124,7 @@ function getPlaySoundCommand(soundPath) {
   const player = detectAudioPlayer();
   if (!player)
     return null;
-  const platform = os7.platform();
+  const platform = os6.platform();
   const safePath = escapeShellArg(soundPath);
   if (platform === "darwin") {
     return `afplay -v 0.1 ${safePath}`;
@@ -33307,31 +33207,31 @@ function replaceClaudePathPlaceholder(content, claudeDir) {
   return content.replaceAll("{CLAUDE_PATH}", claudeDir);
 }
 async function replacePathPlaceholdersInDir(dir, claudeDir) {
-  const entries = await import_fs_extra5.default.readdir(dir, { withFileTypes: true });
+  const entries = await import_fs_extra4.default.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path7.join(dir, entry.name);
+    const fullPath = path6.join(dir, entry.name);
     if (entry.isDirectory()) {
       await replacePathPlaceholdersInDir(fullPath, claudeDir);
     } else if (isTextFile(entry.name)) {
-      const content = await import_fs_extra5.default.readFile(fullPath, "utf-8");
+      const content = await import_fs_extra4.default.readFile(fullPath, "utf-8");
       const replaced = replaceClaudePathPlaceholder(content, claudeDir);
       if (replaced !== content) {
-        await import_fs_extra5.default.writeFile(fullPath, replaced, "utf-8");
+        await import_fs_extra4.default.writeFile(fullPath, replaced, "utf-8");
       }
     }
   }
 }
 async function applyPathPlaceholders(target, claudeDir) {
-  const stat = await import_fs_extra5.default.stat(target).catch(() => null);
+  const stat = await import_fs_extra4.default.stat(target).catch(() => null);
   if (!stat)
     return;
   if (stat.isDirectory()) {
     await replacePathPlaceholdersInDir(target, claudeDir);
   } else if (isTextFile(target)) {
-    const content = await import_fs_extra5.default.readFile(target, "utf-8");
+    const content = await import_fs_extra4.default.readFile(target, "utf-8");
     const replaced = replaceClaudePathPlaceholder(content, claudeDir);
     if (replaced !== content) {
-      await import_fs_extra5.default.writeFile(target, replaced, "utf-8");
+      await import_fs_extra4.default.writeFile(target, replaced, "utf-8");
     }
   }
 }
@@ -33360,40 +33260,40 @@ function transformFileContent(content, claudeDir) {
 }
 
 // src/lib/telemetry.ts
-import os8 from "os";
-import fs6 from "fs";
-import path8 from "path";
+import os7 from "os";
+import fs5 from "fs";
+import path7 from "path";
 var TELEMETRY_URL = "https://codelynx.dev/api/cli/events";
 var isDisabled = () => {
   return process.env.AIBLUEPRINT_TELEMETRY_DISABLED === "1";
 };
 var getBasePayload = () => ({
   cliVersion: getVersion(),
-  platform: os8.platform(),
-  arch: os8.arch(),
+  platform: os7.platform(),
+  arch: os7.arch(),
   nodeVersion: process.version
 });
 function getTokenFilePath() {
-  const homeDir = os8.homedir();
-  if (os8.platform() === "win32") {
-    const appData = process.env.APPDATA || path8.join(homeDir, "AppData", "Roaming");
-    return path8.join(appData, "aiblueprint", "token.txt");
+  const homeDir = os7.homedir();
+  if (os7.platform() === "win32") {
+    const appData = process.env.APPDATA || path7.join(homeDir, "AppData", "Roaming");
+    return path7.join(appData, "aiblueprint", "token.txt");
   }
-  const configHome = process.env.XDG_CONFIG_HOME || path8.join(homeDir, ".config");
-  return path8.join(configHome, "aiblueprint", "token.txt");
+  const configHome = process.env.XDG_CONFIG_HOME || path7.join(homeDir, ".config");
+  return path7.join(configHome, "aiblueprint", "token.txt");
 }
 function getSystemInfo() {
   let hasProToken = false;
   try {
-    hasProToken = fs6.existsSync(getTokenFilePath());
+    hasProToken = fs5.existsSync(getTokenFilePath());
   } catch {}
   return {
-    osVersion: os8.release(),
-    osType: os8.type(),
-    totalMemory: `${Math.round(os8.totalmem() / (1024 * 1024 * 1024))}GB`,
-    cpus: os8.cpus().length,
+    osVersion: os7.release(),
+    osType: os7.type(),
+    totalMemory: `${Math.round(os7.totalmem() / (1024 * 1024 * 1024))}GB`,
+    cpus: os7.cpus().length,
     shell: process.env.SHELL || process.env.COMSPEC || "unknown",
-    homeDir: os8.homedir(),
+    homeDir: os7.homedir(),
     locale: process.env.LANG || process.env.LC_ALL || "unknown",
     hasProToken
   };
@@ -33435,28 +33335,28 @@ async function flushTelemetry() {
 }
 
 // src/lib/agents-installer.ts
-var import_fs_extra6 = __toESM(require_lib4(), 1);
-import os9 from "os";
-import path9 from "path";
+var import_fs_extra5 = __toESM(require_lib4(), 1);
+import os8 from "os";
+import path8 from "path";
 var AGENT_CATEGORIES = ["skills", "agents"];
 async function platformSymlink(source, target) {
-  await import_fs_extra6.default.ensureDir(path9.dirname(target));
-  const isWindows2 = os9.platform() === "win32";
-  const sourceStat = await import_fs_extra6.default.stat(source).catch(() => null);
+  await import_fs_extra5.default.ensureDir(path8.dirname(target));
+  const isWindows2 = os8.platform() === "win32";
+  const sourceStat = await import_fs_extra5.default.stat(source).catch(() => null);
   const isDir = sourceStat?.isDirectory() ?? false;
   if (isWindows2 && isDir) {
-    await import_fs_extra6.default.symlink(source, target, "junction");
+    await import_fs_extra5.default.symlink(source, target, "junction");
     return;
   }
   try {
-    await import_fs_extra6.default.symlink(source, target);
+    await import_fs_extra5.default.symlink(source, target);
   } catch (error) {
     if (!isWindows2 || isDir)
       throw error;
     try {
-      await import_fs_extra6.default.link(source, target);
+      await import_fs_extra5.default.link(source, target);
     } catch {
-      await import_fs_extra6.default.copy(source, target, { overwrite: true });
+      await import_fs_extra5.default.copy(source, target, { overwrite: true });
     }
   }
 }
@@ -33467,37 +33367,37 @@ async function installCategoryToAgents(sourceCategoryDir, category, agentsDir, c
     symlinked: [],
     skipped: []
   };
-  if (!await import_fs_extra6.default.pathExists(sourceCategoryDir)) {
+  if (!await import_fs_extra5.default.pathExists(sourceCategoryDir)) {
     return result;
   }
-  const agentsCategoryDir = path9.join(agentsDir, category);
-  await import_fs_extra6.default.ensureDir(agentsCategoryDir);
-  const entries = await import_fs_extra6.default.readdir(sourceCategoryDir, { withFileTypes: true });
+  const agentsCategoryDir = path8.join(agentsDir, category);
+  await import_fs_extra5.default.ensureDir(agentsCategoryDir);
+  const entries = await import_fs_extra5.default.readdir(sourceCategoryDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".DS_Store" || entry.name === "node_modules")
       continue;
-    const sourcePath = path9.join(sourceCategoryDir, entry.name);
-    const agentsTarget = path9.join(agentsCategoryDir, entry.name);
-    const claudeTarget = path9.join(claudeDir, category, entry.name);
-    const agentsExists = await import_fs_extra6.default.pathExists(agentsTarget);
+    const sourcePath = path8.join(sourceCategoryDir, entry.name);
+    const agentsTarget = path8.join(agentsCategoryDir, entry.name);
+    const claudeTarget = path8.join(claudeDir, category, entry.name);
+    const agentsExists = await import_fs_extra5.default.pathExists(agentsTarget);
     if (!agentsExists) {
       let migrated = false;
       if (options.migrateClaudeDirs) {
-        const claudeStat = await import_fs_extra6.default.lstat(claudeTarget).catch(() => null);
+        const claudeStat = await import_fs_extra5.default.lstat(claudeTarget).catch(() => null);
         if (claudeStat && !claudeStat.isSymbolicLink()) {
-          await import_fs_extra6.default.move(claudeTarget, agentsTarget);
+          await import_fs_extra5.default.move(claudeTarget, agentsTarget);
           result.migrated.push(entry.name);
           migrated = true;
         }
       }
       if (!migrated) {
-        await import_fs_extra6.default.copy(sourcePath, agentsTarget, { overwrite: false });
+        await import_fs_extra5.default.copy(sourcePath, agentsTarget, { overwrite: false });
         await applyPathPlaceholders(agentsTarget, claudeDir);
         result.copied.push(entry.name);
       }
     } else if (options.overwrite) {
-      await import_fs_extra6.default.remove(agentsTarget);
-      await import_fs_extra6.default.copy(sourcePath, agentsTarget, { overwrite: false });
+      await import_fs_extra5.default.remove(agentsTarget);
+      await import_fs_extra5.default.copy(sourcePath, agentsTarget, { overwrite: false });
       await applyPathPlaceholders(agentsTarget, claudeDir);
       result.copied.push(entry.name);
     }
@@ -33506,24 +33406,24 @@ async function installCategoryToAgents(sourceCategoryDir, category, agentsDir, c
   return result;
 }
 async function syncCategorySymlinks(category, agentsDir, claudeDir, result, silent = false) {
-  const agentsCategoryDir = path9.join(agentsDir, category);
-  const claudeCategoryDir = path9.join(claudeDir, category);
-  if (!await import_fs_extra6.default.pathExists(agentsCategoryDir)) {
+  const agentsCategoryDir = path8.join(agentsDir, category);
+  const claudeCategoryDir = path8.join(claudeDir, category);
+  if (!await import_fs_extra5.default.pathExists(agentsCategoryDir)) {
     return;
   }
-  await import_fs_extra6.default.ensureDir(claudeCategoryDir);
-  const entries = await import_fs_extra6.default.readdir(agentsCategoryDir, { withFileTypes: true });
+  await import_fs_extra5.default.ensureDir(claudeCategoryDir);
+  const entries = await import_fs_extra5.default.readdir(agentsCategoryDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".DS_Store")
       continue;
-    const agentsTarget = path9.join(agentsCategoryDir, entry.name);
-    const claudeTarget = path9.join(claudeCategoryDir, entry.name);
-    const claudeStat = await import_fs_extra6.default.lstat(claudeTarget).catch(() => null);
+    const agentsTarget = path8.join(agentsCategoryDir, entry.name);
+    const claudeTarget = path8.join(claudeCategoryDir, entry.name);
+    const claudeStat = await import_fs_extra5.default.lstat(claudeTarget).catch(() => null);
     if (!claudeStat) {
       await platformSymlink(agentsTarget, claudeTarget);
       result?.symlinked.push(entry.name);
     } else if (claudeStat.isSymbolicLink()) {
-      await import_fs_extra6.default.remove(claudeTarget);
+      await import_fs_extra5.default.remove(claudeTarget);
       await platformSymlink(agentsTarget, claudeTarget);
       result?.symlinked.push(entry.name);
     } else {
@@ -33534,15 +33434,15 @@ async function syncCategorySymlinks(category, agentsDir, claudeDir, result, sile
       }
     }
   }
-  if (await import_fs_extra6.default.pathExists(claudeCategoryDir)) {
-    const claudeEntries = await import_fs_extra6.default.readdir(claudeCategoryDir, { withFileTypes: true });
+  if (await import_fs_extra5.default.pathExists(claudeCategoryDir)) {
+    const claudeEntries = await import_fs_extra5.default.readdir(claudeCategoryDir, { withFileTypes: true });
     for (const entry of claudeEntries) {
-      const claudeTarget = path9.join(claudeCategoryDir, entry.name);
-      const stat = await import_fs_extra6.default.lstat(claudeTarget).catch(() => null);
+      const claudeTarget = path8.join(claudeCategoryDir, entry.name);
+      const stat = await import_fs_extra5.default.lstat(claudeTarget).catch(() => null);
       if (stat?.isSymbolicLink()) {
-        const exists = await import_fs_extra6.default.pathExists(claudeTarget);
+        const exists = await import_fs_extra5.default.pathExists(claudeTarget);
         if (!exists) {
-          await import_fs_extra6.default.remove(claudeTarget);
+          await import_fs_extra5.default.remove(claudeTarget);
         }
       }
     }
@@ -33553,26 +33453,397 @@ function isAgentCategory(category) {
 }
 
 // src/lib/folder-paths.ts
-import os10 from "os";
-import path10 from "path";
+import os9 from "os";
+import path9 from "path";
 function resolveFolders(options = {}) {
-  const rootDir = options.folder ? path10.resolve(options.folder) : os10.homedir();
-  const claudeDir = options.claudeCodeFolder ? path10.resolve(options.claudeCodeFolder) : path10.join(rootDir, ".claude");
-  const codexDir = options.codexFolder ? path10.resolve(options.codexFolder) : path10.join(rootDir, ".codex");
-  const agentsDir = options.agentsFolder ? path10.resolve(options.agentsFolder) : path10.join(rootDir, ".agents");
+  const rootDir = options.folder ? path9.resolve(options.folder) : os9.homedir();
+  const claudeDir = options.claudeCodeFolder ? path9.resolve(options.claudeCodeFolder) : path9.join(rootDir, ".claude");
+  const codexDir = options.codexFolder ? path9.resolve(options.codexFolder) : path9.join(rootDir, ".codex");
+  const agentsDir = options.agentsFolder ? path9.resolve(options.agentsFolder) : path9.join(rootDir, ".agents");
   return { rootDir, claudeDir, codexDir, agentsDir };
 }
 
+// src/lib/codex-config.ts
+var import_fs_extra6 = __toESM(require_lib4(), 1);
+import path10 from "path";
+var TUI_STATUS_LINE_BLOCK = `status_line = [
+  "model-with-reasoning",
+  "run-state",
+  "project-name",
+  "git-branch",
+  "branch-changes",
+  "context-remaining",
+  "used-tokens",
+  "five-hour-limit",
+  "weekly-limit",
+  "task-progress",
+]
+status_line_use_colors = true`;
+var TUI_SECTION = `[tui]
+${TUI_STATUS_LINE_BLOCK}`;
+function hasTopLevelKey(content, key) {
+  let inSection = false;
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    if (/^\[[^\]]+\]$/.test(trimmed)) {
+      inSection = true;
+      continue;
+    }
+    if (!inSection && (trimmed.startsWith(`${key} `) || trimmed.startsWith(`${key}=`))) {
+      return true;
+    }
+  }
+  return false;
+}
+function getTopLevelAssignments(defaultConfig) {
+  const assignments = [];
+  for (const line of defaultConfig.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    if (/^\[[^\]]+\]$/.test(trimmed))
+      break;
+    if (/^[A-Za-z0-9_-]+\s*=/.test(trimmed)) {
+      assignments.push(line);
+    }
+  }
+  return assignments;
+}
+function findSectionRange(content, sectionName) {
+  const lines = content.split(/\r?\n/);
+  const sectionHeader = `[${sectionName}]`;
+  let start = -1;
+  for (let index = 0;index < lines.length; index += 1) {
+    if (lines[index].trim() === sectionHeader) {
+      start = index;
+      break;
+    }
+  }
+  if (start === -1)
+    return null;
+  let end = lines.length;
+  for (let index = start + 1;index < lines.length; index += 1) {
+    const trimmed = lines[index].trim();
+    if (/^\[[^\]]+\]$/.test(trimmed)) {
+      end = index;
+      break;
+    }
+  }
+  return { start, end };
+}
+function sectionHasKey(content, sectionName, key) {
+  const range = findSectionRange(content, sectionName);
+  if (!range)
+    return false;
+  const lines = content.split(/\r?\n/).slice(range.start + 1, range.end);
+  return lines.some((line) => {
+    const trimmed = line.trim();
+    return trimmed.startsWith(`${key} `) || trimmed.startsWith(`${key}=`);
+  });
+}
+function appendBlock(content, block) {
+  const normalized = content.trimEnd();
+  if (!normalized)
+    return `${block}
+`;
+  return `${normalized}
+
+${block}
+`;
+}
+function mergeCodexConfig(existingConfig, defaultConfig) {
+  let merged = existingConfig.trimEnd();
+  for (const assignment of getTopLevelAssignments(defaultConfig)) {
+    const key = assignment.split("=")[0].trim();
+    if (!hasTopLevelKey(merged, key)) {
+      merged = appendBlock(merged, assignment);
+    }
+  }
+  if (sectionHasKey(merged, "tui", "status_line")) {
+    return `${merged}
+`;
+  }
+  const tuiRange = findSectionRange(merged, "tui");
+  if (!tuiRange) {
+    return appendBlock(merged, TUI_SECTION);
+  }
+  const lines = merged.split(/\r?\n/);
+  lines.splice(tuiRange.start + 1, 0, TUI_STATUS_LINE_BLOCK);
+  return `${lines.join(`
+`).trimEnd()}
+`;
+}
+async function mergeCodexConfigFile(sourceConfigPath, codexDir) {
+  const targetConfigPath = path10.join(codexDir, "config.toml");
+  const defaultConfig = await import_fs_extra6.default.readFile(sourceConfigPath, "utf-8");
+  const existingConfig = await import_fs_extra6.default.readFile(targetConfigPath, "utf-8").catch(() => "");
+  const merged = mergeCodexConfig(existingConfig, defaultConfig);
+  await import_fs_extra6.default.ensureDir(codexDir);
+  await import_fs_extra6.default.writeFile(targetConfigPath, merged, "utf-8");
+}
+
+// src/lib/configs-store.ts
+var import_fs_extra7 = __toESM(require_lib4(), 1);
+import path11 from "path";
+function getConfigStorePaths(rootDir) {
+  const baseDir = path11.join(rootDir, ".aiblueprint");
+  return {
+    baseDir,
+    configsDir: path11.join(baseDir, "configs"),
+    backupsDir: path11.join(baseDir, "backups"),
+    historyPath: path11.join(baseDir, "history.jsonl")
+  };
+}
+function resolveConfigStoreFolders(options = {}) {
+  return resolveFolders(options);
+}
+function timestamp(date = new 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())
+  ].join("-");
+}
+function sanitizeSnapshotName(name) {
+  const sanitized = name.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  if (!sanitized) {
+    throw new Error("Snapshot name cannot be empty");
+  }
+  if (sanitized === "." || sanitized === ".." || sanitized.includes("..")) {
+    throw new Error("Snapshot name is not allowed");
+  }
+  return sanitized;
+}
+function managedFolders(folders) {
+  return [
+    { name: ".claude", path: folders.claudeDir },
+    { name: ".codex", path: folders.codexDir },
+    { name: ".agents", path: folders.agentsDir }
+  ];
+}
+async function hasContent(folderPath) {
+  if (!await import_fs_extra7.default.pathExists(folderPath))
+    return false;
+  const entries = await import_fs_extra7.default.readdir(folderPath);
+  return entries.some((entry) => entry !== ".DS_Store");
+}
+async function copyManagedFolder(source, destination) {
+  await import_fs_extra7.default.copy(source, destination, {
+    overwrite: true,
+    dereference: false,
+    filter: async (src) => {
+      try {
+        const stat = await import_fs_extra7.default.lstat(src);
+        return !stat.isSymbolicLink();
+      } catch {
+        return true;
+      }
+    }
+  });
+}
+async function writeMetadata(snapshotPath, metadata) {
+  await import_fs_extra7.default.writeJson(path11.join(snapshotPath, "metadata.json"), metadata, { spaces: 2 });
+}
+async function readMetadata(snapshotPath, fallbackType) {
+  const metadataPath = path11.join(snapshotPath, "metadata.json");
+  if (await import_fs_extra7.default.pathExists(metadataPath)) {
+    return import_fs_extra7.default.readJson(metadataPath);
+  }
+  const name = path11.basename(snapshotPath);
+  return {
+    name,
+    type: fallbackType,
+    createdAt: new Date(0).toISOString(),
+    reason: "Legacy snapshot without metadata",
+    trigger: "legacy",
+    folders: []
+  };
+}
+async function appendHistory(paths, event) {
+  await import_fs_extra7.default.ensureDir(paths.baseDir);
+  await import_fs_extra7.default.appendFile(paths.historyPath, `${JSON.stringify({ at: new Date().toISOString(), ...event })}
+`);
+}
+async function snapshotByCopy(snapshotPath, folders, metadata) {
+  const copied = [];
+  await import_fs_extra7.default.ensureDir(snapshotPath);
+  for (const folder of managedFolders(folders)) {
+    if (!await hasContent(folder.path))
+      continue;
+    await copyManagedFolder(folder.path, path11.join(snapshotPath, folder.name));
+    copied.push(folder.name);
+  }
+  if (copied.length === 0) {
+    await import_fs_extra7.default.remove(snapshotPath);
+    return null;
+  }
+  await writeMetadata(snapshotPath, { ...metadata, folders: copied });
+  return snapshotPath;
+}
+async function saveNamedConfig(name, options = {}) {
+  const folders = resolveConfigStoreFolders(options);
+  const paths = getConfigStorePaths(folders.rootDir);
+  const safeName = sanitizeSnapshotName(name);
+  const snapshotPath = path11.join(paths.configsDir, safeName);
+  if (await import_fs_extra7.default.pathExists(snapshotPath) && !options.force) {
+    throw new Error(`Config "${safeName}" already exists. Use --force to overwrite it.`);
+  }
+  if (await import_fs_extra7.default.pathExists(snapshotPath)) {
+    const backupName = `${timestamp()}-replace-saved-${safeName}`;
+    await import_fs_extra7.default.ensureDir(paths.backupsDir);
+    await import_fs_extra7.default.move(snapshotPath, path11.join(paths.backupsDir, backupName), { overwrite: false });
+  }
+  const result = await snapshotByCopy(snapshotPath, folders, {
+    name: safeName,
+    type: "config",
+    createdAt: new Date().toISOString(),
+    reason: `Manual save as "${safeName}"`,
+    trigger: "save",
+    folders: []
+  });
+  if (!result) {
+    throw new Error("No .claude, .codex, or .agents configuration found to save.");
+  }
+  await appendHistory(paths, { action: "save", name: safeName, path: result });
+  return result;
+}
+async function createConfigBackup(options = {}, reason = "Backup current configuration", trigger = "manual", source) {
+  const folders = resolveConfigStoreFolders(options);
+  const paths = getConfigStorePaths(folders.rootDir);
+  const safeSource = source ? sanitizeSnapshotName(source) : trigger;
+  const name = `${timestamp()}-${safeSource}`;
+  const snapshotPath = path11.join(paths.backupsDir, name);
+  const result = await snapshotByCopy(snapshotPath, folders, {
+    name,
+    type: "backup",
+    createdAt: new Date().toISOString(),
+    reason,
+    trigger,
+    source,
+    folders: []
+  });
+  if (result) {
+    await appendHistory(paths, { action: "backup", name, reason, trigger, source, path: result });
+  }
+  return result;
+}
+async function backupCurrentByMove(folders, reason, trigger, source) {
+  const paths = getConfigStorePaths(folders.rootDir);
+  const safeSource = source ? sanitizeSnapshotName(source) : trigger;
+  const name = `${timestamp()}-${safeSource}`;
+  const backupPath = path11.join(paths.backupsDir, name);
+  const moved = [];
+  await import_fs_extra7.default.ensureDir(backupPath);
+  for (const folder of managedFolders(folders)) {
+    if (!await hasContent(folder.path))
+      continue;
+    await import_fs_extra7.default.move(folder.path, path11.join(backupPath, folder.name), { overwrite: false });
+    moved.push(folder.name);
+  }
+  if (moved.length === 0) {
+    await import_fs_extra7.default.remove(backupPath);
+    return null;
+  }
+  await writeMetadata(backupPath, {
+    name,
+    type: "backup",
+    createdAt: new Date().toISOString(),
+    reason,
+    trigger,
+    source,
+    folders: moved
+  });
+  await appendHistory(paths, { action: "backup", name, reason, trigger, source, path: backupPath });
+  return backupPath;
+}
+async function restoreSnapshot(snapshotPath, folders) {
+  const restored = [];
+  for (const folder of managedFolders(folders)) {
+    const source = path11.join(snapshotPath, folder.name);
+    if (!await import_fs_extra7.default.pathExists(source))
+      continue;
+    await import_fs_extra7.default.ensureDir(path11.dirname(folder.path));
+    await copyManagedFolder(source, folder.path);
+    restored.push(folder.name);
+  }
+  return restored;
+}
+async function loadNamedConfig(name, options = {}) {
+  const folders = resolveConfigStoreFolders(options);
+  const paths = getConfigStorePaths(folders.rootDir);
+  const safeName = sanitizeSnapshotName(name);
+  const snapshotPath = path11.join(paths.configsDir, safeName);
+  if (!await import_fs_extra7.default.pathExists(snapshotPath)) {
+    throw new Error(`Saved config not found: ${safeName}`);
+  }
+  const backupPath = await backupCurrentByMove(folders, `Before loading saved config "${safeName}"`, "load", safeName);
+  const restored = await restoreSnapshot(snapshotPath, folders);
+  await appendHistory(paths, { action: "load", name: safeName, backupPath, restored });
+  return { backupPath, restored };
+}
+async function loadBackupSnapshot(name, options = {}) {
+  const folders = resolveConfigStoreFolders(options);
+  const paths = getConfigStorePaths(folders.rootDir);
+  const safeName = sanitizeSnapshotName(name);
+  const snapshotPath = path11.join(paths.backupsDir, safeName);
+  if (!await import_fs_extra7.default.pathExists(snapshotPath)) {
+    throw new Error(`Backup not found: ${safeName}`);
+  }
+  const backupPath = await backupCurrentByMove(folders, `Before restoring backup "${safeName}"`, "backup-load", safeName);
+  const restored = await restoreSnapshot(snapshotPath, folders);
+  await appendHistory(paths, { action: "backup-load", name: safeName, backupPath, restored });
+  return { backupPath, restored };
+}
+async function undoLastLoad(options = {}) {
+  const backups = await listConfigBackups(options);
+  const lastLoadBackup = backups.find((backup) => backup.metadata.trigger === "load" || backup.metadata.trigger === "backup-load");
+  if (!lastLoadBackup) {
+    throw new Error("No load backup found to undo.");
+  }
+  const result = await loadBackupSnapshot(lastLoadBackup.name, options);
+  return { backupName: lastLoadBackup.name, ...result };
+}
+async function listSnapshots(dir, type) {
+  if (!await import_fs_extra7.default.pathExists(dir))
+    return [];
+  const entries = await import_fs_extra7.default.readdir(dir, { withFileTypes: true });
+  const snapshots = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const snapshotPath = path11.join(dir, entry.name);
+    const metadata = await readMetadata(snapshotPath, type);
+    snapshots.push({ name: entry.name, path: snapshotPath, metadata });
+  }
+  return snapshots.sort((a, b) => b.metadata.createdAt.localeCompare(a.metadata.createdAt));
+}
+async function listSavedConfigs(options = {}) {
+  const folders = resolveConfigStoreFolders(options);
+  const paths = getConfigStorePaths(folders.rootDir);
+  return listSnapshots(paths.configsDir, "config");
+}
+async function listConfigBackups(options = {}) {
+  const folders = resolveConfigStoreFolders(options);
+  const paths = getConfigStorePaths(folders.rootDir);
+  return listSnapshots(paths.backupsDir, "backup");
+}
+
 // src/commands/setup.ts
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
 async function resolveClaudeAssetPath(sourceDir, name) {
   const candidates = [
-    path11.join(sourceDir, "claude-config", name),
-    path11.join(sourceDir, name)
+    path12.join(sourceDir, "claude-config", name),
+    path12.join(sourceDir, name)
   ];
   for (const candidate of candidates) {
-    if (await import_fs_extra7.default.pathExists(candidate))
+    if (await import_fs_extra8.default.pathExists(candidate))
       return candidate;
   }
   return null;
@@ -33660,10 +33931,10 @@ async function setupCommand(params = {}) {
     console.log(source_default.gray(`Claude:  ${claudeDir}`));
     console.log(source_default.gray(`Codex:   ${codexDir}`));
     console.log(source_default.gray(`Agents:  ${agentsDir}`));
-    await import_fs_extra7.default.ensureDir(claudeDir);
-    await import_fs_extra7.default.ensureDir(agentsDir);
+    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, agentsDir);
+    const backupPath = await createConfigBackup({ folder, claudeCodeFolder, codexFolder, agentsFolder }, "Before running aiblueprint setup", "setup", "aiblueprint-setup");
     if (backupPath) {
       s.stop(`Backup created: ${source_default.gray(backupPath)}`);
     } else {
@@ -33689,11 +33960,11 @@ async function setupCommand(params = {}) {
       s.start("Setting up scripts");
       const scriptsSource = await resolveClaudeAssetPath(sourceDir, "scripts");
       if (scriptsSource) {
-        await import_fs_extra7.default.copy(scriptsSource, path11.join(claudeDir, "scripts"), {
+        await import_fs_extra8.default.copy(scriptsSource, path12.join(claudeDir, "scripts"), {
           overwrite: true
         });
-        await replacePathPlaceholdersInDir(path11.join(claudeDir, "scripts"), claudeDir);
-        await import_fs_extra7.default.ensureDir(path11.join(claudeDir, "scripts/statusline/data"));
+        await replacePathPlaceholdersInDir(path12.join(claudeDir, "scripts"), claudeDir);
+        await import_fs_extra8.default.ensureDir(path12.join(claudeDir, "scripts/statusline/data"));
         s.stop("Scripts installed");
       } else {
         s.stop("Scripts not available in repository");
@@ -33701,8 +33972,8 @@ async function setupCommand(params = {}) {
     }
     if (options.aiblueprintAgents) {
       s.start("Setting up AIBlueprint agents");
-      const agentsSource = path11.join(sourceDir, "agents");
-      if (await import_fs_extra7.default.pathExists(agentsSource)) {
+      const agentsSource = path12.join(sourceDir, "agents");
+      if (await import_fs_extra8.default.pathExists(agentsSource)) {
         const installResult = await installCategoryToAgents(agentsSource, "agents", agentsDir, claudeDir, { migrateClaudeDirs: true, silent: true });
         const summary = [
           installResult.copied.length && `${installResult.copied.length} copied`,
@@ -33717,8 +33988,8 @@ async function setupCommand(params = {}) {
     }
     if (options.aiblueprintSkills) {
       s.start("Setting up AIBlueprint Skills");
-      const skillsSourcePath = path11.join(sourceDir, "skills");
-      if (await import_fs_extra7.default.pathExists(skillsSourcePath)) {
+      const skillsSourcePath = path12.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`,
@@ -33738,10 +34009,21 @@ async function setupCommand(params = {}) {
     }
     if (options.installCodex) {
       s.start("Setting up Codex");
-      await import_fs_extra7.default.ensureDir(codexDir);
-      const codexConfigSource = path11.join(sourceDir, "codex-config");
-      if (await import_fs_extra7.default.pathExists(codexConfigSource)) {
-        await import_fs_extra7.default.copy(codexConfigSource, codexDir, { overwrite: false });
+      await import_fs_extra8.default.ensureDir(codexDir);
+      const codexConfigSource = path12.join(sourceDir, "codex-config");
+      if (await import_fs_extra8.default.pathExists(codexConfigSource)) {
+        const codexConfigPath = path12.join(codexConfigSource, "config.toml");
+        if (await import_fs_extra8.default.pathExists(codexConfigPath)) {
+          await mergeCodexConfigFile(codexConfigPath, codexDir);
+        }
+        const entries = await import_fs_extra8.default.readdir(codexConfigSource);
+        for (const entry of entries) {
+          if (entry === "config.toml")
+            continue;
+          await import_fs_extra8.default.copy(path12.join(codexConfigSource, entry), path12.join(codexDir, entry), {
+            overwrite: false
+          });
+        }
       }
       if (options.aiblueprintSkills) {
         await syncCategorySymlinks("skills", agentsDir, codexDir, undefined, true);
@@ -33787,7 +34069,7 @@ async function setupCommand(params = {}) {
     console.log(source_default.gray(`
 Next steps:`));
     if (options.shellShortcuts) {
-      const platform = os11.platform();
+      const platform = os10.platform();
       if (platform === "win32") {
         console.log(source_default.gray("  • Restart PowerShell to load the new functions"));
       } else {
@@ -33813,9 +34095,9 @@ Next steps:`));
 }
 
 // src/commands/setup-terminal.ts
-var import_fs_extra8 = __toESM(require_lib4(), 1);
-import path12 from "path";
-import os12 from "os";
+var import_fs_extra9 = __toESM(require_lib4(), 1);
+import path13 from "path";
+import os11 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;
@@ -33849,16 +34131,16 @@ function commandExists(cmd) {
   }
 }
 function isOhMyZshInstalled(homeDir) {
-  const ohMyZshDir = path12.join(homeDir, ".oh-my-zsh");
-  return import_fs_extra8.default.existsSync(ohMyZshDir);
+  const ohMyZshDir = path13.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}`;
+  const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${filePath}.backup-${timestamp2}`;
   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}`);
@@ -33897,7 +34179,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: path12.join(homeDir, ".oh-my-zsh") };
+    const env2 = { ...process.env, HOME: homeDir, ZSH: path13.join(homeDir, ".oh-my-zsh") };
     exec2(installCmd, { timeout: INSTALL_TIMEOUT, env: env2 }, (error, stdout, stderr) => {
       if (error) {
         if ("killed" in error && error.killed) {
@@ -33918,8 +34200,8 @@ async function installPlugin(pluginName, repoUrl, homeDir) {
   if (!/^https:\/\/github\.com\/[\w-]+\/[\w-]+$/.test(repoUrl)) {
     throw new Error(`Invalid repository URL: ${repoUrl}`);
   }
-  const customPluginsDir = path12.join(homeDir, ".oh-my-zsh/custom/plugins", pluginName);
-  if (import_fs_extra8.default.existsSync(customPluginsDir)) {
+  const customPluginsDir = path13.join(homeDir, ".oh-my-zsh/custom/plugins", pluginName);
+  if (import_fs_extra9.default.existsSync(customPluginsDir)) {
     return;
   }
   return new Promise((resolve, reject) => {
@@ -33937,20 +34219,20 @@ async function installPlugin(pluginName, repoUrl, homeDir) {
   });
 }
 function updateZshrcTheme(theme, homeDir) {
-  const zshrcPath = path12.join(homeDir, ".zshrc");
+  const zshrcPath = path13.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;
@@ -33959,12 +34241,12 @@ ${content}`;
   }
 }
 function updateZshrcPlugins(plugins, homeDir) {
-  const zshrcPath = path12.join(homeDir, ".zshrc");
-  if (!import_fs_extra8.default.existsSync(zshrcPath)) {
+  const zshrcPath = path13.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})`);
@@ -33972,7 +34254,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;
@@ -33982,7 +34264,7 @@ plugins=(${pluginsString})`;
 }
 async function setupTerminalCommand(options = {}) {
   const { skipInteractive, homeDir: customHomeDir } = options;
-  const homeDir = customHomeDir || os12.homedir();
+  const homeDir = customHomeDir || os11.homedir();
   try {
     console.log(source_default.blue.bold(`
 \uD83D\uDDA5️  AIBlueprint Terminal Setup ${source_default.gray(`v${getVersion()}`)}
@@ -34079,8 +34361,8 @@ Installing missing prerequisites: ${missingPrereqs.join(", ")}`));
         selectedTheme = themeAnswer.theme;
       }
     }
-    const zshrcPath = path12.join(homeDir, ".zshrc");
-    if (import_fs_extra8.default.existsSync(zshrcPath)) {
+    const zshrcPath = path13.join(homeDir, ".zshrc");
+    if (import_fs_extra9.default.existsSync(zshrcPath)) {
       s.start("Backing up .zshrc");
       const backupPath = backupFile(zshrcPath);
       if (backupPath) {
@@ -34130,37 +34412,37 @@ Next steps:`));
 }
 
 // src/commands/setup/symlinks.ts
-var import_fs_extra9 = __toESM(require_lib4(), 1);
-import path13 from "path";
-import os13 from "os";
+var import_fs_extra10 = __toESM(require_lib4(), 1);
+import path14 from "path";
+import os12 from "os";
 async function getToolPaths(tool, customFolder) {
   let baseDir;
   switch (tool) {
     case "claude-code":
-      baseDir = customFolder ? path13.resolve(customFolder) : path13.join(os13.homedir(), ".claude");
+      baseDir = customFolder ? path14.resolve(customFolder) : path14.join(os12.homedir(), ".claude");
       return {
         baseDir,
-        commandsPath: path13.join(baseDir, "commands"),
-        agentsPath: path13.join(baseDir, "agents")
+        commandsPath: path14.join(baseDir, "commands"),
+        agentsPath: path14.join(baseDir, "agents")
       };
     case "codex":
-      baseDir = customFolder ? path13.resolve(customFolder) : path13.join(os13.homedir(), ".codex");
+      baseDir = customFolder ? path14.resolve(customFolder) : path14.join(os12.homedir(), ".codex");
       return {
         baseDir,
-        agentsPath: path13.join(baseDir, "agents")
+        agentsPath: path14.join(baseDir, "agents")
       };
     case "opencode":
-      baseDir = customFolder ? path13.resolve(customFolder) : path13.join(os13.homedir(), ".config", "opencode");
+      baseDir = customFolder ? path14.resolve(customFolder) : path14.join(os12.homedir(), ".config", "opencode");
       return {
         baseDir,
-        commandsPath: path13.join(baseDir, "command")
+        commandsPath: path14.join(baseDir, "command")
       };
     case "factoryai":
-      baseDir = customFolder ? path13.resolve(customFolder) : path13.join(os13.homedir(), ".factory");
+      baseDir = customFolder ? path14.resolve(customFolder) : path14.join(os12.homedir(), ".factory");
       return {
         baseDir,
-        commandsPath: path13.join(baseDir, "commands"),
-        agentsPath: path13.join(baseDir, "droids")
+        commandsPath: path14.join(baseDir, "commands"),
+        agentsPath: path14.join(baseDir, "droids")
       };
     default:
       throw new Error(`Unknown tool type: ${tool}`);
@@ -34168,28 +34450,28 @@ async function getToolPaths(tool, customFolder) {
 }
 async function createSymlink(sourcePath, targetPath, options = {}) {
   try {
-    const sourceExists = await import_fs_extra9.default.pathExists(sourcePath);
+    const sourceExists = await import_fs_extra10.default.pathExists(sourcePath);
     if (!sourceExists) {
       console.log(source_default.yellow(`  Source path ${sourcePath} does not exist. Skipping symlink creation...`));
       return false;
     }
-    const targetDir = path13.dirname(targetPath);
-    await import_fs_extra9.default.ensureDir(targetDir);
-    const targetExists = await import_fs_extra9.default.pathExists(targetPath);
+    const targetDir = path14.dirname(targetPath);
+    await import_fs_extra10.default.ensureDir(targetDir);
+    const targetExists = await import_fs_extra10.default.pathExists(targetPath);
     if (targetExists) {
-      const stat = await import_fs_extra9.default.lstat(targetPath);
+      const stat = await import_fs_extra10.default.lstat(targetPath);
       if (stat.isSymbolicLink()) {
-        await import_fs_extra9.default.remove(targetPath);
+        await import_fs_extra10.default.remove(targetPath);
       } else {
         console.log(source_default.yellow(options.skipMessage || `  ${targetPath} already exists and is not a symlink. Skipping...`));
         return false;
       }
     }
-    const isWindows2 = os13.platform() === "win32";
+    const isWindows2 = os12.platform() === "win32";
     if (isWindows2) {
-      await import_fs_extra9.default.symlink(sourcePath, targetPath, "junction");
+      await import_fs_extra10.default.symlink(sourcePath, targetPath, "junction");
     } else {
-      await import_fs_extra9.default.symlink(sourcePath, targetPath);
+      await import_fs_extra10.default.symlink(sourcePath, targetPath);
     }
     return true;
   } catch (error) {
@@ -35085,12 +35367,12 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 };
 
 // src/commands/pro.ts
-import path16 from "path";
+import path17 from "path";
 
 // src/lib/pro-installer.ts
-var import_fs_extra10 = __toESM(require_lib4(), 1);
-import os14 from "os";
-import path14 from "path";
+var import_fs_extra11 = __toESM(require_lib4(), 1);
+import os13 from "os";
+import path15 from "path";
 import { exec as exec3 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec3);
@@ -35098,9 +35380,9 @@ var PREMIUM_REPO = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH = "main";
 var CONFIG_FOLDER_CANDIDATES2 = ["agents-config", "ai-coding", "claude-code-config", "ai-config"];
 function routePath(relativePath) {
-  const segments = relativePath.split(path14.sep);
+  const segments = relativePath.split(path15.sep);
   const first = segments[0];
-  const rest = segments.slice(1).join(path14.sep);
+  const rest = segments.slice(1).join(path15.sep);
   if (first === "claude-config") {
     return { kind: "claude", relativePath: rest };
   }
@@ -35116,7 +35398,7 @@ function routePath(relativePath) {
   return { kind: "claude", relativePath };
 }
 function getCacheRepoDir() {
-  return path14.join(os14.homedir(), ".config", "aiblueprint", "pro-repos", "aiblueprint-cli-premium");
+  return path15.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?:\/\//, "")}`;
@@ -35130,21 +35412,21 @@ async function execGitWithAuth(command, token, repoUrl, cwd) {
 async function cloneOrUpdateRepo(token) {
   const cacheDir = getCacheRepoDir();
   const repoUrl = `https://github.com/${PREMIUM_REPO}.git`;
-  if (await import_fs_extra10.default.pathExists(path14.join(cacheDir, ".git"))) {
+  if (await import_fs_extra11.default.pathExists(path15.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra10.default.remove(cacheDir);
-      await import_fs_extra10.default.ensureDir(path14.dirname(cacheDir));
+      await import_fs_extra11.default.remove(cacheDir);
+      await import_fs_extra11.default.ensureDir(path15.dirname(cacheDir));
       await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra10.default.ensureDir(path14.dirname(cacheDir));
+    await import_fs_extra11.default.ensureDir(path15.dirname(cacheDir));
     await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
   for (const candidate of CONFIG_FOLDER_CANDIDATES2) {
-    const candidatePath = path14.join(cacheDir, candidate);
-    if (await import_fs_extra10.default.pathExists(candidatePath)) {
+    const candidatePath = path15.join(cacheDir, candidate);
+    if (await import_fs_extra11.default.pathExists(candidatePath)) {
       return candidatePath;
     }
   }
@@ -35152,35 +35434,38 @@ async function cloneOrUpdateRepo(token) {
 }
 async function copyConfigFromCache(cacheConfigDir, dest, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra10.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra11.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name === ".DS_Store" || entry.name === "node_modules")
         continue;
-      const sourcePath = path14.join(dir, entry.name);
-      const relativePath = path14.relative(baseDir, sourcePath);
+      const sourcePath = path15.join(dir, entry.name);
+      const relativePath = path15.relative(baseDir, sourcePath);
       const route = routePath(relativePath);
       if (route.kind === "skip")
         continue;
       if (route.kind === "agents-category") {
-        if (relativePath.split(path14.sep).length === 1) {
+        if (relativePath.split(path15.sep).length === 1) {
           await copyAgentCategory(sourcePath, route.category, dest.agentsDir, dest.claudeDir, onProgress);
         }
         continue;
       }
       const targetBase = route.kind === "claude" ? dest.claudeDir : dest.codexDir;
-      const targetPath = path14.join(targetBase, route.relativePath);
+      const targetPath = path15.join(targetBase, route.relativePath);
       if (entry.isDirectory()) {
-        await import_fs_extra10.default.ensureDir(targetPath);
+        await import_fs_extra11.default.ensureDir(targetPath);
         onProgress?.(relativePath, "directory");
         await walk(sourcePath, baseDir);
+      } else if (route.kind === "codex" && route.relativePath === "config.toml") {
+        await mergeCodexConfigFile(sourcePath, dest.codexDir);
+        onProgress?.(relativePath, "file");
       } else if (isTextFile(entry.name)) {
-        const content = await import_fs_extra10.default.readFile(sourcePath, "utf-8");
+        const content = await import_fs_extra11.default.readFile(sourcePath, "utf-8");
         const replaced = replaceClaudePathPlaceholder(content, dest.claudeDir);
-        await import_fs_extra10.default.ensureDir(path14.dirname(targetPath));
-        await import_fs_extra10.default.writeFile(targetPath, replaced, "utf-8");
+        await import_fs_extra11.default.ensureDir(path15.dirname(targetPath));
+        await import_fs_extra11.default.writeFile(targetPath, replaced, "utf-8");
         onProgress?.(relativePath, "file");
       } else {
-        await import_fs_extra10.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra11.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -35188,21 +35473,21 @@ async function copyConfigFromCache(cacheConfigDir, dest, onProgress) {
   await walk(cacheConfigDir);
 }
 async function copyAgentCategory(sourceCategoryDir, category, agentsDir, claudeDir, onProgress) {
-  const agentsCategoryDir = path14.join(agentsDir, category);
-  await import_fs_extra10.default.ensureDir(agentsCategoryDir);
-  const entries = await import_fs_extra10.default.readdir(sourceCategoryDir, { withFileTypes: true });
+  const agentsCategoryDir = path15.join(agentsDir, category);
+  await import_fs_extra11.default.ensureDir(agentsCategoryDir);
+  const entries = await import_fs_extra11.default.readdir(sourceCategoryDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".DS_Store")
       continue;
-    const src = path14.join(sourceCategoryDir, entry.name);
-    const dst = path14.join(agentsCategoryDir, entry.name);
-    const claudeTop = path14.join(claudeDir, category, entry.name);
-    const claudeStat = await import_fs_extra10.default.lstat(claudeTop).catch(() => null);
+    const src = path15.join(sourceCategoryDir, entry.name);
+    const dst = path15.join(agentsCategoryDir, entry.name);
+    const claudeTop = path15.join(claudeDir, category, entry.name);
+    const claudeStat = await import_fs_extra11.default.lstat(claudeTop).catch(() => null);
     if (claudeStat && !claudeStat.isSymbolicLink()) {
       onProgress?.(`${category}/${entry.name} (skipped - real dir in claude)`, "file");
       continue;
     }
-    await import_fs_extra10.default.copy(src, dst, { overwrite: true });
+    await import_fs_extra11.default.copy(src, dst, { overwrite: true });
     await applyPathPlaceholders(dst, claudeDir);
     onProgress?.(`${category}/${entry.name}`, entry.isDirectory() ? "directory" : "file");
   }
@@ -35221,8 +35506,8 @@ async function downloadFromPrivateGitHub(repo, branch, relativePath, targetPath,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra10.default.ensureDir(path14.dirname(targetPath));
-    await import_fs_extra10.default.writeFile(targetPath, Buffer.from(content));
+    await import_fs_extra11.default.ensureDir(path15.dirname(targetPath));
+    await import_fs_extra11.default.writeFile(targetPath, Buffer.from(content));
     return true;
   } catch (error) {
     console.error(`Error downloading ${relativePath}:`, error);
@@ -35247,10 +35532,10 @@ async function downloadDirectoryFromPrivateGitHub(repo, branch, dirPath, targetD
       console.error(`Unexpected response for directory ${dirPath}`);
       return false;
     }
-    await import_fs_extra10.default.ensureDir(targetDir);
+    await import_fs_extra11.default.ensureDir(targetDir);
     for (const file of files) {
       const relativePath = dirPath ? `${dirPath}/${file.name}` : file.name;
-      const targetPath = path14.join(targetDir, file.name);
+      const targetPath = path15.join(targetDir, file.name);
       const displayPath = relativePath.replace(/^(agents-config|ai-coding|claude-code-config|ai-config)\//, "");
       if (file.type === "file") {
         onProgress?.(displayPath, "file");
@@ -35273,8 +35558,8 @@ async function installProConfigs(options) {
     codexFolder,
     agentsFolder
   });
-  await import_fs_extra10.default.ensureDir(claudeDir);
-  await import_fs_extra10.default.ensureDir(agentsDir);
+  await import_fs_extra11.default.ensureDir(claudeDir);
+  await import_fs_extra11.default.ensureDir(agentsDir);
   const dest = { claudeDir, codexDir, agentsDir };
   try {
     const cacheConfigDir = await cloneOrUpdateRepo(githubToken);
@@ -35284,7 +35569,7 @@ async function installProConfigs(options) {
   } catch (error) {
     console.warn("Git caching failed, falling back to API download");
   }
-  const tempDir = path14.join(os14.tmpdir(), `aiblueprint-premium-${Date.now()}`);
+  const tempDir = path15.join(os13.tmpdir(), `aiblueprint-premium-${Date.now()}`);
   try {
     let success = false;
     for (const candidate of CONFIG_FOLDER_CANDIDATES2) {
@@ -35298,8 +35583,8 @@ async function installProConfigs(options) {
     await copyConfigFromCache(tempDir, dest, onProgress);
     await replacePathPlaceholdersInDir(claudeDir, claudeDir);
     for (const category of AGENT_CATEGORIES) {
-      const agentsCategoryDir = path14.join(agentsDir, category);
-      if (await import_fs_extra10.default.pathExists(agentsCategoryDir)) {
+      const agentsCategoryDir = path15.join(agentsDir, category);
+      if (await import_fs_extra11.default.pathExists(agentsCategoryDir)) {
         await replacePathPlaceholdersInDir(agentsCategoryDir, claudeDir);
       }
     }
@@ -35308,7 +35593,7 @@ async function installProConfigs(options) {
     throw new Error(`Failed to install premium configs: ${error instanceof Error ? error.message : "Unknown error"}`);
   } finally {
     try {
-      await import_fs_extra10.default.remove(tempDir);
+      await import_fs_extra11.default.remove(tempDir);
     } catch {}
   }
 }
@@ -35319,27 +35604,27 @@ async function syncAllAgentSymlinks(agentsDir, claudeDir) {
 }
 
 // src/lib/token-storage.ts
-var import_fs_extra11 = __toESM(require_lib4(), 1);
-import os15 from "os";
-import path15 from "path";
+var import_fs_extra12 = __toESM(require_lib4(), 1);
+import os14 from "os";
+import path16 from "path";
 function getConfigDir() {
-  const platform = os15.platform();
+  const platform = os14.platform();
   if (platform === "win32") {
-    const appData = process.env.APPDATA || path15.join(os15.homedir(), "AppData", "Roaming");
-    return path15.join(appData, "aiblueprint");
+    const appData = process.env.APPDATA || path16.join(os14.homedir(), "AppData", "Roaming");
+    return path16.join(appData, "aiblueprint");
   } else {
-    const configHome = process.env.XDG_CONFIG_HOME || path15.join(os15.homedir(), ".config");
-    return path15.join(configHome, "aiblueprint");
+    const configHome = process.env.XDG_CONFIG_HOME || path16.join(os14.homedir(), ".config");
+    return path16.join(configHome, "aiblueprint");
   }
 }
 function getTokenFilePath2() {
-  return path15.join(getConfigDir(), "token.txt");
+  return path16.join(getConfigDir(), "token.txt");
 }
 async function saveToken(githubToken) {
   const tokenFile = getTokenFilePath2();
-  const configDir = path15.dirname(tokenFile);
+  const configDir = path16.dirname(tokenFile);
   try {
-    await import_fs_extra11.default.ensureDir(configDir);
+    await import_fs_extra12.default.ensureDir(configDir);
   } catch (error) {
     if (error.code === "EACCES") {
       throw new Error(`Permission denied creating config directory: ${configDir}
@@ -35347,15 +35632,15 @@ async function saveToken(githubToken) {
     }
     throw error;
   }
-  await import_fs_extra11.default.writeFile(tokenFile, githubToken, { mode: 384 });
+  await import_fs_extra12.default.writeFile(tokenFile, githubToken, { mode: 384 });
 }
 async function getToken() {
   const tokenFile = getTokenFilePath2();
-  if (!await import_fs_extra11.default.pathExists(tokenFile)) {
+  if (!await import_fs_extra12.default.pathExists(tokenFile)) {
     return null;
   }
   try {
-    const token = await import_fs_extra11.default.readFile(tokenFile, "utf-8");
+    const token = await import_fs_extra12.default.readFile(tokenFile, "utf-8");
     return token.trim();
   } catch (error) {
     return null;
@@ -35364,12 +35649,12 @@ async function getToken() {
 function getTokenInfo() {
   return {
     path: getTokenFilePath2(),
-    platform: os15.platform()
+    platform: os14.platform()
   };
 }
 
 // src/commands/pro.ts
-var import_fs_extra12 = __toESM(require_lib4(), 1);
+var import_fs_extra13 = __toESM(require_lib4(), 1);
 var API_URL = "https://codeline.app/api/products";
 var PRODUCT_IDS = ["prd_XJVgxVPbGG", "prd_NKabAkdOkw"];
 async function countInstalledItems(claudeDir) {
@@ -35378,20 +35663,20 @@ async function countInstalledItems(claudeDir) {
     skills: 0
   };
   try {
-    const agentsDir = path16.join(claudeDir, "agents");
-    if (await import_fs_extra12.default.pathExists(agentsDir)) {
-      const files = await import_fs_extra12.default.readdir(agentsDir);
+    const agentsDir = path17.join(claudeDir, "agents");
+    if (await import_fs_extra13.default.pathExists(agentsDir)) {
+      const files = await import_fs_extra13.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 = path16.join(claudeDir, "skills");
-    if (await import_fs_extra12.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra12.default.readdir(skillsDir);
+    const skillsDir = path17.join(claudeDir, "skills");
+    if (await import_fs_extra13.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra13.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra12.default.stat(path16.join(skillsDir, item));
+        const stat = await import_fs_extra13.default.stat(path17.join(skillsDir, item));
         return stat.isDirectory();
       }));
       counts.skills = dirs.filter(Boolean).length;
@@ -35599,8 +35884,8 @@ async function proUpdateCommand(options = {}) {
 }
 
 // src/lib/sync-utils.ts
-var import_fs_extra13 = __toESM(require_lib4(), 1);
-import path17 from "path";
+var import_fs_extra14 = __toESM(require_lib4(), 1);
+import path18 from "path";
 import crypto from "crypto";
 var PREMIUM_REPO2 = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH2 = "main";
@@ -35671,7 +35956,7 @@ async function listRemoteFilesRecursive(dirPath, githubToken, basePath = "") {
 }
 async function computeLocalFileSha(filePath) {
   try {
-    const content = await import_fs_extra13.default.readFile(filePath);
+    const content = await import_fs_extra14.default.readFile(filePath);
     return computeFileSha(content);
   } catch {
     return null;
@@ -35679,15 +35964,15 @@ async function computeLocalFileSha(filePath) {
 }
 async function listLocalFiles(dir) {
   const files = [];
-  if (!await import_fs_extra13.default.pathExists(dir)) {
+  if (!await import_fs_extra14.default.pathExists(dir)) {
     return files;
   }
-  const items = await import_fs_extra13.default.readdir(dir);
+  const items = await import_fs_extra14.default.readdir(dir);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path17.join(dir, item);
-    const stat = await import_fs_extra13.default.stat(fullPath).catch(() => null);
+    const fullPath = path18.join(dir, item);
+    const stat = await import_fs_extra14.default.stat(fullPath).catch(() => null);
     if (!stat)
       continue;
     if (stat.isDirectory()) {
@@ -35702,13 +35987,13 @@ async function listLocalFiles(dir) {
 }
 async function listLocalFilesRecursive(dir, basePath) {
   const files = [];
-  const items = await import_fs_extra13.default.readdir(dir).catch(() => []);
+  const items = await import_fs_extra14.default.readdir(dir).catch(() => []);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path17.join(dir, item);
+    const fullPath = path18.join(dir, item);
     const relativePath = `${basePath}/${item}`;
-    const stat = await import_fs_extra13.default.stat(fullPath).catch(() => null);
+    const stat = await import_fs_extra14.default.stat(fullPath).catch(() => null);
     if (!stat)
       continue;
     if (stat.isDirectory()) {
@@ -35722,14 +36007,14 @@ async function listLocalFilesRecursive(dir, basePath) {
   return files;
 }
 async function listClaudeRealTopLevel(claudeCategoryDir) {
-  if (!await import_fs_extra13.default.pathExists(claudeCategoryDir))
+  if (!await import_fs_extra14.default.pathExists(claudeCategoryDir))
     return [];
-  const entries = await import_fs_extra13.default.readdir(claudeCategoryDir).catch(() => []);
+  const entries = await import_fs_extra14.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(path17.join(claudeCategoryDir, name)).catch(() => null);
+    const stat = await import_fs_extra14.default.lstat(path18.join(claudeCategoryDir, name)).catch(() => null);
     if (!stat)
       continue;
     if (stat.isDirectory())
@@ -35746,7 +36031,7 @@ async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
   const items = [];
   const useAgents = isAgentCategory(category);
   const localBase = useAgents ? agentsDir : claudeDir;
-  const localDir = path17.join(localBase, category);
+  const localDir = path18.join(localBase, category);
   const remoteCategoryPath = getRemoteCategoryPath(category);
   const remoteFiles = await listRemoteFilesRecursive(remoteCategoryPath, githubToken);
   const localFiles = await listLocalFiles(localDir);
@@ -35760,7 +36045,7 @@ async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
   }
   const localSet = new Set(localFiles);
   for (const [remotePath, { sha, isFolder }] of remoteSet) {
-    const localPath = path17.join(localDir, remotePath);
+    const localPath = path18.join(localDir, remotePath);
     if (isFolder) {
       continue;
     }
@@ -35795,7 +36080,7 @@ async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
     for (const localPath of localSet) {
       agentsTopLevels.add(localPath.split("/")[0]);
     }
-    const claudeCategoryDir = path17.join(claudeDir, category);
+    const claudeCategoryDir = path18.join(claudeDir, category);
     const claudeRealEntries = await listClaudeRealTopLevel(claudeCategoryDir);
     for (const top of claudeRealEntries) {
       if (!remoteTopLevels.has(top))
@@ -35854,13 +36139,13 @@ async function downloadFromPrivateGitHub2(relativePath, targetPath, githubToken,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra13.default.ensureDir(path17.dirname(targetPath));
+    await import_fs_extra14.default.ensureDir(path18.dirname(targetPath));
     if (isTextFile(relativePath)) {
       const textContent = Buffer.from(content).toString("utf-8");
       const transformedContent = transformFileContent(textContent, claudeDir);
-      await import_fs_extra13.default.writeFile(targetPath, transformedContent, "utf-8");
+      await import_fs_extra14.default.writeFile(targetPath, transformedContent, "utf-8");
     } else {
-      await import_fs_extra13.default.writeFile(targetPath, Buffer.from(content));
+      await import_fs_extra14.default.writeFile(targetPath, Buffer.from(content));
     }
     return true;
   } catch {
@@ -35876,27 +36161,27 @@ async function syncSelectedItems(claudeDir, items, githubToken, agentsDir, onPro
   for (const item of items) {
     const useAgents = isAgentCategory(item.category);
     const baseDir = useAgents ? agentsDir : claudeDir;
-    const targetPath = path17.join(baseDir, item.relativePath);
+    const targetPath = path18.join(baseDir, item.relativePath);
     if (item.status === "migration" && useAgents) {
       const topName = item.name.split("/")[0];
-      const agentsTop = path17.join(agentsDir, item.category, topName);
-      const claudeTop = path17.join(claudeDir, item.category, topName);
+      const agentsTop = path18.join(agentsDir, item.category, topName);
+      const claudeTop = path18.join(claudeDir, item.category, topName);
       try {
-        const claudeStat = await import_fs_extra13.default.lstat(claudeTop).catch(() => null);
+        const claudeStat = await import_fs_extra14.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);
+        const agentsExists = await import_fs_extra14.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(path17.dirname(agentsTop));
-        await import_fs_extra13.default.move(claudeTop, agentsTop);
+        await import_fs_extra14.default.ensureDir(path18.dirname(agentsTop));
+        await import_fs_extra14.default.move(claudeTop, agentsTop);
         migrated++;
         touchedAgentCategories.add(item.category);
       } catch {
@@ -35906,8 +36191,8 @@ async function syncSelectedItems(claudeDir, items, githubToken, agentsDir, onPro
     }
     if (useAgents) {
       const topName = item.name.split("/")[0];
-      const claudeTop = path17.join(claudeDir, item.category, topName);
-      const claudeTopStat = await import_fs_extra13.default.lstat(claudeTop).catch(() => null);
+      const claudeTop = path18.join(claudeDir, item.category, topName);
+      const claudeTopStat = await import_fs_extra14.default.lstat(claudeTop).catch(() => null);
       if (claudeTopStat && !claudeTopStat.isSymbolicLink()) {
         onProgress?.(item.relativePath, "skipping (real dir in .claude)");
         failed++;
@@ -35917,7 +36202,7 @@ async function syncSelectedItems(claudeDir, items, githubToken, agentsDir, onPro
     if (item.status === "deleted") {
       onProgress?.(item.relativePath, "deleting");
       try {
-        await import_fs_extra13.default.remove(targetPath);
+        await import_fs_extra14.default.remove(targetPath);
         deleted++;
         if (useAgents)
           touchedAgentCategories.add(item.category);
@@ -36198,7 +36483,7 @@ async function proSyncCommand(options = {}) {
       M2.message(source_default.yellow(`  ✓ Update ${toUpdate} file${toUpdate > 1 ? "s" : ""}`));
     if (toMigrate > 0)
       M2.message(source_default.blue(`  ✓ Move ${toMigrate} skill${toMigrate > 1 ? "s" : ""} from .claude to .agents`));
-    M2.message(source_default.gray(`  ✓ Backup current config to ~/.config/aiblueprint/backup/`));
+    M2.message(source_default.gray(`  ✓ Backup current config to ~/.aiblueprint/backups/`));
     M2.message("");
     const confirmResult = await ye({
       message: "Proceed with sync?",
@@ -36209,7 +36494,7 @@ async function proSyncCommand(options = {}) {
       process.exit(0);
     }
     spinner.start("Creating backup...");
-    const backupPath = await createBackup(claudeDir, agentsDir);
+    const backupPath = await createConfigBackup(options, "Before syncing premium aiblueprint configuration", "sync", "aiblueprint-sync");
     if (backupPath) {
       spinner.stop(`Backup created: ${source_default.gray(backupPath)}`);
     } else {
@@ -36254,6 +36539,106 @@ async function proSyncCommand(options = {}) {
   }
 }
 
+// src/lib/backup-utils.ts
+var import_fs_extra15 = __toESM(require_lib4(), 1);
+import path19 from "path";
+import os15 from "os";
+var BACKUP_BASE_DIR = path19.join(os15.homedir(), ".config", "aiblueprint", "backup");
+function formatDate(date) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}-${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
+}
+async function listBackups() {
+  const exists = await import_fs_extra15.default.pathExists(BACKUP_BASE_DIR);
+  if (!exists) {
+    return [];
+  }
+  const entries = await import_fs_extra15.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: path19.join(BACKUP_BASE_DIR, entry.name),
+      date
+    });
+  }
+  return backups.sort((a, b3) => b3.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_extra15.default.copy(sourcePath, destPath, {
+    overwrite: true,
+    dereference: false,
+    filter: async (src) => {
+      try {
+        const stat = await import_fs_extra15.default.lstat(src);
+        return !stat.isSymbolicLink();
+      } catch {
+        return true;
+      }
+    }
+  });
+}
+async function hasMeaningfulContent(dir) {
+  if (!await import_fs_extra15.default.pathExists(dir))
+    return false;
+  const files = await import_fs_extra15.default.readdir(dir);
+  return files.some((f) => f !== ".DS_Store");
+}
+async function loadBackup(backupPath, claudeDir, agentsDir) {
+  const exists = await import_fs_extra15.default.pathExists(backupPath);
+  if (!exists) {
+    throw new Error(`Backup not found: ${backupPath}`);
+  }
+  await import_fs_extra15.default.ensureDir(claudeDir);
+  for (const item of CLAUDE_ITEMS) {
+    const sourcePath = path19.join(backupPath, item);
+    const destPath = path19.join(claudeDir, item);
+    if (await import_fs_extra15.default.pathExists(sourcePath)) {
+      await copyForBackup(sourcePath, destPath);
+    }
+  }
+  if (agentsDir) {
+    const agentsBackupPath = path19.join(backupPath, AGENTS_BACKUP_SUBDIR);
+    if (await import_fs_extra15.default.pathExists(agentsBackupPath)) {
+      await import_fs_extra15.default.ensureDir(agentsDir);
+      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 timestamp2 = formatDate(new Date);
+  const backupPath = path19.join(BACKUP_BASE_DIR, timestamp2);
+  await import_fs_extra15.default.ensureDir(backupPath);
+  if (claudeHasContent) {
+    for (const item of CLAUDE_ITEMS) {
+      const sourcePath = path19.join(claudeDir, item);
+      const destPath = path19.join(backupPath, item);
+      if (await import_fs_extra15.default.pathExists(sourcePath)) {
+        await copyForBackup(sourcePath, destPath);
+      }
+    }
+  }
+  if (agentsHasContent && agentsDir) {
+    const destPath = path19.join(backupPath, AGENTS_BACKUP_SUBDIR);
+    await copyForBackup(agentsDir, destPath);
+  }
+  return backupPath;
+}
+
 // src/commands/backup.ts
 function formatBackupDate(date) {
   const now = new Date;
@@ -36329,20 +36714,116 @@ async function backupLoadCommand(options = {}) {
   }
 }
 
+// src/commands/configs.ts
+function formatDate2(iso) {
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime()))
+    return "unknown date";
+  return date.toLocaleString();
+}
+function formatFolders(folders) {
+  return folders.length > 0 ? folders.join(", ") : "unknown folders";
+}
+function printSnapshots(title, snapshots) {
+  console.log(source_default.blue(title));
+  if (snapshots.length === 0) {
+    console.log(source_default.gray("No entries found."));
+    return;
+  }
+  for (const snapshot of snapshots) {
+    console.log(`${source_default.cyan(snapshot.name)} ${source_default.gray(formatDate2(snapshot.metadata.createdAt))}`);
+    console.log(source_default.gray(`  reason: ${snapshot.metadata.reason}`));
+    console.log(source_default.gray(`  trigger: ${snapshot.metadata.trigger}`));
+    console.log(source_default.gray(`  folders: ${formatFolders(snapshot.metadata.folders)}`));
+    console.log(source_default.gray(`  path: ${snapshot.path}`));
+  }
+}
+async function configsSaveCommand(name, options = {}) {
+  try {
+    const snapshotPath = await saveNamedConfig(name, options);
+    console.log(source_default.green(`Saved config "${name}"`));
+    console.log(source_default.gray(snapshotPath));
+  } catch (error) {
+    console.error(source_default.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}
+async function configsLoadCommand(name, options = {}) {
+  try {
+    const result = await loadNamedConfig(name, options);
+    console.log(source_default.green(`Loaded config "${name}"`));
+    if (result.backupPath) {
+      console.log(source_default.gray(`Previous config backed up to ${result.backupPath}`));
+    }
+    console.log(source_default.gray(`Restored: ${formatFolders(result.restored)}`));
+  } catch (error) {
+    console.error(source_default.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}
+async function configsUndoCommand(options = {}) {
+  try {
+    const result = await undoLastLoad(options);
+    console.log(source_default.green(`Undid last config load using backup "${result.backupName}"`));
+    if (result.backupPath) {
+      console.log(source_default.gray(`Current config backed up to ${result.backupPath}`));
+    }
+    console.log(source_default.gray(`Restored: ${formatFolders(result.restored)}`));
+  } catch (error) {
+    console.error(source_default.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}
+async function configsListCommand(options = {}) {
+  const configs = await listSavedConfigs(options);
+  printSnapshots("Saved configs", configs);
+}
+async function configsBackupsListCommand(options = {}) {
+  const backups = await listConfigBackups(options);
+  printSnapshots("Config backups", backups);
+}
+async function configsBackupsLoadCommand(name, options = {}) {
+  try {
+    const result = await loadBackupSnapshot(name, options);
+    console.log(source_default.green(`Loaded backup "${name}"`));
+    if (result.backupPath) {
+      console.log(source_default.gray(`Previous config backed up to ${result.backupPath}`));
+    }
+    console.log(source_default.gray(`Restored: ${formatFolders(result.restored)}`));
+  } catch (error) {
+    console.error(source_default.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}
+async function configsBackupsCreateCommand(reason, options = {}) {
+  try {
+    const backupPath = await createConfigBackup(options, reason ?? "Manual backup from configs backups create", "manual-backup", "manual");
+    if (!backupPath) {
+      console.log(source_default.gray("No .claude, .codex, or .agents configuration found to backup."));
+      return;
+    }
+    console.log(source_default.green("Backup created"));
+    console.log(source_default.gray(backupPath));
+  } catch (error) {
+    console.error(source_default.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}
+
 // src/commands/openclaw-pro.ts
 import os18 from "os";
-import path20 from "path";
+import path22 from "path";
 
 // src/lib/openclaw-installer.ts
-var import_fs_extra14 = __toESM(require_lib4(), 1);
+var import_fs_extra16 = __toESM(require_lib4(), 1);
 import os16 from "os";
-import path18 from "path";
+import path20 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 path18.join(os16.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
+  return path20.join(os16.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
 }
 async function execGitWithAuth2(command, token, repoUrl, cwd) {
   const authenticatedUrl = `https://x-access-token:${token}@${repoUrl.replace(/^https?:\/\//, "")}`;
@@ -36356,33 +36837,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_extra14.default.pathExists(path18.join(cacheDir, ".git"))) {
+  if (await import_fs_extra16.default.pathExists(path20.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth2("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra14.default.remove(cacheDir);
-      await import_fs_extra14.default.ensureDir(path18.dirname(cacheDir));
+      await import_fs_extra16.default.remove(cacheDir);
+      await import_fs_extra16.default.ensureDir(path20.dirname(cacheDir));
       await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra14.default.ensureDir(path18.dirname(cacheDir));
+    await import_fs_extra16.default.ensureDir(path20.dirname(cacheDir));
     await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
-  return path18.join(cacheDir, "openclaw-config");
+  return path20.join(cacheDir, "openclaw-config");
 }
 async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra14.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra16.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = path18.join(dir, entry.name);
-      const relativePath = path18.relative(baseDir, sourcePath);
-      const targetPath = path18.join(targetDir, relativePath);
+      const sourcePath = path20.join(dir, entry.name);
+      const relativePath = path20.relative(baseDir, sourcePath);
+      const targetPath = path20.join(targetDir, relativePath);
       if (entry.isDirectory()) {
-        await import_fs_extra14.default.ensureDir(targetPath);
+        await import_fs_extra16.default.ensureDir(targetPath);
         onProgress?.(relativePath, "directory");
         await walk(sourcePath, baseDir);
       } else {
-        await import_fs_extra14.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra16.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -36391,7 +36872,7 @@ async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
 }
 async function installOpenclawProConfigs(options) {
   const { githubToken, openclawFolder, onProgress } = options;
-  const targetFolder = openclawFolder || path18.join(os16.homedir(), ".openclaw");
+  const targetFolder = openclawFolder || path20.join(os16.homedir(), ".openclaw");
   try {
     const cacheConfigDir = await cloneOrUpdateRepo2(githubToken);
     await copyConfigFromCache2(cacheConfigDir, targetFolder, onProgress);
@@ -36402,28 +36883,28 @@ async function installOpenclawProConfigs(options) {
 }
 
 // src/lib/openclaw-token-storage.ts
-var import_fs_extra15 = __toESM(require_lib4(), 1);
+var import_fs_extra17 = __toESM(require_lib4(), 1);
 import os17 from "os";
-import path19 from "path";
+import path21 from "path";
 function getConfigDir2() {
   const platform = os17.platform();
   if (platform === "win32") {
-    return path19.join(process.env.APPDATA || os17.homedir(), "openclaw");
+    return path21.join(process.env.APPDATA || os17.homedir(), "openclaw");
   }
-  return path19.join(os17.homedir(), ".config", "openclaw");
+  return path21.join(os17.homedir(), ".config", "openclaw");
 }
 function getTokenPath() {
-  return path19.join(getConfigDir2(), "token.txt");
+  return path21.join(getConfigDir2(), "token.txt");
 }
 async function saveOpenclawToken(githubToken) {
   const configDir = getConfigDir2();
-  await import_fs_extra15.default.ensureDir(configDir);
-  await import_fs_extra15.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
+  await import_fs_extra17.default.ensureDir(configDir);
+  await import_fs_extra17.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
 }
 async function getOpenclawToken() {
   const tokenPath = getTokenPath();
-  if (await import_fs_extra15.default.pathExists(tokenPath)) {
-    const token = await import_fs_extra15.default.readFile(tokenPath, "utf8");
+  if (await import_fs_extra17.default.pathExists(tokenPath)) {
+    const token = await import_fs_extra17.default.readFile(tokenPath, "utf8");
     return token.trim();
   }
   return null;
@@ -36436,7 +36917,7 @@ function getOpenclawTokenInfo() {
 }
 
 // src/commands/openclaw-pro.ts
-var import_fs_extra16 = __toESM(require_lib4(), 1);
+var import_fs_extra18 = __toESM(require_lib4(), 1);
 var API_URL2 = "https://codeline.app/api/products";
 var OPENCLAW_PRODUCT_ID = "prd_t2GRwX3aH1";
 var CLAUDE_CODE_TOOLS_INSTRUCTIONS = `
@@ -36543,7 +37024,7 @@ async function openclawProSetupCommand(options = {}) {
       Se(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const openclawDir = options.folder ? path20.resolve(options.folder) : path20.join(os18.homedir(), ".openclaw");
+    const openclawDir = options.folder ? path22.resolve(options.folder) : path22.join(os18.homedir(), ".openclaw");
     const spinner = Y2();
     const onProgress = (file, type) => {
       spinner.message(`Installing: ${source_default.cyan(file)} ${source_default.gray(`(${type})`)}`);
@@ -36556,23 +37037,23 @@ async function openclawProSetupCommand(options = {}) {
     });
     spinner.stop("OpenClaw Pro configurations installed");
     let skillCount = 0;
-    const skillsDir = path20.join(openclawDir, "skills");
-    if (await import_fs_extra16.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra16.default.readdir(skillsDir);
+    const skillsDir = path22.join(openclawDir, "skills");
+    if (await import_fs_extra18.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra18.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra16.default.stat(path20.join(skillsDir, item));
+        const stat = await import_fs_extra18.default.stat(path22.join(skillsDir, item));
         return stat.isDirectory();
       }));
       skillCount = dirs.filter(Boolean).length;
     }
     spinner.start("Setting up workspace TOOLS.md...");
-    const workspaceDir = path20.join(openclawDir, "workspace");
-    const toolsPath = path20.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");
+    const workspaceDir = path22.join(openclawDir, "workspace");
+    const toolsPath = path22.join(workspaceDir, "TOOLS.md");
+    await import_fs_extra18.default.ensureDir(workspaceDir);
+    if (await import_fs_extra18.default.pathExists(toolsPath)) {
+      const existingContent = await import_fs_extra18.default.readFile(toolsPath, "utf-8");
       if (!existingContent.includes("Claude Code CLI")) {
-        await import_fs_extra16.default.appendFile(toolsPath, `
+        await import_fs_extra18.default.appendFile(toolsPath, `
 
 ` + CLAUDE_CODE_TOOLS_INSTRUCTIONS);
         spinner.stop("TOOLS.md updated with Claude Code instructions");
@@ -36586,7 +37067,7 @@ Skills define _how_ tools work. This file is for _your_ specifics — the stuff
 
 ${CLAUDE_CODE_TOOLS_INSTRUCTIONS}
 `;
-      await import_fs_extra16.default.writeFile(toolsPath, defaultToolsMd);
+      await import_fs_extra18.default.writeFile(toolsPath, defaultToolsMd);
       spinner.stop("TOOLS.md created with Claude Code instructions");
     }
     spinner.start("Creating claude-run wrapper...");
@@ -36597,9 +37078,9 @@ ${CLAUDE_CODE_TOOLS_INSTRUCTIONS}
 script -q -c "claude $*" /dev/null
 `;
     const binDir = "/usr/local/bin";
-    const wrapperPath = path20.join(binDir, "claude-run");
+    const wrapperPath = path22.join(binDir, "claude-run");
     try {
-      await import_fs_extra16.default.writeFile(wrapperPath, claudeRunWrapper, { mode: 493 });
+      await import_fs_extra18.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)");
@@ -36648,12 +37129,12 @@ async function openclawProUpdateCommand(options = {}) {
 }
 
 // src/commands/dynamic-scripts.ts
-import path23 from "path";
+import path25 from "path";
 import { homedir } from "os";
 
 // src/lib/script-parser.ts
-var import_fs_extra17 = __toESM(require_lib4(), 1);
-import path21 from "path";
+var import_fs_extra19 = __toESM(require_lib4(), 1);
+import path23 from "path";
 var EXCLUDED_SCRIPTS = ["test", "lint", "format", "start"];
 var EXCLUDED_SUFFIXES = [":test", ":lint", ":test-fixtures", ":start"];
 function shouldIncludeScript(scriptName) {
@@ -36664,12 +37145,12 @@ function shouldIncludeScript(scriptName) {
   return true;
 }
 async function readScriptsPackageJson(claudeDir) {
-  const packageJsonPath = path21.join(claudeDir, "scripts", "package.json");
+  const packageJsonPath = path23.join(claudeDir, "scripts", "package.json");
   try {
-    if (!await import_fs_extra17.default.pathExists(packageJsonPath)) {
+    if (!await import_fs_extra19.default.pathExists(packageJsonPath)) {
       return null;
     }
-    const content = await import_fs_extra17.default.readFile(packageJsonPath, "utf-8");
+    const content = await import_fs_extra19.default.readFile(packageJsonPath, "utf-8");
     const parsed = JSON.parse(content);
     return parsed.scripts || null;
   } catch (error) {
@@ -36713,10 +37194,10 @@ function groupScriptsByPrefix(commands) {
 }
 
 // src/commands/script-runner.ts
-var import_fs_extra18 = __toESM(require_lib4(), 1);
+var import_fs_extra20 = __toESM(require_lib4(), 1);
 import { spawn as spawn2 } from "child_process";
 import { execSync as execSync4 } from "child_process";
-import path22 from "path";
+import path24 from "path";
 import os19 from "os";
 function checkCommand2(cmd) {
   try {
@@ -36746,18 +37227,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 = path22.join(claudeDir, "scripts");
-  if (!await import_fs_extra18.default.pathExists(scriptsDir)) {
+  const scriptsDir = path24.join(claudeDir, "scripts");
+  if (!await import_fs_extra20.default.pathExists(scriptsDir)) {
     console.error(source_default.red(`Scripts directory not found at ${scriptsDir}`));
     console.log(source_default.gray("Run: aiblueprint agents setup"));
     return 1;
   }
-  const packageJsonPath = path22.join(scriptsDir, "package.json");
-  if (!await import_fs_extra18.default.pathExists(packageJsonPath)) {
+  const packageJsonPath = path24.join(scriptsDir, "package.json");
+  if (!await import_fs_extra20.default.pathExists(packageJsonPath)) {
     console.error(source_default.red(`package.json not found in ${scriptsDir}`));
     return 1;
   }
-  const packageJson = await import_fs_extra18.default.readJson(packageJsonPath);
+  const packageJson = await import_fs_extra20.default.readJson(packageJsonPath);
   if (!packageJson.scripts || !packageJson.scripts[scriptName]) {
     console.error(source_default.red(`Script "${scriptName}" not found in package.json`));
     return 1;
@@ -36780,7 +37261,7 @@ async function executeScript(scriptName, claudeDir) {
 
 // src/commands/dynamic-scripts.ts
 function getClaudeDir(parentOptions) {
-  return parentOptions.claudeCodeFolder || parentOptions.folder ? path23.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path23.join(homedir(), ".claude");
+  return parentOptions.claudeCodeFolder || parentOptions.folder ? path25.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path25.join(homedir(), ".claude");
 }
 async function registerDynamicScriptCommands(claudeCodeCmd, claudeDir) {
   const scripts = await readScriptsPackageJson(claudeDir);
@@ -36886,12 +37367,81 @@ function registerAgentsCommands(cmd) {
     });
   });
 }
+function addConfigFolderOptions(cmd) {
+  return cmd.option("-f, --folder <path>", "Root folder that contains .claude/, .codex/, .agents/ (default: $HOME)").option("--claudeCodeFolder <path>", "Override Claude Code folder (default: {folder}/.claude)").option("--codexFolder <path>", "Override Codex folder (default: {folder}/.codex)").option("--agentsFolder <path>", "Override shared agents folder (default: {folder}/.agents)");
+}
 var agentsCmd = program2.command("agents").description("AI coding configuration commands");
 registerAgentsCommands(agentsCmd);
 var aiCodingCmd = program2.command("ai-coding").description("Legacy alias for agents configuration commands");
 registerAgentsCommands(aiCodingCmd);
 var claudeCodeCmd = program2.command("claude-code").description("Legacy alias for agents configuration commands");
 registerAgentsCommands(claudeCodeCmd);
+var configsCmd = addConfigFolderOptions(program2.command("configs").description("Save, load, undo, and inspect .claude/.codex/.agents configurations"));
+configsCmd.command("save <name>").description("Save the current .claude, .codex, and .agents folders as a named config").option("--force", "Overwrite an existing saved config with the same name").action((name, options, command) => {
+  const parentOptions = command.parent.opts();
+  configsSaveCommand(name, {
+    folder: parentOptions.folder,
+    claudeCodeFolder: parentOptions.claudeCodeFolder,
+    codexFolder: parentOptions.codexFolder,
+    agentsFolder: parentOptions.agentsFolder,
+    force: options.force
+  });
+});
+configsCmd.command("load <name>").description("Load a named config and backup the current folders first").action((name, options, command) => {
+  const parentOptions = command.parent.opts();
+  configsLoadCommand(name, {
+    folder: parentOptions.folder,
+    claudeCodeFolder: parentOptions.claudeCodeFolder,
+    codexFolder: parentOptions.codexFolder,
+    agentsFolder: parentOptions.agentsFolder
+  });
+});
+configsCmd.command("undo").description("Undo the most recent configs load by restoring its automatic backup").action((options, command) => {
+  const parentOptions = command.parent.opts();
+  configsUndoCommand({
+    folder: parentOptions.folder,
+    claudeCodeFolder: parentOptions.claudeCodeFolder,
+    codexFolder: parentOptions.codexFolder,
+    agentsFolder: parentOptions.agentsFolder
+  });
+});
+configsCmd.command("list").description("List saved named configs").action((options, command) => {
+  const parentOptions = command.parent.opts();
+  configsListCommand({
+    folder: parentOptions.folder,
+    claudeCodeFolder: parentOptions.claudeCodeFolder,
+    codexFolder: parentOptions.codexFolder,
+    agentsFolder: parentOptions.agentsFolder
+  });
+});
+var configsBackupsCmd = configsCmd.command("backups").description("Manage automatic config backups");
+configsBackupsCmd.command("list").description("List automatic backups with reasons").action((options, command) => {
+  const parentOptions = command.parent.parent.opts();
+  configsBackupsListCommand({
+    folder: parentOptions.folder,
+    claudeCodeFolder: parentOptions.claudeCodeFolder,
+    codexFolder: parentOptions.codexFolder,
+    agentsFolder: parentOptions.agentsFolder
+  });
+});
+configsBackupsCmd.command("load <name>").description("Load a backup and backup the current folders first").action((name, options, command) => {
+  const parentOptions = command.parent.parent.opts();
+  configsBackupsLoadCommand(name, {
+    folder: parentOptions.folder,
+    claudeCodeFolder: parentOptions.claudeCodeFolder,
+    codexFolder: parentOptions.codexFolder,
+    agentsFolder: parentOptions.agentsFolder
+  });
+});
+configsBackupsCmd.command("create [reason]").description("Create a manual backup of the current config folders").action((reason, options, command) => {
+  const parentOptions = command.parent.parent.opts();
+  configsBackupsCreateCommand(reason, {
+    folder: parentOptions.folder,
+    claudeCodeFolder: parentOptions.claudeCodeFolder,
+    codexFolder: parentOptions.codexFolder,
+    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");
 openclawProCmd.command("activate [token]").description("Activate OpenClaw Pro with your access token").action((token) => {