npm - aiblueprint-cli - Versions diffs - 1.4.56 → 1.4.58 - Mend

aiblueprint-cli 1.4.56 → 1.4.58

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/agents-config/codex-config/config.toml +17 -2
package/dist/cli.js +994 -391
package/package.json +1 -1

package/dist/cli.js CHANGED Viewed

@@ -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,456 @@ 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";
+var COMMON_EXCLUDED_NAMES = new Set([
+  ".git",
+  ".DS_Store",
+  "node_modules"
+]);
+var EXCLUDED_RUNTIME_PATHS = {
+  ".claude": new Set([
+    "backups",
+    "cache",
+    "debug",
+    "file-history",
+    "logs",
+    "output",
+    "paste-cache",
+    "plugins/cache",
+    "projects",
+    "session-env",
+    "sessions",
+    "stats-cache.json",
+    "security.log"
+  ]),
+  ".codex": new Set([
+    "archived_sessions",
+    "browser/sessions",
+    "cache",
+    "log",
+    "logs_2.sqlite",
+    "logs_2.sqlite-shm",
+    "logs_2.sqlite-wal",
+    "models_cache.json",
+    "plugins/cache",
+    "sessions",
+    "vendor_imports/skills-curated-cache.json"
+  ]),
+  ".agents": new Set([
+    "cache",
+    "logs",
+    "sessions"
+  ])
+};
+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");
+}
+function normalizeRelativePath(relativePath) {
+  return relativePath.split(path11.sep).join("/");
+}
+function shouldCopyManagedPath(folderName, sourceRoot, sourcePath) {
+  const basename = path11.basename(sourcePath);
+  if (COMMON_EXCLUDED_NAMES.has(basename))
+    return false;
+  const relativePath = normalizeRelativePath(path11.relative(sourceRoot, sourcePath));
+  if (!relativePath)
+    return true;
+  const excludedPaths = EXCLUDED_RUNTIME_PATHS[folderName];
+  if (excludedPaths.has(relativePath))
+    return false;
+  for (const excludedPath of excludedPaths) {
+    if (relativePath.startsWith(`${excludedPath}/`))
+      return false;
+  }
+  return true;
+}
+async function copyManagedFolder(name, 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() && shouldCopyManagedPath(name, source, src);
+      } 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.name, 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(folder.name, 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 +33990,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 +34019,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 +34031,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 +34047,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 +34068,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 +34128,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 +34154,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 +34190,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 +34238,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 +34259,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 +34278,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 +34300,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 +34313,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 +34323,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 +34420,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 +34471,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 +34509,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 +35426,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 +35439,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 +35457,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 +35471,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 +35493,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 +35532,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 +35565,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 +35591,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 +35617,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 +35628,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 +35642,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 +35652,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 +35663,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 +35691,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 +35708,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 +35722,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 +35943,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 +36015,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 +36023,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 +36046,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 +36066,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 +36090,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 +36104,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 +36139,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 +36198,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 +36220,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 +36250,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 +36261,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 +36542,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 +36553,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 +36598,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 +36773,121 @@ 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 {
+    console.log(source_default.gray("Saving .claude, .codex, and .agents config files..."));
+    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 {
+    console.log(source_default.gray(`Loading config "${name}"...`));
+    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 {
+    console.log(source_default.gray("Restoring the previous config backup..."));
+    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 {
+    console.log(source_default.gray(`Loading backup "${name}"...`));
+    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 {
+    console.log(source_default.gray("Creating config backup..."));
+    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 +36901,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 +36936,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 +36947,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 +36981,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 +37088,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 +37101,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 +37131,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 +37142,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 +37193,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 +37209,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 +37258,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 +37291,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 +37325,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 +37431,70 @@ 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)");
+}
+function readConfigOptions(command, options = {}) {
+  const parentOptions = command.parent?.opts() ?? {};
+  const grandParentOptions = command.parent?.parent?.opts() ?? {};
+  return {
+    folder: options.folder ?? parentOptions.folder ?? grandParentOptions.folder,
+    claudeCodeFolder: options.claudeCodeFolder ?? parentOptions.claudeCodeFolder ?? grandParentOptions.claudeCodeFolder,
+    codexFolder: options.codexFolder ?? parentOptions.codexFolder ?? grandParentOptions.codexFolder,
+    agentsFolder: options.agentsFolder ?? parentOptions.agentsFolder ?? grandParentOptions.agentsFolder
+  };
+}
 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"));
+addConfigFolderOptions(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 folderOptions = readConfigOptions(command, options);
+  configsSaveCommand(name, {
+    ...folderOptions,
+    force: options.force
+  });
+});
+addConfigFolderOptions(configsCmd.command("load <name>").description("Load a named config and backup the current folders first")).action((name, options, command) => {
+  const folderOptions = readConfigOptions(command, options);
+  configsLoadCommand(name, {
+    ...folderOptions
+  });
+});
+addConfigFolderOptions(configsCmd.command("undo").description("Undo the most recent configs load by restoring its automatic backup")).action((options, command) => {
+  const folderOptions = readConfigOptions(command, options);
+  configsUndoCommand({
+    ...folderOptions
+  });
+});
+addConfigFolderOptions(configsCmd.command("list").description("List saved named configs")).action((options, command) => {
+  const folderOptions = readConfigOptions(command, options);
+  configsListCommand({
+    ...folderOptions
+  });
+});
+var configsBackupsCmd = configsCmd.command("backups").description("Manage automatic config backups");
+addConfigFolderOptions(configsBackupsCmd.command("list").description("List automatic backups with reasons")).action((options, command) => {
+  const folderOptions = readConfigOptions(command, options);
+  configsBackupsListCommand({
+    ...folderOptions
+  });
+});
+addConfigFolderOptions(configsBackupsCmd.command("load <name>").description("Load a backup and backup the current folders first")).action((name, options, command) => {
+  const folderOptions = readConfigOptions(command, options);
+  configsBackupsLoadCommand(name, {
+    ...folderOptions
+  });
+});
+addConfigFolderOptions(configsBackupsCmd.command("create [reason]").description("Create a manual backup of the current config folders")).action((reason, options, command) => {
+  const folderOptions = readConfigOptions(command, options);
+  configsBackupsCreateCommand(reason, {
+    ...folderOptions
+  });
+});
 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) => {