aiblueprint-cli 1.4.62 → 1.4.64

package/dist/cli.js

@@ -33628,46 +33628,6 @@ async function mergeCodexConfigFile(sourceConfigPath, codexDir) {
 // 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 {
@@ -33714,37 +33674,10 @@ async function hasContent(folderPath) {
   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) {
+async function copyManagedFolder(source, destination) {
   await import_fs_extra7.default.copy(source, destination, {
     overwrite: true,
-    dereference: false,
-    filter: async (src) => {
-      try {
-        const stat = await import_fs_extra7.default.lstat(src);
-        return !stat.isSymbolicLink() && shouldCopyManagedPath(name, source, src);
-      } catch {
-        return true;
-      }
-    }
+    dereference: false
   });
 }
 async function writeMetadata(snapshotPath, metadata) {
@@ -33776,7 +33709,7 @@ async function snapshotByCopy(snapshotPath, folders, metadata) {
   for (const folder of managedFolders(folders)) {
     if (!await hasContent(folder.path))
       continue;
-    await copyManagedFolder(folder.name, folder.path, path11.join(snapshotPath, folder.name));
+    await copyManagedFolder(folder.path, path11.join(snapshotPath, folder.name));
     copied.push(folder.name);
   }
   if (copied.length === 0) {
@@ -33869,7 +33802,7 @@ async function restoreSnapshot(snapshotPath, folders) {
     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);
+    await copyManagedFolder(source, folder.path);
     restored.push(folder.name);
   }
   return restored;
@@ -35097,13 +35030,90 @@ function getInstructionFileCandidates(options) {
     }
   ]);
 }
-function shouldCollectEntry(category, entry) {
-  if (IGNORED_ENTRY_NAMES2.has(entry.name))
-    return false;
-  if (category === "skills" && entry.name === ".cursor-managed-skills-manifest.json") {
-    return true;
-  }
-  return entry.isFile() || entry.isDirectory() || entry.isSymbolicLink();
+function getRepositoryContainerCandidates(options) {
+  const folders = resolveFolders(options);
+  const cursorDir = path16.join(folders.rootDir, ".cursor");
+  return uniqueByPath([
+    ...getContainerCandidates(options),
+    {
+      category: "rules",
+      label: "agents-rules",
+      path: path16.join(folders.agentsDir, "rules"),
+      isDestination: true
+    },
+    {
+      category: "rules",
+      label: "claude-rules",
+      path: path16.join(folders.claudeDir, "rules"),
+      linkWhenMissing: true
+    },
+    {
+      category: "rules",
+      label: "codex-rules",
+      path: path16.join(folders.codexDir, "rules"),
+      linkWhenParentExists: true
+    },
+    {
+      category: "rules",
+      label: "cursor-rules",
+      path: path16.join(cursorDir, "rules"),
+      linkWhenParentExists: true
+    },
+    {
+      category: "rules",
+      label: "claude-memories",
+      path: path16.join(folders.claudeDir, "memories"),
+      linkSource: false
+    },
+    {
+      category: "rules",
+      label: "codex-memories",
+      path: path16.join(folders.codexDir, "memories"),
+      linkSource: false
+    },
+    {
+      category: "rules",
+      label: "cursor-memories",
+      path: path16.join(cursorDir, "memories"),
+      linkSource: false
+    },
+    {
+      category: "rules",
+      label: "claude-memory",
+      path: path16.join(folders.claudeDir, "memory.md"),
+      linkSource: false
+    },
+    {
+      category: "rules",
+      label: "codex-memory",
+      path: path16.join(folders.codexDir, "memory.md"),
+      linkSource: false
+    },
+    {
+      category: "rules",
+      label: "cursor-memory",
+      path: path16.join(cursorDir, "memory.md"),
+      linkSource: false
+    },
+    {
+      category: "rules",
+      label: "claude-memory-uppercase",
+      path: path16.join(folders.claudeDir, "MEMORY.md"),
+      linkSource: false
+    },
+    {
+      category: "rules",
+      label: "codex-memory-uppercase",
+      path: path16.join(folders.codexDir, "MEMORY.md"),
+      linkSource: false
+    },
+    {
+      category: "rules",
+      label: "cursor-memory-uppercase",
+      path: path16.join(cursorDir, "MEMORY.md"),
+      linkSource: false
+    }
+  ]);
 }
 async function pathExistsOrSymlink(targetPath) {
   const stat = await import_fs_extra12.default.lstat(targetPath).catch(() => null);
@@ -35148,6 +35158,73 @@ async function hashPath(targetPath) {
   }
   return hashString(`other:${stat.mode}:${stat.size}`);
 }
+var TEXT_EXTENSIONS = new Set([
+  ".cjs",
+  ".js",
+  ".json",
+  ".jsonc",
+  ".md",
+  ".mdc",
+  ".mjs",
+  ".sh",
+  ".toml",
+  ".ts",
+  ".tsx",
+  ".txt",
+  ".yaml",
+  ".yml"
+]);
+var PORTABLE_PATH_REPLACEMENTS = [
+  [/\.claude\/skills/g, ".agents/skills"],
+  [/\.codex\/skills/g, ".agents/skills"],
+  [/\.cursor\/skills-cursor/g, ".agents/skills"],
+  [/\.cursor\/skills/g, ".agents/skills"],
+  [/\.claude\/agents/g, ".agents/agents"],
+  [/\.codex\/agents/g, ".agents/agents"],
+  [/\.cursor\/agents/g, ".agents/agents"],
+  [/\.claude\/rules/g, ".agents/rules"],
+  [/\.codex\/rules/g, ".agents/rules"],
+  [/\.cursor\/rules/g, ".agents/rules"],
+  [/\.claude\/memories/g, ".agents/rules"],
+  [/\.codex\/memories/g, ".agents/rules"],
+  [/\.cursor\/memories/g, ".agents/rules"]
+];
+function normalizePortableText(content) {
+  let normalized = content;
+  for (const [pattern, replacement] of PORTABLE_PATH_REPLACEMENTS) {
+    normalized = normalized.replace(pattern, replacement);
+  }
+  return normalized;
+}
+function isLikelyTextFile(filePath) {
+  const ext = path16.extname(filePath).toLowerCase();
+  if (TEXT_EXTENSIONS.has(ext))
+    return true;
+  return path16.basename(filePath) === "SKILL.md";
+}
+async function normalizePortableContent(targetPath) {
+  const stat = await import_fs_extra12.default.lstat(targetPath).catch(() => null);
+  if (!stat || stat.isSymbolicLink())
+    return;
+  if (stat.isDirectory()) {
+    const entries = await import_fs_extra12.default.readdir(targetPath);
+    for (const entry of entries) {
+      if (IGNORED_ENTRY_NAMES2.has(entry))
+        continue;
+      await normalizePortableContent(path16.join(targetPath, entry));
+    }
+    return;
+  }
+  if (!stat.isFile() || !isLikelyTextFile(targetPath))
+    return;
+  const content = await import_fs_extra12.default.readFile(targetPath, "utf-8").catch(() => null);
+  if (content === null || content.includes("\x00"))
+    return;
+  const normalized = normalizePortableText(content);
+  if (normalized !== content) {
+    await import_fs_extra12.default.writeFile(targetPath, normalized, "utf-8");
+  }
+}
 function suffixFromLabel(label) {
   return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "source";
 }
@@ -35196,7 +35273,7 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
     if (destinationRealPath && candidateRealPath && samePath(destinationRealPath, candidateRealPath)) {
       continue;
     }
-    const entries = await import_fs_extra12.default.readdir(candidate.path, { withFileTypes: true }).catch(() => null);
+    const entries = await collectCandidateEntries(candidate).catch(() => null);
     if (!entries) {
       result.skipped.push({
         category,
@@ -35206,9 +35283,9 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
       continue;
     }
     for (const entry of entries) {
-      if (!shouldCollectEntry(category, entry))
+      if (!shouldCollectPath(category, entry.name, entry.path))
         continue;
-      const sourcePath = path16.join(candidate.path, entry.name);
+      const sourcePath = entry.path;
       const sourceHash = await hashPath(sourcePath);
       const existingName = knownHashes.get(sourceHash);
       if (existingName) {
@@ -35237,6 +35314,7 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
         dereference: false,
         overwrite: false
       });
+      await normalizePortableContent(targetPath);
       knownHashes.set(sourceHash, targetName);
       result.imported.push({
         category,
@@ -35247,6 +35325,41 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
     }
   }
 }
+async function collectCandidateEntries(candidate) {
+  const stat = await import_fs_extra12.default.lstat(candidate.path);
+  if (stat.isDirectory()) {
+    const entries = await import_fs_extra12.default.readdir(candidate.path, { withFileTypes: true });
+    return entries.map((entry) => ({
+      name: entry.name,
+      path: path16.join(candidate.path, entry.name)
+    }));
+  }
+  if (stat.isSymbolicLink()) {
+    const targetStat = await import_fs_extra12.default.stat(candidate.path).catch(() => null);
+    if (targetStat?.isDirectory()) {
+      const entries = await import_fs_extra12.default.readdir(candidate.path, { withFileTypes: true });
+      return entries.map((entry) => ({
+        name: entry.name,
+        path: path16.join(candidate.path, entry.name)
+      }));
+    }
+  }
+  return [{
+    name: path16.basename(candidate.path),
+    path: candidate.path
+  }];
+}
+async function shouldCollectPath(category, name, sourcePath) {
+  if (IGNORED_ENTRY_NAMES2.has(name))
+    return false;
+  if (category === "skills" && name === ".cursor-managed-skills-manifest.json") {
+    return true;
+  }
+  const stat = await import_fs_extra12.default.lstat(sourcePath).catch(() => null);
+  if (!stat)
+    return false;
+  return stat.isFile() || stat.isDirectory() || stat.isSymbolicLink();
+}
 function timestamp2(date = new Date) {
   return date.toISOString().replace(/\.\d{3}Z$/, "").replace(/[:T]/g, "-");
 }
@@ -35291,6 +35404,9 @@ async function shouldLinkMissingContainer(candidate) {
   return import_fs_extra12.default.pathExists(path16.dirname(candidate.path));
 }
 async function linkContainer(candidate, destinationDir, result) {
+  if (candidate.linkSource === false) {
+    return;
+  }
   if (candidate.isDestination || samePath(candidate.path, destinationDir)) {
     return;
   }
@@ -35447,29 +35563,176 @@ async function linkInstructionFile(candidate, destinationPath, result) {
     movedToBackup: backupTarget
   });
 }
+var RULES_INDEX_START = "<!-- AIBLUEPRINT:RULES:START -->";
+var RULES_INDEX_END = "<!-- AIBLUEPRINT:RULES:END -->";
+function titleFromRulePath(rulePath) {
+  return path16.basename(rulePath, path16.extname(rulePath)).replace(/[-_]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+async function readRuleTitle(rulePath) {
+  const content = await import_fs_extra12.default.readFile(rulePath, "utf-8").catch(() => "");
+  const heading = content.match(/^#\s+(.+)$/m)?.[1]?.trim();
+  return heading || titleFromRulePath(rulePath);
+}
+async function collectRuleIndexEntries(rulesDir, rootDir, currentDir = rulesDir) {
+  const entries = await import_fs_extra12.default.readdir(currentDir, { withFileTypes: true }).catch(() => []);
+  const rules = [];
+  for (const entry of entries) {
+    if (IGNORED_ENTRY_NAMES2.has(entry.name))
+      continue;
+    const entryPath = path16.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      rules.push(...await collectRuleIndexEntries(rulesDir, rootDir, entryPath));
+      continue;
+    }
+    if (!entry.isFile() && !entry.isSymbolicLink())
+      continue;
+    if (![".md", ".mdc"].includes(path16.extname(entry.name).toLowerCase()))
+      continue;
+    rules.push({
+      title: await readRuleTitle(entryPath),
+      relativePath: path16.relative(rootDir, entryPath)
+    });
+  }
+  return rules.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+function stripGeneratedRulesIndex(content) {
+  const start = content.indexOf(RULES_INDEX_START);
+  const end = content.indexOf(RULES_INDEX_END);
+  if (start === -1 || end === -1 || end < start) {
+    return content.trimEnd();
+  }
+  const beforeStart = content.slice(0, start);
+  const headingIndex = beforeStart.lastIndexOf(`
+## Rules`);
+  const blockStart = headingIndex === -1 ? start : headingIndex + 1;
+  return `${content.slice(0, blockStart).trimEnd()}
+${content.slice(end + RULES_INDEX_END.length).trimStart()}`.trimEnd();
+}
+function renderRulesIndexBlock(rules) {
+  const lines = [
+    "## Rules",
+    "",
+    "Detailed focused rules live in `.agents/rules/`. Read the relevant file before acting:",
+    "",
+    RULES_INDEX_START
+  ];
+  if (rules.length === 0) {
+    lines.push("- No repository rules found yet.");
+  } else {
+    for (const rule of rules) {
+      lines.push(`- **${rule.title}** - [${rule.relativePath}](${rule.relativePath})`);
+    }
+  }
+  lines.push(RULES_INDEX_END);
+  return lines.join(`
+`);
+}
+async function readExistingInstructions(rootDir) {
+  const agentsPath = path16.join(rootDir, "AGENTS.md");
+  const claudePath = path16.join(rootDir, "CLAUDE.md");
+  const agentsContent = await import_fs_extra12.default.readFile(agentsPath, "utf-8").catch(() => null);
+  const claudeContent = await import_fs_extra12.default.readFile(claudePath, "utf-8").catch(() => null);
+  if (agentsContent !== null && claudeContent !== null && agentsContent.trim() !== claudeContent.trim()) {
+    return `${agentsContent.trimEnd()}
+
+## Previous Claude Instructions
+
+${claudeContent.trimStart()}`;
+  }
+  if (agentsContent !== null)
+    return agentsContent;
+  if (claudeContent !== null)
+    return claudeContent;
+  return `# Repository Instructions
+`;
+}
+async function copyPathToBackup(result, targetPath) {
+  const stat = await import_fs_extra12.default.lstat(targetPath).catch(() => null);
+  if (!stat)
+    return null;
+  const backupRoot = await ensureBackupPath(result);
+  const backupTarget = path16.join(backupRoot, safeRelativePath(result.rootDir, targetPath));
+  await import_fs_extra12.default.ensureDir(path16.dirname(backupTarget));
+  await import_fs_extra12.default.copy(targetPath, backupTarget, {
+    dereference: false,
+    overwrite: false
+  });
+  return backupTarget;
+}
+async function replaceWithFileSymlink(sourcePath, targetPath) {
+  await import_fs_extra12.default.ensureDir(path16.dirname(targetPath));
+  const relativeSource = path16.relative(path16.dirname(targetPath), sourcePath) || path16.basename(sourcePath);
+  await import_fs_extra12.default.symlink(relativeSource, targetPath, "file");
+}
+async function ensureClaudeInstructionSymlink(result, agentsPath, claudePath) {
+  const agentsRealPath = await realPathIfPossible(agentsPath);
+  const claudeStat = await import_fs_extra12.default.lstat(claudePath).catch(() => null);
+  if (claudeStat?.isSymbolicLink()) {
+    const claudeRealPath = await realPathIfPossible(claudePath);
+    if (agentsRealPath && claudeRealPath && samePath(agentsRealPath, claudeRealPath)) {
+      return;
+    }
+  }
+  if (claudeStat) {
+    await copyPathToBackup(result, claudePath);
+    await import_fs_extra12.default.remove(claudePath);
+  }
+  await replaceWithFileSymlink(agentsPath, claudePath);
+}
+async function writeRepositoryInstructionIndex(result, folders) {
+  const rulesDir = path16.join(folders.agentsDir, "rules");
+  await import_fs_extra12.default.ensureDir(rulesDir);
+  const rules = await collectRuleIndexEntries(rulesDir, folders.rootDir);
+  const existing = stripGeneratedRulesIndex(await readExistingInstructions(folders.rootDir));
+  const content = `${existing}
+
+${renderRulesIndexBlock(rules)}
+`;
+  const agentsPath = path16.join(folders.rootDir, "AGENTS.md");
+  const claudePath = path16.join(folders.rootDir, "CLAUDE.md");
+  const agentsStat = await import_fs_extra12.default.lstat(agentsPath).catch(() => null);
+  if (agentsStat) {
+    await copyPathToBackup(result, agentsPath);
+    if (agentsStat.isSymbolicLink()) {
+      await import_fs_extra12.default.remove(agentsPath);
+    }
+  }
+  await import_fs_extra12.default.writeFile(agentsPath, content, "utf-8");
+  await ensureClaudeInstructionSymlink(result, agentsPath, claudePath);
+  result.instructionIndex = {
+    agentsPath,
+    claudePath,
+    indexedRules: rules.map((rule) => rule.relativePath)
+  };
+}
 async function unifyAgentsConfiguration(options = {}) {
+  const scope = options.scope ?? "global";
   const folders = resolveFolders(options);
-  const candidates = getContainerCandidates(options);
   const instructionCandidates = getInstructionFileCandidates(options);
+  const candidates = scope === "repository" ? getRepositoryContainerCandidates(options) : getContainerCandidates(options);
   const result = {
     rootDir: folders.rootDir,
     agentsDir: folders.agentsDir,
+    scope,
     backupPath: null,
     imported: [],
     duplicates: [],
     renamed: [],
     linked: [],
     alreadyLinked: [],
-    skipped: []
+    skipped: [],
+    instructionIndex: null
   };
   const destinationByCategory = {
     skills: path16.join(folders.agentsDir, "skills"),
     agents: path16.join(folders.agentsDir, "agents"),
-    instructions: path16.join(folders.agentsDir, "AGENTS.md")
+    instructions: path16.join(folders.agentsDir, "AGENTS.md"),
+    rules: path16.join(folders.agentsDir, "rules")
   };
   await import_fs_extra12.default.ensureDir(folders.agentsDir);
   await importInstructionFiles(instructionCandidates, destinationByCategory.instructions, result);
-  for (const category of ["skills", "agents"]) {
+  const categories = scope === "repository" ? ["skills", "agents", "rules"] : ["skills", "agents"];
+  for (const category of categories) {
     await importCategoryEntries(category, candidates, destinationByCategory[category], result);
   }
   for (const candidate of candidates) {
@@ -35478,6 +35741,9 @@ async function unifyAgentsConfiguration(options = {}) {
   for (const candidate of instructionCandidates) {
     await linkInstructionFile(candidate, destinationByCategory.instructions, result);
   }
+  if (scope === "repository") {
+    await writeRepositoryInstructionIndex(result, folders);
+  }
   return result;
 }
 
@@ -35498,7 +35764,8 @@ async function agentsUnifyCommand(params = {}) {
     console.log(source_default.blue.bold(`
 AIBlueprint agents unify ${source_default.gray(`v${getVersion()}`)}
 `));
-    console.log(source_default.gray("Centralizing reusable skills and agents into .agents, then rendering Codex agents"));
+    console.log(source_default.gray(`Scope: ${params.scope ?? "global"}`));
+    console.log(source_default.gray("Centralizing reusable agent configuration into .agents, then rendering Codex agents"));
     const result = await unifyAgentsConfiguration(params);
     const codexResult = await renderCodexAgentsFromMarkdown(params);
     console.log(source_default.green(`
@@ -35507,7 +35774,14 @@ Unify complete`));
     printCategorySummary(result, "instructions");
     printCategorySummary(result, "skills");
     printCategorySummary(result, "agents");
+    if (result.scope === "repository") {
+      printCategorySummary(result, "rules");
+    }
     console.log(source_default.gray(`  codex agents: ${codexResult.rendered.length} rendered, ${codexResult.skipped.length} skipped`));
+    if (result.instructionIndex) {
+      console.log(source_default.gray(`  rules index: ${result.instructionIndex.indexedRules.length} rules indexed in ${result.instructionIndex.agentsPath}`));
+      console.log(source_default.gray(`  Claude instructions: ${result.instructionIndex.claudePath}`));
+    }
     if (result.backupPath) {
       console.log(source_default.gray(`  Source backups: ${result.backupPath}`));
     }
@@ -35553,6 +35827,359 @@ Codex agents render failed:`), error);
   }
 }
 
+// src/lib/session-unifier.ts
+var import_fs_extra14 = __toESM(require_lib4(), 1);
+import crypto2 from "crypto";
+import os15 from "os";
+import path18 from "path";
+
+// src/lib/backup-utils.ts
+var import_fs_extra13 = __toESM(require_lib4(), 1);
+import path17 from "path";
+import os14 from "os";
+var BACKUP_BASE_DIR = path17.join(os14.homedir(), ".config", "aiblueprint", "backup");
+function getBackupDir() {
+  return process.env.AIBLUEPRINT_BACKUP_DIR || BACKUP_BASE_DIR;
+}
+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 backupBaseDir = getBackupDir();
+  const exists = await import_fs_extra13.default.pathExists(backupBaseDir);
+  if (!exists) {
+    return [];
+  }
+  const entries = await import_fs_extra13.default.readdir(backupBaseDir, { 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: path17.join(backupBaseDir, 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"];
+var MANAGED_FOLDERS = [".claude", ".codex", ".agents"];
+async function copyForBackup(sourcePath, destPath) {
+  await import_fs_extra13.default.copy(sourcePath, destPath, {
+    overwrite: true,
+    dereference: false
+  });
+}
+async function hasMeaningfulContent(dir) {
+  if (!await import_fs_extra13.default.pathExists(dir))
+    return false;
+  const files = await import_fs_extra13.default.readdir(dir);
+  return files.some((f) => f !== ".DS_Store");
+}
+async function loadBackup(backupPath, claudeDir, codexDir, agentsDir) {
+  const exists = await import_fs_extra13.default.pathExists(backupPath);
+  if (!exists) {
+    throw new Error(`Backup not found: ${backupPath}`);
+  }
+  const managedDestinations = {
+    ".claude": claudeDir,
+    ".codex": codexDir,
+    ".agents": agentsDir
+  };
+  let restoredManagedFolder = false;
+  for (const folderName of MANAGED_FOLDERS) {
+    const sourcePath = path17.join(backupPath, folderName);
+    const destPath = managedDestinations[folderName];
+    if (!destPath || !await import_fs_extra13.default.pathExists(sourcePath))
+      continue;
+    await import_fs_extra13.default.ensureDir(destPath);
+    await copyForBackup(sourcePath, destPath);
+    restoredManagedFolder = true;
+  }
+  if (!restoredManagedFolder) {
+    await import_fs_extra13.default.ensureDir(claudeDir);
+    for (const item of CLAUDE_ITEMS) {
+      const sourcePath = path17.join(backupPath, item);
+      const destPath = path17.join(claudeDir, item);
+      if (await import_fs_extra13.default.pathExists(sourcePath)) {
+        await copyForBackup(sourcePath, destPath);
+      }
+    }
+    if (agentsDir) {
+      const agentsBackupPath = path17.join(backupPath, AGENTS_BACKUP_SUBDIR);
+      if (await import_fs_extra13.default.pathExists(agentsBackupPath)) {
+        await import_fs_extra13.default.ensureDir(agentsDir);
+        await copyForBackup(agentsBackupPath, agentsDir);
+      }
+    }
+  }
+}
+async function createBackup(claudeDir, codexDir, agentsDir) {
+  const claudeHasContent = await hasMeaningfulContent(claudeDir);
+  const codexHasContent = codexDir ? await hasMeaningfulContent(codexDir) : false;
+  const agentsHasContent = agentsDir ? await hasMeaningfulContent(agentsDir) : false;
+  if (!claudeHasContent && !codexHasContent && !agentsHasContent) {
+    return null;
+  }
+  const timestamp3 = formatDate(new Date);
+  const backupPath = path17.join(getBackupDir(), timestamp3);
+  await import_fs_extra13.default.ensureDir(backupPath);
+  if (claudeHasContent) {
+    await copyForBackup(claudeDir, path17.join(backupPath, ".claude"));
+  }
+  if (codexHasContent && codexDir) {
+    await copyForBackup(codexDir, path17.join(backupPath, ".codex"));
+  }
+  if (agentsHasContent && agentsDir) {
+    const destPath = path17.join(backupPath, AGENTS_BACKUP_SUBDIR);
+    await copyForBackup(agentsDir, destPath);
+  }
+  return backupPath;
+}
+
+// src/lib/session-unifier.ts
+var MANAGED_FOLDERS2 = [".claude", ".codex", ".agents"];
+var SESSION_PATHS = {
+  ".claude": ["projects", "sessions"],
+  ".codex": ["sessions", "archived_sessions", "browser/sessions"],
+  ".agents": ["sessions"]
+};
+async function listSnapshotSources(parentDir, type) {
+  if (!await import_fs_extra14.default.pathExists(parentDir))
+    return [];
+  const entries = await import_fs_extra14.default.readdir(parentDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => ({
+    name: entry.name,
+    path: path18.join(parentDir, entry.name),
+    type
+  }));
+}
+async function collectSnapshotSources(folders) {
+  const storePaths = getConfigStorePaths(folders.rootDir);
+  const sources = [
+    ...await listSnapshotSources(storePaths.configsDir, "config"),
+    ...await listSnapshotSources(storePaths.backupsDir, "backup")
+  ];
+  if (path18.resolve(folders.rootDir) === os15.homedir()) {
+    sources.push(...await listSnapshotSources(getBackupDir(), "legacy-backup"));
+  }
+  return sources.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function snapshotFolderPath(snapshot, folder) {
+  const managedPath = path18.join(snapshot.path, folder);
+  if (await import_fs_extra14.default.pathExists(managedPath))
+    return managedPath;
+  if (snapshot.type === "legacy-backup") {
+    if (folder === ".claude")
+      return snapshot.path;
+    const legacyAgentsPath = path18.join(snapshot.path, ".agents");
+    if (folder === ".agents" && await import_fs_extra14.default.pathExists(legacyAgentsPath)) {
+      return legacyAgentsPath;
+    }
+  }
+  return null;
+}
+function sanitizeSourceTag(snapshot) {
+  return `${snapshot.type}-${snapshot.name}`.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "snapshot";
+}
+function withSourceSuffix(targetPath, sourceTag, index) {
+  const parsed = path18.parse(targetPath);
+  const suffix = index === 1 ? sourceTag : `${sourceTag}-${index}`;
+  if (parsed.ext && parsed.name) {
+    return path18.join(parsed.dir, `${parsed.name}--${suffix}${parsed.ext}`);
+  }
+  return path18.join(parsed.dir, `${parsed.base}--${suffix}`);
+}
+async function uniqueConflictPath(targetPath, sourceTag) {
+  let index = 1;
+  while (true) {
+    const candidate = withSourceSuffix(targetPath, sourceTag, index);
+    if (!await import_fs_extra14.default.pathExists(candidate))
+      return candidate;
+    index++;
+  }
+}
+function hashString2(value) {
+  return crypto2.createHash("sha256").update(value).digest("hex");
+}
+async function hashPath2(targetPath) {
+  const stat = await import_fs_extra14.default.lstat(targetPath);
+  if (stat.isSymbolicLink()) {
+    return hashString2(`symlink:${await import_fs_extra14.default.readlink(targetPath)}`);
+  }
+  if (stat.isFile()) {
+    const hash = crypto2.createHash("sha256");
+    hash.update("file:");
+    hash.update(await import_fs_extra14.default.readFile(targetPath));
+    return hash.digest("hex");
+  }
+  if (stat.isDirectory()) {
+    const entries = (await import_fs_extra14.default.readdir(targetPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+    const hash = crypto2.createHash("sha256");
+    hash.update("dir:");
+    for (const entry of entries) {
+      hash.update(entry.name);
+      hash.update("\x00");
+      hash.update(await hashPath2(path18.join(targetPath, entry.name)));
+      hash.update("\x00");
+    }
+    return hash.digest("hex");
+  }
+  return hashString2(`other:${stat.mode}:${stat.size}`);
+}
+async function mergeSessionPath(params) {
+  const {
+    sourcePath,
+    destinationPath,
+    folder,
+    sessionRoot,
+    snapshot,
+    sourceTag,
+    result
+  } = params;
+  const sourceStat = await import_fs_extra14.default.lstat(sourcePath).catch(() => null);
+  if (!sourceStat)
+    return;
+  const destinationStat = await import_fs_extra14.default.lstat(destinationPath).catch(() => null);
+  if (sourceStat.isDirectory() && destinationStat?.isDirectory()) {
+    const entries = await import_fs_extra14.default.readdir(sourcePath);
+    await import_fs_extra14.default.ensureDir(destinationPath);
+    for (const entry of entries) {
+      await mergeSessionPath({
+        sourcePath: path18.join(sourcePath, entry),
+        destinationPath: path18.join(destinationPath, entry),
+        folder,
+        sessionRoot,
+        snapshot,
+        sourceTag,
+        result
+      });
+    }
+    return;
+  }
+  if (!destinationStat) {
+    await import_fs_extra14.default.ensureDir(path18.dirname(destinationPath));
+    await import_fs_extra14.default.copy(sourcePath, destinationPath, {
+      overwrite: false,
+      dereference: false
+    });
+    result.imported.push({
+      folder,
+      sessionRoot,
+      from: sourcePath,
+      to: destinationPath,
+      snapshot: snapshot.name
+    });
+    return;
+  }
+  if (await hashPath2(sourcePath) === await hashPath2(destinationPath)) {
+    result.duplicates.push({
+      folder,
+      sessionRoot,
+      from: sourcePath,
+      existing: destinationPath,
+      snapshot: snapshot.name
+    });
+    return;
+  }
+  const conflictPath = await uniqueConflictPath(destinationPath, sourceTag);
+  await import_fs_extra14.default.ensureDir(path18.dirname(conflictPath));
+  await import_fs_extra14.default.copy(sourcePath, conflictPath, {
+    overwrite: false,
+    dereference: false
+  });
+  result.conflicts.push({
+    folder,
+    sessionRoot,
+    from: sourcePath,
+    to: conflictPath,
+    snapshot: snapshot.name,
+    reason: "Same session path with different content"
+  });
+}
+async function unifySessionsFromSnapshots(options = {}) {
+  const folders = resolveFolders(options);
+  const snapshots = await collectSnapshotSources(folders);
+  const destinationByFolder = {
+    ".claude": folders.claudeDir,
+    ".codex": folders.codexDir,
+    ".agents": folders.agentsDir
+  };
+  const result = {
+    rootDir: folders.rootDir,
+    scannedSnapshots: snapshots,
+    imported: [],
+    duplicates: [],
+    conflicts: []
+  };
+  for (const snapshot of snapshots) {
+    const sourceTag = sanitizeSourceTag(snapshot);
+    for (const folder of MANAGED_FOLDERS2) {
+      const sourceFolder = await snapshotFolderPath(snapshot, folder);
+      if (!sourceFolder)
+        continue;
+      for (const sessionRoot of SESSION_PATHS[folder]) {
+        const sourcePath = path18.join(sourceFolder, sessionRoot);
+        if (!await import_fs_extra14.default.pathExists(sourcePath))
+          continue;
+        await mergeSessionPath({
+          sourcePath,
+          destinationPath: path18.join(destinationByFolder[folder], sessionRoot),
+          folder,
+          sessionRoot,
+          snapshot,
+          sourceTag,
+          result
+        });
+      }
+    }
+  }
+  return result;
+}
+
+// src/commands/session-unify.ts
+function summarizeByFolder(entries) {
+  const counts = new Map;
+  for (const entry of entries) {
+    counts.set(entry.folder, (counts.get(entry.folder) ?? 0) + 1);
+  }
+  if (counts.size === 0)
+    return "none";
+  return [...counts.entries()].map(([folder, count]) => `${folder}: ${count}`).join(", ");
+}
+async function sessionsUnifyCommand(params = {}) {
+  try {
+    console.log(source_default.blue("Unifying saved sessions from configs and backups..."));
+    const result = await unifySessionsFromSnapshots(params);
+    console.log(source_default.green("Session unify complete"));
+    console.log(source_default.gray(`  Snapshots scanned: ${result.scannedSnapshots.length}`));
+    console.log(source_default.gray(`  Imported: ${result.imported.length} (${summarizeByFolder(result.imported)})`));
+    console.log(source_default.gray(`  Duplicates skipped: ${result.duplicates.length}`));
+    console.log(source_default.gray(`  Conflicts preserved: ${result.conflicts.length}`));
+    if (result.conflicts.length > 0) {
+      console.log(source_default.yellow(`
+Conflicting session paths were copied with source suffixes:`));
+      for (const conflict of result.conflicts.slice(0, 10)) {
+        console.log(source_default.yellow(`  ${conflict.to}`));
+      }
+      if (result.conflicts.length > 10) {
+        console.log(source_default.yellow(`  ...and ${result.conflicts.length - 10} more`));
+      }
+    }
+  } catch (error) {
+    console.error(source_default.red("Session unify failed:"), error);
+    process.exit(1);
+  }
+}
+
 // node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
 var import_picocolors = __toESM(require_picocolors(), 1);
@@ -36269,12 +36896,12 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 };
 
 // src/commands/pro.ts
-import path19 from "path";
+import path21 from "path";
 
 // src/lib/pro-installer.ts
-var import_fs_extra13 = __toESM(require_lib4(), 1);
-import os14 from "os";
-import path17 from "path";
+var import_fs_extra15 = __toESM(require_lib4(), 1);
+import os16 from "os";
+import path19 from "path";
 import { exec as exec3 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec3);
@@ -36282,9 +36909,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(path17.sep);
+  const segments = relativePath.split(path19.sep);
   const first = segments[0];
-  const rest = segments.slice(1).join(path17.sep);
+  const rest = segments.slice(1).join(path19.sep);
   if (first === "claude-config") {
     return { kind: "claude", relativePath: rest };
   }
@@ -36300,7 +36927,7 @@ function routePath(relativePath) {
   return { kind: "claude", relativePath };
 }
 function getCacheRepoDir() {
-  return path17.join(os14.homedir(), ".config", "aiblueprint", "pro-repos", "aiblueprint-cli-premium");
+  return path19.join(os16.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?:\/\//, "")}`;
@@ -36314,21 +36941,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_extra13.default.pathExists(path17.join(cacheDir, ".git"))) {
+  if (await import_fs_extra15.default.pathExists(path19.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra13.default.remove(cacheDir);
-      await import_fs_extra13.default.ensureDir(path17.dirname(cacheDir));
+      await import_fs_extra15.default.remove(cacheDir);
+      await import_fs_extra15.default.ensureDir(path19.dirname(cacheDir));
       await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra13.default.ensureDir(path17.dirname(cacheDir));
+    await import_fs_extra15.default.ensureDir(path19.dirname(cacheDir));
     await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
   for (const candidate of CONFIG_FOLDER_CANDIDATES2) {
-    const candidatePath = path17.join(cacheDir, candidate);
-    if (await import_fs_extra13.default.pathExists(candidatePath)) {
+    const candidatePath = path19.join(cacheDir, candidate);
+    if (await import_fs_extra15.default.pathExists(candidatePath)) {
       return candidatePath;
     }
   }
@@ -36336,38 +36963,38 @@ async function cloneOrUpdateRepo(token) {
 }
 async function copyConfigFromCache(cacheConfigDir, dest, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra13.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra15.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name === ".DS_Store" || entry.name === "node_modules")
         continue;
-      const sourcePath = path17.join(dir, entry.name);
-      const relativePath = path17.relative(baseDir, sourcePath);
+      const sourcePath = path19.join(dir, entry.name);
+      const relativePath = path19.relative(baseDir, sourcePath);
       const route = routePath(relativePath);
       if (route.kind === "skip")
         continue;
       if (route.kind === "agents-category") {
-        if (relativePath.split(path17.sep).length === 1) {
+        if (relativePath.split(path19.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 = path17.join(targetBase, route.relativePath);
+      const targetPath = path19.join(targetBase, route.relativePath);
       if (entry.isDirectory()) {
-        await import_fs_extra13.default.ensureDir(targetPath);
+        await import_fs_extra15.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_extra13.default.readFile(sourcePath, "utf-8");
+        const content = await import_fs_extra15.default.readFile(sourcePath, "utf-8");
         const replaced = replaceClaudePathPlaceholder(content, dest.claudeDir);
-        await import_fs_extra13.default.ensureDir(path17.dirname(targetPath));
-        await import_fs_extra13.default.writeFile(targetPath, replaced, "utf-8");
+        await import_fs_extra15.default.ensureDir(path19.dirname(targetPath));
+        await import_fs_extra15.default.writeFile(targetPath, replaced, "utf-8");
         onProgress?.(relativePath, "file");
       } else {
-        await import_fs_extra13.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra15.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -36375,21 +37002,21 @@ async function copyConfigFromCache(cacheConfigDir, dest, onProgress) {
   await walk(cacheConfigDir);
 }
 async function copyAgentCategory(sourceCategoryDir, category, agentsDir, claudeDir, onProgress) {
-  const agentsCategoryDir = path17.join(agentsDir, category);
-  await import_fs_extra13.default.ensureDir(agentsCategoryDir);
-  const entries = await import_fs_extra13.default.readdir(sourceCategoryDir, { withFileTypes: true });
+  const agentsCategoryDir = path19.join(agentsDir, category);
+  await import_fs_extra15.default.ensureDir(agentsCategoryDir);
+  const entries = await import_fs_extra15.default.readdir(sourceCategoryDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".DS_Store")
       continue;
-    const src = path17.join(sourceCategoryDir, entry.name);
-    const dst = path17.join(agentsCategoryDir, entry.name);
-    const claudeTop = path17.join(claudeDir, category, entry.name);
-    const claudeStat = await import_fs_extra13.default.lstat(claudeTop).catch(() => null);
+    const src = path19.join(sourceCategoryDir, entry.name);
+    const dst = path19.join(agentsCategoryDir, entry.name);
+    const claudeTop = path19.join(claudeDir, category, entry.name);
+    const claudeStat = await import_fs_extra15.default.lstat(claudeTop).catch(() => null);
     if (claudeStat && !claudeStat.isSymbolicLink()) {
       onProgress?.(`${category}/${entry.name} (skipped - real dir in claude)`, "file");
       continue;
     }
-    await import_fs_extra13.default.copy(src, dst, { overwrite: true });
+    await import_fs_extra15.default.copy(src, dst, { overwrite: true });
     await applyPathPlaceholders(dst, claudeDir);
     onProgress?.(`${category}/${entry.name}`, entry.isDirectory() ? "directory" : "file");
   }
@@ -36408,8 +37035,8 @@ async function downloadFromPrivateGitHub(repo, branch, relativePath, targetPath,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra13.default.ensureDir(path17.dirname(targetPath));
-    await import_fs_extra13.default.writeFile(targetPath, Buffer.from(content));
+    await import_fs_extra15.default.ensureDir(path19.dirname(targetPath));
+    await import_fs_extra15.default.writeFile(targetPath, Buffer.from(content));
     return true;
   } catch (error) {
     console.error(`Error downloading ${relativePath}:`, error);
@@ -36434,10 +37061,10 @@ async function downloadDirectoryFromPrivateGitHub(repo, branch, dirPath, targetD
       console.error(`Unexpected response for directory ${dirPath}`);
       return false;
     }
-    await import_fs_extra13.default.ensureDir(targetDir);
+    await import_fs_extra15.default.ensureDir(targetDir);
     for (const file of files) {
       const relativePath = dirPath ? `${dirPath}/${file.name}` : file.name;
-      const targetPath = path17.join(targetDir, file.name);
+      const targetPath = path19.join(targetDir, file.name);
       const displayPath = relativePath.replace(/^(agents-config|ai-coding|claude-code-config|ai-config)\//, "");
       if (file.type === "file") {
         onProgress?.(displayPath, "file");
@@ -36460,8 +37087,8 @@ async function installProConfigs(options) {
     codexFolder,
     agentsFolder
   });
-  await import_fs_extra13.default.ensureDir(claudeDir);
-  await import_fs_extra13.default.ensureDir(agentsDir);
+  await import_fs_extra15.default.ensureDir(claudeDir);
+  await import_fs_extra15.default.ensureDir(agentsDir);
   const dest = { claudeDir, codexDir, agentsDir };
   try {
     const cacheConfigDir = await cloneOrUpdateRepo(githubToken);
@@ -36471,7 +37098,7 @@ async function installProConfigs(options) {
   } catch (error) {
     console.warn("Git caching failed, falling back to API download");
   }
-  const tempDir = path17.join(os14.tmpdir(), `aiblueprint-premium-${Date.now()}`);
+  const tempDir = path19.join(os16.tmpdir(), `aiblueprint-premium-${Date.now()}`);
   try {
     let success = false;
     for (const candidate of CONFIG_FOLDER_CANDIDATES2) {
@@ -36485,8 +37112,8 @@ async function installProConfigs(options) {
     await copyConfigFromCache(tempDir, dest, onProgress);
     await replacePathPlaceholdersInDir(claudeDir, claudeDir);
     for (const category of AGENT_CATEGORIES) {
-      const agentsCategoryDir = path17.join(agentsDir, category);
-      if (await import_fs_extra13.default.pathExists(agentsCategoryDir)) {
+      const agentsCategoryDir = path19.join(agentsDir, category);
+      if (await import_fs_extra15.default.pathExists(agentsCategoryDir)) {
         await replacePathPlaceholdersInDir(agentsCategoryDir, claudeDir);
       }
     }
@@ -36495,7 +37122,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_extra13.default.remove(tempDir);
+      await import_fs_extra15.default.remove(tempDir);
     } catch {}
   }
 }
@@ -36506,27 +37133,27 @@ async function syncAllAgentSymlinks(agentsDir, claudeDir) {
 }
 
 // src/lib/token-storage.ts
-var import_fs_extra14 = __toESM(require_lib4(), 1);
-import os15 from "os";
-import path18 from "path";
+var import_fs_extra16 = __toESM(require_lib4(), 1);
+import os17 from "os";
+import path20 from "path";
 function getConfigDir() {
-  const platform = os15.platform();
+  const platform = os17.platform();
   if (platform === "win32") {
-    const appData = process.env.APPDATA || path18.join(os15.homedir(), "AppData", "Roaming");
-    return path18.join(appData, "aiblueprint");
+    const appData = process.env.APPDATA || path20.join(os17.homedir(), "AppData", "Roaming");
+    return path20.join(appData, "aiblueprint");
   } else {
-    const configHome = process.env.XDG_CONFIG_HOME || path18.join(os15.homedir(), ".config");
-    return path18.join(configHome, "aiblueprint");
+    const configHome = process.env.XDG_CONFIG_HOME || path20.join(os17.homedir(), ".config");
+    return path20.join(configHome, "aiblueprint");
   }
 }
 function getTokenFilePath2() {
-  return path18.join(getConfigDir(), "token.txt");
+  return path20.join(getConfigDir(), "token.txt");
 }
 async function saveToken(githubToken) {
   const tokenFile = getTokenFilePath2();
-  const configDir = path18.dirname(tokenFile);
+  const configDir = path20.dirname(tokenFile);
   try {
-    await import_fs_extra14.default.ensureDir(configDir);
+    await import_fs_extra16.default.ensureDir(configDir);
   } catch (error) {
     if (error.code === "EACCES") {
       throw new Error(`Permission denied creating config directory: ${configDir}
@@ -36534,15 +37161,15 @@ async function saveToken(githubToken) {
     }
     throw error;
   }
-  await import_fs_extra14.default.writeFile(tokenFile, githubToken, { mode: 384 });
+  await import_fs_extra16.default.writeFile(tokenFile, githubToken, { mode: 384 });
 }
 async function getToken() {
   const tokenFile = getTokenFilePath2();
-  if (!await import_fs_extra14.default.pathExists(tokenFile)) {
+  if (!await import_fs_extra16.default.pathExists(tokenFile)) {
     return null;
   }
   try {
-    const token = await import_fs_extra14.default.readFile(tokenFile, "utf-8");
+    const token = await import_fs_extra16.default.readFile(tokenFile, "utf-8");
     return token.trim();
   } catch (error) {
     return null;
@@ -36551,12 +37178,12 @@ async function getToken() {
 function getTokenInfo() {
   return {
     path: getTokenFilePath2(),
-    platform: os15.platform()
+    platform: os17.platform()
   };
 }
 
 // src/commands/pro.ts
-var import_fs_extra15 = __toESM(require_lib4(), 1);
+var import_fs_extra17 = __toESM(require_lib4(), 1);
 var API_URL = "https://codeline.app/api/products";
 var PRODUCT_IDS = ["prd_XJVgxVPbGG", "prd_NKabAkdOkw"];
 async function countInstalledItems(claudeDir) {
@@ -36565,20 +37192,20 @@ async function countInstalledItems(claudeDir) {
     skills: 0
   };
   try {
-    const agentsDir = path19.join(claudeDir, "agents");
-    if (await import_fs_extra15.default.pathExists(agentsDir)) {
-      const files = await import_fs_extra15.default.readdir(agentsDir);
+    const agentsDir = path21.join(claudeDir, "agents");
+    if (await import_fs_extra17.default.pathExists(agentsDir)) {
+      const files = await import_fs_extra17.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 = path19.join(claudeDir, "skills");
-    if (await import_fs_extra15.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra15.default.readdir(skillsDir);
+    const skillsDir = path21.join(claudeDir, "skills");
+    if (await import_fs_extra17.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra17.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra15.default.stat(path19.join(skillsDir, item));
+        const stat = await import_fs_extra17.default.stat(path21.join(skillsDir, item));
         return stat.isDirectory();
       }));
       counts.skills = dirs.filter(Boolean).length;
@@ -36786,9 +37413,9 @@ async function proUpdateCommand(options = {}) {
 }
 
 // src/lib/sync-utils.ts
-var import_fs_extra16 = __toESM(require_lib4(), 1);
-import path20 from "path";
-import crypto2 from "crypto";
+var import_fs_extra18 = __toESM(require_lib4(), 1);
+import path22 from "path";
+import crypto3 from "crypto";
 var PREMIUM_REPO2 = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH2 = "main";
 var CONFIG_FOLDER_CANDIDATES3 = ["agents-config", "ai-coding", "claude-code-config", "ai-config"];
@@ -36796,7 +37423,7 @@ function computeFileSha(content) {
   const size = content.length;
   const header = `blob ${size}\x00`;
   const fullContent = Buffer.concat([Buffer.from(header), content]);
-  return crypto2.createHash("sha1").update(fullContent).digest("hex");
+  return crypto3.createHash("sha1").update(fullContent).digest("hex");
 }
 var resolvedConfigFolder = null;
 async function resolveRemoteConfigFolder(githubToken) {
@@ -36858,7 +37485,7 @@ async function listRemoteFilesRecursive(dirPath, githubToken, basePath = "") {
 }
 async function computeLocalFileSha(filePath) {
   try {
-    const content = await import_fs_extra16.default.readFile(filePath);
+    const content = await import_fs_extra18.default.readFile(filePath);
     return computeFileSha(content);
   } catch {
     return null;
@@ -36866,15 +37493,15 @@ async function computeLocalFileSha(filePath) {
 }
 async function listLocalFiles(dir) {
   const files = [];
-  if (!await import_fs_extra16.default.pathExists(dir)) {
+  if (!await import_fs_extra18.default.pathExists(dir)) {
     return files;
   }
-  const items = await import_fs_extra16.default.readdir(dir);
+  const items = await import_fs_extra18.default.readdir(dir);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path20.join(dir, item);
-    const stat = await import_fs_extra16.default.stat(fullPath).catch(() => null);
+    const fullPath = path22.join(dir, item);
+    const stat = await import_fs_extra18.default.stat(fullPath).catch(() => null);
     if (!stat)
       continue;
     if (stat.isDirectory()) {
@@ -36889,13 +37516,13 @@ async function listLocalFiles(dir) {
 }
 async function listLocalFilesRecursive(dir, basePath) {
   const files = [];
-  const items = await import_fs_extra16.default.readdir(dir).catch(() => []);
+  const items = await import_fs_extra18.default.readdir(dir).catch(() => []);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path20.join(dir, item);
+    const fullPath = path22.join(dir, item);
     const relativePath = `${basePath}/${item}`;
-    const stat = await import_fs_extra16.default.stat(fullPath).catch(() => null);
+    const stat = await import_fs_extra18.default.stat(fullPath).catch(() => null);
     if (!stat)
       continue;
     if (stat.isDirectory()) {
@@ -36909,14 +37536,14 @@ async function listLocalFilesRecursive(dir, basePath) {
   return files;
 }
 async function listClaudeRealTopLevel(claudeCategoryDir) {
-  if (!await import_fs_extra16.default.pathExists(claudeCategoryDir))
+  if (!await import_fs_extra18.default.pathExists(claudeCategoryDir))
     return [];
-  const entries = await import_fs_extra16.default.readdir(claudeCategoryDir).catch(() => []);
+  const entries = await import_fs_extra18.default.readdir(claudeCategoryDir).catch(() => []);
   const real = [];
   for (const name of entries) {
     if (name === "node_modules" || name === ".DS_Store")
       continue;
-    const stat = await import_fs_extra16.default.lstat(path20.join(claudeCategoryDir, name)).catch(() => null);
+    const stat = await import_fs_extra18.default.lstat(path22.join(claudeCategoryDir, name)).catch(() => null);
     if (!stat)
       continue;
     if (stat.isDirectory())
@@ -36933,7 +37560,7 @@ async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
   const items = [];
   const useAgents = isAgentCategory(category);
   const localBase = useAgents ? agentsDir : claudeDir;
-  const localDir = path20.join(localBase, category);
+  const localDir = path22.join(localBase, category);
   const remoteCategoryPath = getRemoteCategoryPath(category);
   const remoteFiles = await listRemoteFilesRecursive(remoteCategoryPath, githubToken);
   const localFiles = await listLocalFiles(localDir);
@@ -36947,7 +37574,7 @@ async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
   }
   const localSet = new Set(localFiles);
   for (const [remotePath, { sha, isFolder }] of remoteSet) {
-    const localPath = path20.join(localDir, remotePath);
+    const localPath = path22.join(localDir, remotePath);
     if (isFolder) {
       continue;
     }
@@ -36982,7 +37609,7 @@ async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
     for (const localPath of localSet) {
       agentsTopLevels.add(localPath.split("/")[0]);
     }
-    const claudeCategoryDir = path20.join(claudeDir, category);
+    const claudeCategoryDir = path22.join(claudeDir, category);
     const claudeRealEntries = await listClaudeRealTopLevel(claudeCategoryDir);
     for (const top of claudeRealEntries) {
       if (!remoteTopLevels.has(top))
@@ -37041,13 +37668,13 @@ async function downloadFromPrivateGitHub2(relativePath, targetPath, githubToken,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra16.default.ensureDir(path20.dirname(targetPath));
+    await import_fs_extra18.default.ensureDir(path22.dirname(targetPath));
     if (isTextFile(relativePath)) {
       const textContent = Buffer.from(content).toString("utf-8");
       const transformedContent = transformFileContent(textContent, claudeDir);
-      await import_fs_extra16.default.writeFile(targetPath, transformedContent, "utf-8");
+      await import_fs_extra18.default.writeFile(targetPath, transformedContent, "utf-8");
     } else {
-      await import_fs_extra16.default.writeFile(targetPath, Buffer.from(content));
+      await import_fs_extra18.default.writeFile(targetPath, Buffer.from(content));
     }
     return true;
   } catch {
@@ -37063,27 +37690,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 = path20.join(baseDir, item.relativePath);
+    const targetPath = path22.join(baseDir, item.relativePath);
     if (item.status === "migration" && useAgents) {
       const topName = item.name.split("/")[0];
-      const agentsTop = path20.join(agentsDir, item.category, topName);
-      const claudeTop = path20.join(claudeDir, item.category, topName);
+      const agentsTop = path22.join(agentsDir, item.category, topName);
+      const claudeTop = path22.join(claudeDir, item.category, topName);
       try {
-        const claudeStat = await import_fs_extra16.default.lstat(claudeTop).catch(() => null);
+        const claudeStat = await import_fs_extra18.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_extra16.default.pathExists(agentsTop);
+        const agentsExists = await import_fs_extra18.default.pathExists(agentsTop);
         if (agentsExists) {
           onProgress?.(item.relativePath, "skipping (already in .agents)");
           failed++;
           continue;
         }
         onProgress?.(item.relativePath, "moving to .agents");
-        await import_fs_extra16.default.ensureDir(path20.dirname(agentsTop));
-        await import_fs_extra16.default.move(claudeTop, agentsTop);
+        await import_fs_extra18.default.ensureDir(path22.dirname(agentsTop));
+        await import_fs_extra18.default.move(claudeTop, agentsTop);
         migrated++;
         touchedAgentCategories.add(item.category);
       } catch {
@@ -37093,8 +37720,8 @@ async function syncSelectedItems(claudeDir, items, githubToken, agentsDir, onPro
     }
     if (useAgents) {
       const topName = item.name.split("/")[0];
-      const claudeTop = path20.join(claudeDir, item.category, topName);
-      const claudeTopStat = await import_fs_extra16.default.lstat(claudeTop).catch(() => null);
+      const claudeTop = path22.join(claudeDir, item.category, topName);
+      const claudeTopStat = await import_fs_extra18.default.lstat(claudeTop).catch(() => null);
       if (claudeTopStat && !claudeTopStat.isSymbolicLink()) {
         onProgress?.(item.relativePath, "skipping (real dir in .claude)");
         failed++;
@@ -37104,7 +37731,7 @@ async function syncSelectedItems(claudeDir, items, githubToken, agentsDir, onPro
     if (item.status === "deleted") {
       onProgress?.(item.relativePath, "deleting");
       try {
-        await import_fs_extra16.default.remove(targetPath);
+        await import_fs_extra18.default.remove(targetPath);
         deleted++;
         if (useAgents)
           touchedAgentCategories.add(item.category);
@@ -37441,106 +38068,6 @@ async function proSyncCommand(options = {}) {
   }
 }
 
-// src/lib/backup-utils.ts
-var import_fs_extra17 = __toESM(require_lib4(), 1);
-import path21 from "path";
-import os16 from "os";
-var BACKUP_BASE_DIR = path21.join(os16.homedir(), ".config", "aiblueprint", "backup");
-function formatDate(date) {
-  const pad = (n) => n.toString().padStart(2, "0");
-  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}-${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
-}
-async function listBackups() {
-  const exists = await import_fs_extra17.default.pathExists(BACKUP_BASE_DIR);
-  if (!exists) {
-    return [];
-  }
-  const entries = await import_fs_extra17.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: path21.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_extra17.default.copy(sourcePath, destPath, {
-    overwrite: true,
-    dereference: false,
-    filter: async (src) => {
-      try {
-        const stat = await import_fs_extra17.default.lstat(src);
-        return !stat.isSymbolicLink();
-      } catch {
-        return true;
-      }
-    }
-  });
-}
-async function hasMeaningfulContent(dir) {
-  if (!await import_fs_extra17.default.pathExists(dir))
-    return false;
-  const files = await import_fs_extra17.default.readdir(dir);
-  return files.some((f) => f !== ".DS_Store");
-}
-async function loadBackup(backupPath, claudeDir, agentsDir) {
-  const exists = await import_fs_extra17.default.pathExists(backupPath);
-  if (!exists) {
-    throw new Error(`Backup not found: ${backupPath}`);
-  }
-  await import_fs_extra17.default.ensureDir(claudeDir);
-  for (const item of CLAUDE_ITEMS) {
-    const sourcePath = path21.join(backupPath, item);
-    const destPath = path21.join(claudeDir, item);
-    if (await import_fs_extra17.default.pathExists(sourcePath)) {
-      await copyForBackup(sourcePath, destPath);
-    }
-  }
-  if (agentsDir) {
-    const agentsBackupPath = path21.join(backupPath, AGENTS_BACKUP_SUBDIR);
-    if (await import_fs_extra17.default.pathExists(agentsBackupPath)) {
-      await import_fs_extra17.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 timestamp3 = formatDate(new Date);
-  const backupPath = path21.join(BACKUP_BASE_DIR, timestamp3);
-  await import_fs_extra17.default.ensureDir(backupPath);
-  if (claudeHasContent) {
-    for (const item of CLAUDE_ITEMS) {
-      const sourcePath = path21.join(claudeDir, item);
-      const destPath = path21.join(backupPath, item);
-      if (await import_fs_extra17.default.pathExists(sourcePath)) {
-        await copyForBackup(sourcePath, destPath);
-      }
-    }
-  }
-  if (agentsHasContent && agentsDir) {
-    const destPath = path21.join(backupPath, AGENTS_BACKUP_SUBDIR);
-    await copyForBackup(agentsDir, destPath);
-  }
-  return backupPath;
-}
-
 // src/commands/backup.ts
 function formatBackupDate(date) {
   const now = new Date;
@@ -37561,7 +38088,7 @@ function formatBackupDate(date) {
   return `${date.toLocaleString()} (${relative})`;
 }
 async function backupLoadCommand(options = {}) {
-  const { claudeDir, agentsDir } = resolveFolders(options);
+  const { claudeDir, codexDir, agentsDir } = resolveFolders(options);
   Ie(source_default.blue("\uD83D\uDCE6 Load Backup"));
   const spinner = Y2();
   spinner.start("Scanning for backups...");
@@ -37597,7 +38124,7 @@ async function backupLoadCommand(options = {}) {
     process.exit(0);
   }
   spinner.start("Creating backup of current configuration...");
-  const currentBackup = await createBackup(claudeDir, agentsDir);
+  const currentBackup = await createBackup(claudeDir, codexDir, agentsDir);
   if (currentBackup) {
     spinner.stop(`Current config backed up to: ${source_default.gray(currentBackup)}`);
   } else {
@@ -37605,7 +38132,7 @@ async function backupLoadCommand(options = {}) {
   }
   spinner.start("Restoring backup...");
   try {
-    await loadBackup(selected.path, claudeDir, agentsDir);
+    await loadBackup(selected.path, claudeDir, codexDir, agentsDir);
     spinner.stop("Backup restored successfully");
     M2.success(`Restored configuration from ${source_default.cyan(selected.name)}`);
     Se(source_default.green("✅ Backup loaded successfully"));
@@ -37642,7 +38169,7 @@ function printSnapshots(title, snapshots) {
 }
 async function configsSaveCommand(name, options = {}) {
   try {
-    console.log(source_default.gray("Saving .claude, .codex, and .agents config files..."));
+    console.log(source_default.gray("Saving full .claude, .codex, and .agents folders..."));
     const snapshotPath = await saveNamedConfig(name, options);
     console.log(source_default.green(`Saved config "${name}"`));
     console.log(source_default.gray(snapshotPath));
@@ -37718,19 +38245,19 @@ async function configsBackupsCreateCommand(reason, options = {}) {
 }
 
 // src/commands/openclaw-pro.ts
-import os19 from "os";
-import path24 from "path";
+import os20 from "os";
+import path25 from "path";
 
 // src/lib/openclaw-installer.ts
-var import_fs_extra18 = __toESM(require_lib4(), 1);
-import os17 from "os";
-import path22 from "path";
+var import_fs_extra19 = __toESM(require_lib4(), 1);
+import os18 from "os";
+import path23 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 path22.join(os17.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
+  return path23.join(os18.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
 }
 async function execGitWithAuth2(command, token, repoUrl, cwd) {
   const authenticatedUrl = `https://x-access-token:${token}@${repoUrl.replace(/^https?:\/\//, "")}`;
@@ -37744,33 +38271,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_extra18.default.pathExists(path22.join(cacheDir, ".git"))) {
+  if (await import_fs_extra19.default.pathExists(path23.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth2("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra18.default.remove(cacheDir);
-      await import_fs_extra18.default.ensureDir(path22.dirname(cacheDir));
+      await import_fs_extra19.default.remove(cacheDir);
+      await import_fs_extra19.default.ensureDir(path23.dirname(cacheDir));
       await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra18.default.ensureDir(path22.dirname(cacheDir));
+    await import_fs_extra19.default.ensureDir(path23.dirname(cacheDir));
     await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
-  return path22.join(cacheDir, "openclaw-config");
+  return path23.join(cacheDir, "openclaw-config");
 }
 async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra18.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra19.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = path22.join(dir, entry.name);
-      const relativePath = path22.relative(baseDir, sourcePath);
-      const targetPath = path22.join(targetDir, relativePath);
+      const sourcePath = path23.join(dir, entry.name);
+      const relativePath = path23.relative(baseDir, sourcePath);
+      const targetPath = path23.join(targetDir, relativePath);
       if (entry.isDirectory()) {
-        await import_fs_extra18.default.ensureDir(targetPath);
+        await import_fs_extra19.default.ensureDir(targetPath);
         onProgress?.(relativePath, "directory");
         await walk(sourcePath, baseDir);
       } else {
-        await import_fs_extra18.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra19.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -37779,7 +38306,7 @@ async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
 }
 async function installOpenclawProConfigs(options) {
   const { githubToken, openclawFolder, onProgress } = options;
-  const targetFolder = openclawFolder || path22.join(os17.homedir(), ".openclaw");
+  const targetFolder = openclawFolder || path23.join(os18.homedir(), ".openclaw");
   try {
     const cacheConfigDir = await cloneOrUpdateRepo2(githubToken);
     await copyConfigFromCache2(cacheConfigDir, targetFolder, onProgress);
@@ -37790,28 +38317,28 @@ async function installOpenclawProConfigs(options) {
 }
 
 // src/lib/openclaw-token-storage.ts
-var import_fs_extra19 = __toESM(require_lib4(), 1);
-import os18 from "os";
-import path23 from "path";
+var import_fs_extra20 = __toESM(require_lib4(), 1);
+import os19 from "os";
+import path24 from "path";
 function getConfigDir2() {
-  const platform = os18.platform();
+  const platform = os19.platform();
   if (platform === "win32") {
-    return path23.join(process.env.APPDATA || os18.homedir(), "openclaw");
+    return path24.join(process.env.APPDATA || os19.homedir(), "openclaw");
   }
-  return path23.join(os18.homedir(), ".config", "openclaw");
+  return path24.join(os19.homedir(), ".config", "openclaw");
 }
 function getTokenPath() {
-  return path23.join(getConfigDir2(), "token.txt");
+  return path24.join(getConfigDir2(), "token.txt");
 }
 async function saveOpenclawToken(githubToken) {
   const configDir = getConfigDir2();
-  await import_fs_extra19.default.ensureDir(configDir);
-  await import_fs_extra19.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
+  await import_fs_extra20.default.ensureDir(configDir);
+  await import_fs_extra20.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
 }
 async function getOpenclawToken() {
   const tokenPath = getTokenPath();
-  if (await import_fs_extra19.default.pathExists(tokenPath)) {
-    const token = await import_fs_extra19.default.readFile(tokenPath, "utf8");
+  if (await import_fs_extra20.default.pathExists(tokenPath)) {
+    const token = await import_fs_extra20.default.readFile(tokenPath, "utf8");
     return token.trim();
   }
   return null;
@@ -37819,12 +38346,12 @@ async function getOpenclawToken() {
 function getOpenclawTokenInfo() {
   return {
     path: getTokenPath(),
-    platform: os18.platform()
+    platform: os19.platform()
   };
 }
 
 // src/commands/openclaw-pro.ts
-var import_fs_extra20 = __toESM(require_lib4(), 1);
+var import_fs_extra21 = __toESM(require_lib4(), 1);
 var API_URL2 = "https://codeline.app/api/products";
 var OPENCLAW_PRODUCT_ID = "prd_t2GRwX3aH1";
 var CLAUDE_CODE_TOOLS_INSTRUCTIONS = `
@@ -37931,7 +38458,7 @@ async function openclawProSetupCommand(options = {}) {
       Se(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const openclawDir = options.folder ? path24.resolve(options.folder) : path24.join(os19.homedir(), ".openclaw");
+    const openclawDir = options.folder ? path25.resolve(options.folder) : path25.join(os20.homedir(), ".openclaw");
     const spinner = Y2();
     const onProgress = (file, type) => {
       spinner.message(`Installing: ${source_default.cyan(file)} ${source_default.gray(`(${type})`)}`);
@@ -37944,23 +38471,23 @@ async function openclawProSetupCommand(options = {}) {
     });
     spinner.stop("OpenClaw Pro configurations installed");
     let skillCount = 0;
-    const skillsDir = path24.join(openclawDir, "skills");
-    if (await import_fs_extra20.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra20.default.readdir(skillsDir);
+    const skillsDir = path25.join(openclawDir, "skills");
+    if (await import_fs_extra21.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra21.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra20.default.stat(path24.join(skillsDir, item));
+        const stat = await import_fs_extra21.default.stat(path25.join(skillsDir, item));
         return stat.isDirectory();
       }));
       skillCount = dirs.filter(Boolean).length;
     }
     spinner.start("Setting up workspace TOOLS.md...");
-    const workspaceDir = path24.join(openclawDir, "workspace");
-    const toolsPath = path24.join(workspaceDir, "TOOLS.md");
-    await import_fs_extra20.default.ensureDir(workspaceDir);
-    if (await import_fs_extra20.default.pathExists(toolsPath)) {
-      const existingContent = await import_fs_extra20.default.readFile(toolsPath, "utf-8");
+    const workspaceDir = path25.join(openclawDir, "workspace");
+    const toolsPath = path25.join(workspaceDir, "TOOLS.md");
+    await import_fs_extra21.default.ensureDir(workspaceDir);
+    if (await import_fs_extra21.default.pathExists(toolsPath)) {
+      const existingContent = await import_fs_extra21.default.readFile(toolsPath, "utf-8");
       if (!existingContent.includes("Claude Code CLI")) {
-        await import_fs_extra20.default.appendFile(toolsPath, `
+        await import_fs_extra21.default.appendFile(toolsPath, `
 
 ` + CLAUDE_CODE_TOOLS_INSTRUCTIONS);
         spinner.stop("TOOLS.md updated with Claude Code instructions");
@@ -37974,7 +38501,7 @@ Skills define _how_ tools work. This file is for _your_ specifics — the stuff
 
 ${CLAUDE_CODE_TOOLS_INSTRUCTIONS}
 `;
-      await import_fs_extra20.default.writeFile(toolsPath, defaultToolsMd);
+      await import_fs_extra21.default.writeFile(toolsPath, defaultToolsMd);
       spinner.stop("TOOLS.md created with Claude Code instructions");
     }
     spinner.start("Creating claude-run wrapper...");
@@ -37985,9 +38512,9 @@ ${CLAUDE_CODE_TOOLS_INSTRUCTIONS}
 script -q -c "claude $*" /dev/null
 `;
     const binDir = "/usr/local/bin";
-    const wrapperPath = path24.join(binDir, "claude-run");
+    const wrapperPath = path25.join(binDir, "claude-run");
     try {
-      await import_fs_extra20.default.writeFile(wrapperPath, claudeRunWrapper, { mode: 493 });
+      await import_fs_extra21.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)");
@@ -38036,12 +38563,12 @@ async function openclawProUpdateCommand(options = {}) {
 }
 
 // src/commands/dynamic-scripts.ts
-import path27 from "path";
+import path28 from "path";
 import { homedir } from "os";
 
 // src/lib/script-parser.ts
-var import_fs_extra21 = __toESM(require_lib4(), 1);
-import path25 from "path";
+var import_fs_extra22 = __toESM(require_lib4(), 1);
+import path26 from "path";
 var EXCLUDED_SCRIPTS = ["test", "lint", "format", "start"];
 var EXCLUDED_SUFFIXES = [":test", ":lint", ":test-fixtures", ":start"];
 function shouldIncludeScript(scriptName) {
@@ -38052,12 +38579,12 @@ function shouldIncludeScript(scriptName) {
   return true;
 }
 async function readScriptsPackageJson(claudeDir) {
-  const packageJsonPath = path25.join(claudeDir, "scripts", "package.json");
+  const packageJsonPath = path26.join(claudeDir, "scripts", "package.json");
   try {
-    if (!await import_fs_extra21.default.pathExists(packageJsonPath)) {
+    if (!await import_fs_extra22.default.pathExists(packageJsonPath)) {
       return null;
     }
-    const content = await import_fs_extra21.default.readFile(packageJsonPath, "utf-8");
+    const content = await import_fs_extra22.default.readFile(packageJsonPath, "utf-8");
     const parsed = JSON.parse(content);
     return parsed.scripts || null;
   } catch (error) {
@@ -38101,14 +38628,14 @@ function groupScriptsByPrefix(commands) {
 }
 
 // src/commands/script-runner.ts
-var import_fs_extra22 = __toESM(require_lib4(), 1);
+var import_fs_extra23 = __toESM(require_lib4(), 1);
 import { spawn as spawn2 } from "child_process";
 import { execSync as execSync4 } from "child_process";
-import path26 from "path";
-import os20 from "os";
+import path27 from "path";
+import os21 from "os";
 function checkCommand2(cmd) {
   try {
-    const isWindows2 = os20.platform() === "win32";
+    const isWindows2 = os21.platform() === "win32";
     const whichCmd = isWindows2 ? `where ${cmd}` : `which ${cmd}`;
     execSync4(whichCmd, { stdio: "ignore" });
     return true;
@@ -38134,18 +38661,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 = path26.join(claudeDir, "scripts");
-  if (!await import_fs_extra22.default.pathExists(scriptsDir)) {
+  const scriptsDir = path27.join(claudeDir, "scripts");
+  if (!await import_fs_extra23.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 = path26.join(scriptsDir, "package.json");
-  if (!await import_fs_extra22.default.pathExists(packageJsonPath)) {
+  const packageJsonPath = path27.join(scriptsDir, "package.json");
+  if (!await import_fs_extra23.default.pathExists(packageJsonPath)) {
     console.error(source_default.red(`package.json not found in ${scriptsDir}`));
     return 1;
   }
-  const packageJson = await import_fs_extra22.default.readJson(packageJsonPath);
+  const packageJson = await import_fs_extra23.default.readJson(packageJsonPath);
   if (!packageJson.scripts || !packageJson.scripts[scriptName]) {
     console.error(source_default.red(`Script "${scriptName}" not found in package.json`));
     return 1;
@@ -38168,7 +38695,7 @@ async function executeScript(scriptName, claudeDir) {
 
 // src/commands/dynamic-scripts.ts
 function getClaudeDir(parentOptions) {
-  return parentOptions.claudeCodeFolder || parentOptions.folder ? path27.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path27.join(homedir(), ".claude");
+  return parentOptions.claudeCodeFolder || parentOptions.folder ? path28.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path28.join(homedir(), ".claude");
 }
 async function registerDynamicScriptCommands(claudeCodeCmd, claudeDir) {
   const scripts = await readScriptsPackageJson(claudeDir);
@@ -38230,13 +38757,21 @@ function registerAgentsCommands(cmd) {
       codexFolder: parentOptions.codexFolder
     });
   });
-  cmd.command("unify").description("Unify skills and agents into .agents, then render Codex TOML agents").action((options, command) => {
+  cmd.command("unify [scope]").description("Unify agent configuration into .agents (scope: global or repository; default: global)").action((scope, options, command) => {
     const parentOptions = command.parent.opts();
+    const selectedScope = scope ?? "global";
+    if (selectedScope !== "global" && selectedScope !== "repository") {
+      console.error(source_default.red(`Invalid unify scope: ${selectedScope}`));
+      console.error(source_default.gray("Use `global` or `repository`."));
+      process.exitCode = 1;
+      return;
+    }
     return agentsUnifyCommand({
-      folder: parentOptions.folder,
+      folder: parentOptions.folder ?? (selectedScope === "repository" ? process.cwd() : undefined),
       claudeCodeFolder: parentOptions.claudeCodeFolder,
       codexFolder: parentOptions.codexFolder,
-      agentsFolder: parentOptions.agentsFolder
+      agentsFolder: parentOptions.agentsFolder,
+      scope: selectedScope
     });
   });
   cmd.command("codex-agents").description("Render shared Markdown agents from .agents/agents into Codex TOML custom agents").option("--overwrite", "Overwrite existing non-generated Codex agent files").action((options, command) => {
@@ -38249,6 +38784,12 @@ function registerAgentsCommands(cmd) {
       overwrite: options.overwrite
     });
   });
+  const configCmd = cmd.command("config").description("Manage cross-tool agent configuration data");
+  const configUnifyCmd = configCmd.command("unify").description("Merge saved configuration data back into the current folders");
+  configUnifyCmd.command("sessions").description("Import saved session history from configs and backups into current .claude/.codex/.agents folders").action((options, command) => {
+    const folderOptions = readConfigOptions(command, options);
+    return sessionsUnifyCommand(folderOptions);
+  });
   const proCmd = cmd.command("pro").description("Manage AIBlueprint CLI Premium features");
   proCmd.command("activate [token]").description("Activate AIBlueprint CLI Premium with your access token").action((token) => {
     proActivateCommand(token);
@@ -38289,6 +38830,7 @@ function registerAgentsCommands(cmd) {
     backupLoadCommand({
       folder: parentOptions.folder,
       claudeCodeFolder: parentOptions.claudeCodeFolder,
+      codexFolder: parentOptions.codexFolder,
       agentsFolder: parentOptions.agentsFolder
     });
   });
@@ -38297,13 +38839,21 @@ 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() ?? {};
+  const optionChain = [options];
+  let current = command;
+  while (current) {
+    optionChain.push(current.opts());
+    current = current.parent ?? null;
+  }
+  const findOption = (name) => {
+    const value = optionChain.find((opts) => opts[name] !== undefined)?.[name];
+    return typeof value === "string" ? value : undefined;
+  };
   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
+    folder: findOption("folder"),
+    claudeCodeFolder: findOption("claudeCodeFolder"),
+    codexFolder: findOption("codexFolder"),
+    agentsFolder: findOption("agentsFolder")
   };
 }
 var agentsCmd = program2.command("agents").description("AI coding configuration commands");