aiblueprint-cli 1.4.73 → 1.4.75

package/dist/cli.js

@@ -33628,6 +33628,8 @@ async function mergeCodexConfigFile(sourceConfigPath, codexDir) {
 // src/lib/configs-store.ts
 var import_fs_extra7 = __toESM(require_lib4(), 1);
 import path11 from "path";
+var RETENTION_MANAGED_BACKUP_TRIGGERS = new Set(["setup", "sync", "load", "backup-load"]);
+var DEFAULT_BACKUP_RETENTION_DAYS = 30;
 function getConfigStorePaths(rootDir) {
   const baseDir = path11.join(rootDir, ".aiblueprint");
   return {
@@ -33866,6 +33868,117 @@ async function listConfigBackups(options = {}) {
   const paths = getConfigStorePaths(folders.rootDir);
   return listSnapshots(paths.backupsDir, "backup");
 }
+function normalizeBackupRetentionDays(value = DEFAULT_BACKUP_RETENTION_DAYS) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error("Backup retention days must be a positive integer.");
+  }
+  return value;
+}
+function isRetentionManagedBackup(metadata, includeManual = false) {
+  return RETENTION_MANAGED_BACKUP_TRIGGERS.has(metadata.trigger) || includeManual && metadata.trigger === "manual-backup";
+}
+function isPathInside(childPath, parentPath) {
+  const relativePath = path11.relative(parentPath, childPath);
+  return relativePath !== "" && !relativePath.startsWith("..") && !path11.isAbsolute(relativePath);
+}
+async function realBackupStorePath(backupsDir) {
+  if (!await import_fs_extra7.default.pathExists(backupsDir))
+    return null;
+  const stats = await import_fs_extra7.default.lstat(backupsDir);
+  if (stats.isSymbolicLink()) {
+    throw new Error("Backup directory cannot be a symlink.");
+  }
+  if (!stats.isDirectory()) {
+    throw new Error("Backup path is not a directory.");
+  }
+  return import_fs_extra7.default.realpath(backupsDir);
+}
+function cleanupDateForSnapshot(snapshot) {
+  if (snapshot.metadata.type !== "backup")
+    return null;
+  const createdAt = new Date(snapshot.metadata.createdAt);
+  if (Number.isNaN(createdAt.getTime()))
+    return null;
+  return createdAt;
+}
+async function removeBackupSnapshot(snapshot, backupsRealPath) {
+  const snapshotRealPath = await import_fs_extra7.default.realpath(snapshot.path);
+  if (!isPathInside(snapshotRealPath, backupsRealPath)) {
+    throw new Error(`Refusing to delete backup outside store: ${snapshot.name}`);
+  }
+  await import_fs_extra7.default.remove(snapshot.path);
+}
+async function cleanConfigBackups(options = {}) {
+  const days = normalizeBackupRetentionDays(options.days);
+  const folders = resolveConfigStoreFolders(options);
+  const paths = getConfigStorePaths(folders.rootDir);
+  const backupsRealPath = await realBackupStorePath(paths.backupsDir);
+  const now = options.now ?? new Date;
+  const cutoffDate = new Date(now.getTime() - days * 24 * 60 * 60 * 1000);
+  if (!backupsRealPath) {
+    return {
+      cutoff: cutoffDate.toISOString(),
+      deleted: [],
+      failed: [],
+      kept: [],
+      skipped: []
+    };
+  }
+  const backups = await listSnapshots(paths.backupsDir, "backup");
+  const deleted = [];
+  const failed = [];
+  const kept = [];
+  const skipped = [];
+  const deletionCandidates = [];
+  for (const backup of backups) {
+    if (!isRetentionManagedBackup(backup.metadata, options.includeManual)) {
+      skipped.push({ snapshot: backup, reason: "not retention-managed" });
+      continue;
+    }
+    const cleanupDate = cleanupDateForSnapshot(backup);
+    if (!cleanupDate) {
+      skipped.push({ snapshot: backup, reason: "missing valid backup metadata date" });
+      continue;
+    }
+    if (cleanupDate < cutoffDate) {
+      deletionCandidates.push(backup);
+    } else {
+      kept.push(backup);
+    }
+  }
+  if (options.dryRun) {
+    deleted.push(...deletionCandidates);
+  } else {
+    for (const backup of deletionCandidates) {
+      try {
+        await removeBackupSnapshot(backup, backupsRealPath);
+        deleted.push(backup);
+      } catch (error) {
+        failed.push({
+          snapshot: backup,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    if (deleted.length > 0 || failed.length > 0) {
+      await appendHistory(paths, {
+        action: "backup-clean",
+        days,
+        cutoff: cutoffDate.toISOString(),
+        deleted: deleted.map((backup) => backup.name),
+        failed: failed.map((entry) => ({ name: entry.snapshot.name, error: entry.error })),
+        skipped: skipped.map((entry) => ({ name: entry.snapshot.name, reason: entry.reason }))
+      });
+    }
+  }
+  return {
+    cutoff: cutoffDate.toISOString(),
+    deleted,
+    failed,
+    kept,
+    skipped
+  };
+}
 
 // src/lib/codex-agents-renderer.ts
 var import_fs_extra8 = __toESM(require_lib4(), 1);
@@ -34083,6 +34196,17 @@ async function resolveClaudeAssetPath(sourceDir, name) {
   }
   return null;
 }
+async function resolveDirectoryCopyDestination(destination) {
+  const stat = await import_fs_extra9.default.lstat(destination).catch(() => null);
+  if (!stat?.isSymbolicLink())
+    return destination;
+  const targetStat = await import_fs_extra9.default.stat(destination).catch(() => null);
+  if (targetStat?.isDirectory()) {
+    return import_fs_extra9.default.realpath(destination);
+  }
+  await import_fs_extra9.default.remove(destination);
+  return destination;
+}
 async function setupCommand(params = {}) {
   const {
     folder,
@@ -34195,11 +34319,10 @@ async function setupCommand(params = {}) {
       s.start("Setting up scripts");
       const scriptsSource = await resolveClaudeAssetPath(sourceDir, "scripts");
       if (scriptsSource) {
-        await import_fs_extra9.default.copy(scriptsSource, path13.join(claudeDir, "scripts"), {
-          overwrite: true
-        });
-        await replacePathPlaceholdersInDir(path13.join(claudeDir, "scripts"), claudeDir);
-        await import_fs_extra9.default.ensureDir(path13.join(claudeDir, "scripts/statusline/data"));
+        const scriptsDestination = path13.join(claudeDir, "scripts");
+        await import_fs_extra9.default.copy(scriptsSource, await resolveDirectoryCopyDestination(scriptsDestination), { overwrite: true });
+        await replacePathPlaceholdersInDir(scriptsDestination, claudeDir);
+        await import_fs_extra9.default.ensureDir(path13.join(scriptsDestination, "statusline/data"));
         s.stop("Scripts installed");
       } else {
         s.stop("Scripts not available in repository");
@@ -35738,6 +35861,7 @@ var IGNORED_ENTRY_NAMES2 = new Set([
   ".git",
   "node_modules"
 ]);
+var RULE_EXTENSION_RENAME_REASON = "Rule file extension normalized from .mdc to .md";
 function uniqueByPath(candidates) {
   const seen = new Set;
   const unique = [];
@@ -35847,8 +35971,10 @@ function getContainerCandidates(options, includeCodex = true) {
     }
   ]);
 }
-function getInstructionFileCandidates(options, includeCodex = true) {
+function getInstructionFileCandidates(options, scope) {
   const folders = resolveFolders(options);
+  const cursorDir = path17.join(folders.rootDir, ".cursor");
+  const linkToolInstructionsWhenMissing = scope === "global";
   return uniqueByPath([
     {
       label: "agents-instructions",
@@ -35860,11 +35986,17 @@ function getInstructionFileCandidates(options, includeCodex = true) {
       path: path17.join(folders.claudeDir, "CLAUDE.md"),
       linkWhenMissing: true
     },
-    ...includeCodex ? [{
+    {
       label: "codex-instructions",
       path: path17.join(folders.codexDir, "AGENTS.md"),
-      linkWhenMissing: true
-    }] : []
+      linkWhenMissing: linkToolInstructionsWhenMissing,
+      linkWhenParentExists: true
+    },
+    {
+      label: "cursor-instructions",
+      path: path17.join(cursorDir, "AGENTS.md"),
+      linkWhenParentExists: true
+    }
   ]);
 }
 function getRepositoryContainerCandidates(options) {
@@ -35971,6 +36103,60 @@ async function hashPath(targetPath) {
   }
   return hashString(`other:${stat.mode}:${stat.size}`);
 }
+async function hashRulePath(targetPath) {
+  const stat = await import_fs_extra13.default.lstat(targetPath);
+  if (stat.isSymbolicLink()) {
+    const linkTarget = await import_fs_extra13.default.readlink(targetPath);
+    return hashString(`symlink:${linkTarget}`);
+  }
+  if (stat.isFile()) {
+    const fileHash = crypto.createHash("sha256");
+    fileHash.update("file:");
+    fileHash.update(await import_fs_extra13.default.readFile(targetPath));
+    return fileHash.digest("hex");
+  }
+  if (stat.isDirectory()) {
+    const entries = (await import_fs_extra13.default.readdir(targetPath, { withFileTypes: true })).filter((entry) => !IGNORED_ENTRY_NAMES2.has(entry.name)).sort(compareRuleEntryNames);
+    const canonicalEntries = [];
+    const usedNames = new Set;
+    const hashesByName = new Map;
+    const dirHash = crypto.createHash("sha256");
+    dirHash.update("dir:");
+    for (const entry of entries) {
+      const entryHash = await hashRulePath(path17.join(targetPath, entry.name));
+      let entryName = entry.isDirectory() ? entry.name : normalizeRuleFileName(entry.name);
+      const existingHash = hashesByName.get(entryName);
+      if (existingHash) {
+        if (existingHash === entryHash)
+          continue;
+        entryName = findAvailableRuleName(entryName, usedNames);
+      }
+      usedNames.add(entryName);
+      hashesByName.set(entryName, entryHash);
+      canonicalEntries.push({ name: entryName, hash: entryHash });
+    }
+    for (const entry of canonicalEntries.sort((a, b3) => a.name.localeCompare(b3.name))) {
+      dirHash.update(entry.name);
+      dirHash.update("\x00");
+      dirHash.update(entry.hash);
+      dirHash.update("\x00");
+    }
+    return dirHash.digest("hex");
+  }
+  return hashString(`other:${stat.mode}:${stat.size}`);
+}
+async function hashPathForCategory(category, targetPath) {
+  return category === "rules" ? hashRulePath(targetPath) : hashPath(targetPath);
+}
+function findAvailableRuleName(originalName, usedNames) {
+  let index = 1;
+  while (true) {
+    const candidate = nameWithSuffix(originalName, "agents-rules", index);
+    if (!usedNames.has(candidate))
+      return candidate;
+    index++;
+  }
+}
 var TEXT_EXTENSIONS = new Set([
   ".cjs",
   ".js",
@@ -36049,15 +36235,40 @@ function nameWithSuffix(name, suffix, index) {
   }
   return `${name}--${numberedSuffix}`;
 }
-async function addExistingDestinationHashes(destinationDir, knownHashes) {
+function normalizeRuleFileName(name) {
+  return path17.extname(name).toLowerCase() === ".mdc" ? `${path17.basename(name, path17.extname(name))}.md` : name;
+}
+function ruleExtensionPriority(name) {
+  const ext = path17.extname(name).toLowerCase();
+  if (ext === ".md")
+    return 0;
+  if (ext === ".mdc")
+    return 1;
+  return 2;
+}
+function compareRuleEntryNames(a, b3) {
+  const normalizedCompare = normalizeRuleFileName(a.name).localeCompare(normalizeRuleFileName(b3.name));
+  if (normalizedCompare !== 0)
+    return normalizedCompare;
+  const priorityCompare = ruleExtensionPriority(a.name) - ruleExtensionPriority(b3.name);
+  if (priorityCompare !== 0)
+    return priorityCompare;
+  return a.name.localeCompare(b3.name);
+}
+async function addExistingDestinationHashes(category, destinationDir, knownHashes, result) {
   if (!await import_fs_extra13.default.pathExists(destinationDir))
     return;
+  const plannedRuleNames = new Map(result.renamed.filter((entry) => entry.category === "rules").map((entry) => [path17.resolve(entry.from), path17.basename(entry.to)]));
+  const removedRulePaths = new Set(result.duplicates.filter((entry) => entry.category === "rules").map((entry) => path17.resolve(entry.from)));
   const entries = await import_fs_extra13.default.readdir(destinationDir, { withFileTypes: true });
   for (const entry of entries) {
     if (IGNORED_ENTRY_NAMES2.has(entry.name))
       continue;
     const entryPath = path17.join(destinationDir, entry.name);
-    knownHashes.set(await hashPath(entryPath), entry.name);
+    if (category === "rules" && removedRulePaths.has(path17.resolve(entryPath)))
+      continue;
+    const entryName = category === "rules" ? plannedRuleNames.get(path17.resolve(entryPath)) ?? normalizeRuleFileName(entry.name) : entry.name;
+    knownHashes.set(await hashPathForCategory(category, entryPath), entryName);
   }
 }
 async function importCategoryEntries(category, candidates, destinationDir, result, dryRun = false) {
@@ -36074,7 +36285,7 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
     if (destinationRealPath && candidateRealPath && samePath(destinationRealPath, candidateRealPath)) {
       continue;
     }
-    const entries = await collectCandidateEntries(candidate).catch(() => null);
+    const entries = await collectCandidateEntries(candidate, category).catch(() => null);
     if (!entries) {
       result.skipped.push({
         category,
@@ -36100,12 +36311,12 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
     await import_fs_extra13.default.ensureDir(destinationDir);
   }
   const knownHashes = new Map;
-  await addExistingDestinationHashes(destinationDir, knownHashes);
+  await addExistingDestinationHashes(category, destinationDir, knownHashes, result);
   const knownNames = new Set(knownHashes.values());
   for (const { candidate, entries } of sourceEntries) {
     for (const entry of entries) {
       const sourcePath = entry.path;
-      const sourceHash = await hashPath(sourcePath);
+      const sourceHash = await hashPathForCategory(category, sourcePath);
       const existingName = knownHashes.get(sourceHash);
       if (existingName) {
         result.duplicates.push({
@@ -36116,10 +36327,10 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
         });
         continue;
       }
-      let targetName = entry.name;
+      let targetName = category === "rules" ? normalizeRuleFileName(entry.name) : entry.name;
       let targetPath = path17.join(destinationDir, targetName);
       if (await pathExistsOrSymlink(targetPath) || knownNames.has(targetName)) {
-        targetName = await findAvailableTargetName(destinationDir, entry.name, candidate.label, knownNames);
+        targetName = await findAvailableTargetName(destinationDir, targetName, candidate.label, knownNames);
         targetPath = path17.join(destinationDir, targetName);
         result.renamed.push({
           category,
@@ -36137,7 +36348,7 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
         await normalizePortableContent(targetPath);
       }
       knownNames.add(targetName);
-      knownHashes.set(dryRun ? sourceHash : await hashPath(targetPath), targetName);
+      knownHashes.set(dryRun ? sourceHash : await hashPathForCategory(category, targetPath), targetName);
       result.imported.push({
         category,
         name: entry.name,
@@ -36148,6 +36359,84 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
   }
   return true;
 }
+function recordRuleExtensionRename(result, from3, to) {
+  result.renamed.push({
+    category: "rules",
+    name: path17.basename(from3),
+    from: from3,
+    to,
+    reason: RULE_EXTENSION_RENAME_REASON
+  });
+}
+async function migrateExistingRuleExtensions(rulesDir, result, dryRun = false) {
+  const usedNamesByDir = new Map;
+  async function usedNamesForDir(currentDir) {
+    const existing = usedNamesByDir.get(currentDir);
+    if (existing)
+      return existing;
+    const names = new Set(await import_fs_extra13.default.readdir(currentDir).catch(() => []));
+    usedNamesByDir.set(currentDir, names);
+    return names;
+  }
+  async function walk(currentDir) {
+    const entries = sortSourceEntries(await import_fs_extra13.default.readdir(currentDir, { withFileTypes: true }).catch(() => []), "rules");
+    for (const entry of entries) {
+      if (IGNORED_ENTRY_NAMES2.has(entry.name))
+        continue;
+      const sourcePath = path17.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(sourcePath);
+        continue;
+      }
+      if (!entry.isFile() && !entry.isSymbolicLink())
+        continue;
+      if (path17.extname(entry.name).toLowerCase() !== ".mdc")
+        continue;
+      const targetPath = path17.join(currentDir, normalizeRuleFileName(entry.name));
+      if (samePath(sourcePath, targetPath))
+        continue;
+      if (await pathExistsOrSymlink(targetPath)) {
+        const sourceHash = await hashPath(sourcePath);
+        const targetHash = await hashPath(targetPath);
+        if (sourceHash === targetHash) {
+          const backupRoot = await ensureBackupPath(result, dryRun);
+          const backupTarget = path17.join(backupRoot, safeRelativePath(result.rootDir, sourcePath));
+          if (!dryRun) {
+            await import_fs_extra13.default.ensureDir(path17.dirname(backupTarget));
+            await import_fs_extra13.default.move(sourcePath, backupTarget, { overwrite: false });
+          }
+          result.duplicates.push({
+            category: "rules",
+            name: entry.name,
+            from: sourcePath,
+            keptAs: targetPath
+          });
+          const usedNames3 = await usedNamesForDir(currentDir);
+          usedNames3.delete(entry.name);
+          continue;
+        }
+        const usedNames2 = await usedNamesForDir(currentDir);
+        const targetName = await findAvailableTargetName(currentDir, path17.basename(targetPath), "agents-rules", usedNames2);
+        const renamedTargetPath = path17.join(currentDir, targetName);
+        if (!dryRun) {
+          await import_fs_extra13.default.move(sourcePath, renamedTargetPath, { overwrite: false });
+        }
+        usedNames2.delete(entry.name);
+        usedNames2.add(targetName);
+        recordRuleExtensionRename(result, sourcePath, renamedTargetPath);
+        continue;
+      }
+      const usedNames = await usedNamesForDir(currentDir);
+      if (!dryRun) {
+        await import_fs_extra13.default.move(sourcePath, targetPath, { overwrite: false });
+      }
+      usedNames.delete(entry.name);
+      usedNames.add(path17.basename(targetPath));
+      recordRuleExtensionRename(result, sourcePath, targetPath);
+    }
+  }
+  await walk(rulesDir);
+}
 async function findAvailableTargetName(destinationDir, originalName, label, knownNames) {
   const suffix = suffixFromLabel(label);
   let index = 1;
@@ -36159,11 +36448,18 @@ async function findAvailableTargetName(destinationDir, originalName, label, know
     index++;
   }
 }
-async function collectCandidateEntries(candidate) {
+function sortSourceEntries(entries, category) {
+  return [...entries].sort((a, b3) => {
+    if (category === "rules")
+      return compareRuleEntryNames(a, b3);
+    return a.name.localeCompare(b3.name);
+  });
+}
+async function collectCandidateEntries(candidate, category) {
   const stat = await import_fs_extra13.default.lstat(candidate.path);
   if (stat.isDirectory()) {
     const entries = await import_fs_extra13.default.readdir(candidate.path, { withFileTypes: true });
-    return entries.map((entry) => ({
+    return sortSourceEntries(entries, category).map((entry) => ({
       name: entry.name,
       path: path17.join(candidate.path, entry.name)
     }));
@@ -36172,7 +36468,7 @@ async function collectCandidateEntries(candidate) {
     const targetStat = await import_fs_extra13.default.stat(candidate.path).catch(() => null);
     if (targetStat?.isDirectory()) {
       const entries = await import_fs_extra13.default.readdir(candidate.path, { withFileTypes: true });
-      return entries.map((entry) => ({
+      return sortSourceEntries(entries, category).map((entry) => ({
         name: entry.name,
         path: path17.join(candidate.path, entry.name)
       }));
@@ -36368,6 +36664,8 @@ async function importInstructionFiles(candidates, destinationPath, result, dryRu
 async function shouldLinkMissingInstruction(candidate) {
   if (candidate.linkWhenMissing)
     return true;
+  if (candidate.linkWhenParentExists)
+    return import_fs_extra13.default.pathExists(path17.dirname(candidate.path));
   return false;
 }
 async function linkInstructionFile(candidate, destinationPath, result, dryRun = false) {
@@ -36450,7 +36748,7 @@ async function collectRuleIndexEntries(rulesDir, rootDir, currentDir = rulesDir)
     }
     if (!entry.isFile() && !entry.isSymbolicLink())
       continue;
-    if (![".md", ".mdc"].includes(path17.extname(entry.name).toLowerCase()))
+    if (path17.extname(entry.name).toLowerCase() !== ".md")
       continue;
     rules.push({
       title: await readRuleTitle(entryPath),
@@ -36561,12 +36859,12 @@ async function ensureClaudeInstructionSymlink(result, agentsPath, claudePath, dr
     to: agentsPath
   });
 }
-async function writeRepositoryInstructionIndex(result, folders, dryRun = false) {
+async function writeRepositoryInstructionIndex(result, folders, dryRun = false, includeRules = true) {
   const rulesDir = path17.join(folders.agentsDir, "rules");
   const agentsPath = path17.join(folders.rootDir, "AGENTS.md");
   const claudePath = path17.join(folders.rootDir, "CLAUDE.md");
   const rulesDirExists = await pathExistsOrSymlink(rulesDir);
-  const rules = dryRun || rulesDirExists ? dryRun ? await collectPlannedRuleIndexEntries(result, folders.rootDir) : await collectRuleIndexEntries(rulesDir, folders.rootDir) : [];
+  const rules = includeRules && (dryRun || rulesDirExists) ? dryRun ? await collectPlannedRuleIndexEntries(result, folders.rootDir) : await collectRuleIndexEntries(rulesDir, folders.rootDir) : [];
   const agentsExists = await pathExistsOrSymlink(agentsPath);
   const claudeExists = await pathExistsOrSymlink(claudePath);
   if (rules.length === 0 && !agentsExists && !claudeExists) {
@@ -36601,21 +36899,20 @@ ${renderRulesIndexBlock(rules)}
 }
 async function collectPlannedRuleIndexEntries(result, rootDir) {
   const rules = [];
+  const removedRulePaths = new Set([
+    ...result.renamed.filter((entry) => entry.category === "rules").map((entry) => path17.relative(rootDir, entry.from)),
+    ...result.duplicates.filter((entry) => entry.category === "rules").map((entry) => path17.relative(rootDir, entry.from))
+  ]);
   const plannedRuleEntries = [
     ...result.imported.filter((entry) => entry.category === "rules"),
     ...result.renamed.filter((entry) => entry.category === "rules")
   ];
   for (const entry of plannedRuleEntries) {
-    const ext = path17.extname(entry.to).toLowerCase();
-    if (![".md", ".mdc"].includes(ext))
-      continue;
-    rules.push({
-      title: await readRuleTitle(entry.from),
-      relativePath: path17.relative(rootDir, entry.to)
-    });
+    rules.push(...await collectPlannedRuleEntryFiles(entry, rootDir));
   }
   if (await pathExistsOrSymlink(path17.join(rootDir, ".agents", "rules"))) {
-    rules.push(...await collectRuleIndexEntries(path17.join(rootDir, ".agents", "rules"), rootDir));
+    const existingRules = await collectRuleIndexEntries(path17.join(rootDir, ".agents", "rules"), rootDir);
+    rules.push(...existingRules.filter((rule) => !removedRulePaths.has(rule.relativePath)));
   }
   const byPath = new Map;
   for (const rule of rules) {
@@ -36623,12 +36920,66 @@ async function collectPlannedRuleIndexEntries(result, rootDir) {
   }
   return [...byPath.values()].sort((a, b3) => a.relativePath.localeCompare(b3.relativePath));
 }
+async function collectPlannedRuleEntryFiles(entry, rootDir) {
+  const sourceStat = await import_fs_extra13.default.lstat(entry.from).catch(() => null);
+  if (!sourceStat?.isDirectory()) {
+    const ext = path17.extname(entry.to).toLowerCase();
+    if (ext !== ".md")
+      return [];
+    return [{
+      title: await readRuleTitle(entry.from),
+      relativePath: path17.relative(rootDir, entry.to)
+    }];
+  }
+  return collectPlannedRuleDirectoryFiles(entry.from, entry.to, rootDir);
+}
+async function collectPlannedRuleDirectoryFiles(sourceDir, targetDir, rootDir) {
+  const entries = sortSourceEntries(await import_fs_extra13.default.readdir(sourceDir, { withFileTypes: true }).catch(() => []), "rules");
+  const rules = [];
+  const usedNames = new Set;
+  const plannedSourcesByName = new Map;
+  for (const entry of entries) {
+    if (IGNORED_ENTRY_NAMES2.has(entry.name))
+      continue;
+    const sourcePath = path17.join(sourceDir, entry.name);
+    if (entry.isDirectory()) {
+      const targetPath2 = path17.join(targetDir, entry.name);
+      usedNames.add(entry.name);
+      rules.push(...await collectPlannedRuleDirectoryFiles(sourcePath, targetPath2, rootDir));
+      continue;
+    }
+    if (!entry.isFile() && !entry.isSymbolicLink())
+      continue;
+    const ext = path17.extname(entry.name).toLowerCase();
+    if (![".md", ".mdc"].includes(ext))
+      continue;
+    let targetName = normalizeRuleFileName(entry.name);
+    const existingSourcePath = plannedSourcesByName.get(targetName);
+    if (existingSourcePath) {
+      const sourceHash = await hashRulePath(sourcePath);
+      const existingHash = await hashRulePath(existingSourcePath);
+      if (sourceHash === existingHash)
+        continue;
+      targetName = await findAvailableTargetName(targetDir, targetName, "agents-rules", usedNames);
+    }
+    usedNames.add(targetName);
+    plannedSourcesByName.set(targetName, sourcePath);
+    const targetPath = path17.join(targetDir, targetName);
+    rules.push({
+      title: await readRuleTitle(sourcePath),
+      relativePath: path17.relative(rootDir, targetPath)
+    });
+  }
+  return rules;
+}
 async function unifyAgentsConfiguration(options = {}) {
   const scope = options.scope ?? "global";
   const dryRun = Boolean(options.dryRun);
   const folders = resolveFolders(options);
   const includeCodex = scope !== "repository";
-  const instructionCandidates = getInstructionFileCandidates(options, includeCodex);
+  const defaultCategories = scope === "repository" ? ["instructions", "skills", "agents", "rules"] : ["instructions", "skills", "agents"];
+  const selectedCategories = new Set((options.categories ?? defaultCategories).filter((category) => defaultCategories.includes(category)));
+  const instructionCandidates = getInstructionFileCandidates(options, scope);
   const candidates = scope === "repository" ? getRepositoryContainerCandidates(options) : getContainerCandidates(options);
   const result = {
     rootDir: folders.rootDir,
@@ -36649,10 +37000,17 @@ async function unifyAgentsConfiguration(options = {}) {
     instructions: path17.join(folders.agentsDir, "AGENTS.md"),
     rules: path17.join(folders.agentsDir, "rules")
   };
-  await importInstructionFiles(instructionCandidates, destinationByCategory.instructions, result, dryRun);
+  if (selectedCategories.has("instructions")) {
+    await importInstructionFiles(instructionCandidates, destinationByCategory.instructions, result, dryRun);
+  }
   const categories = scope === "repository" ? ["skills", "agents", "rules"] : ["skills", "agents"];
+  if (scope === "repository" && selectedCategories.has("rules") && await pathExistsOrSymlink(destinationByCategory.rules)) {
+    await migrateExistingRuleExtensions(destinationByCategory.rules, result, dryRun);
+  }
   const activeCategories = new Set;
   for (const category of categories) {
+    if (!selectedCategories.has(category))
+      continue;
     const isActive = await importCategoryEntries(category, candidates, destinationByCategory[category], result, dryRun);
     if (isActive) {
       activeCategories.add(category);
@@ -36663,11 +37021,16 @@ async function unifyAgentsConfiguration(options = {}) {
       continue;
     await linkContainer(candidate, destinationByCategory[candidate.category], result, dryRun);
   }
-  for (const candidate of instructionCandidates) {
-    await linkInstructionFile(candidate, destinationByCategory.instructions, result, dryRun);
+  if (selectedCategories.has("instructions")) {
+    for (const candidate of instructionCandidates) {
+      await linkInstructionFile(candidate, destinationByCategory.instructions, result, dryRun);
+    }
   }
-  if (scope === "repository") {
-    await writeRepositoryInstructionIndex(result, folders, dryRun);
+  if (scope === "repository" && (selectedCategories.has("instructions") || selectedCategories.has("rules"))) {
+    if (!dryRun && selectedCategories.has("rules") && await pathExistsOrSymlink(destinationByCategory.rules)) {
+      await migrateExistingRuleExtensions(destinationByCategory.rules, result, dryRun);
+    }
+    await writeRepositoryInstructionIndex(result, folders, dryRun, selectedCategories.has("rules"));
   }
   return result;
 }
@@ -36676,6 +37039,46 @@ async function previewAgentsConfiguration(options = {}) {
 }
 
 // src/commands/agents-unify.ts
+var CATEGORY_LABELS = {
+  instructions: "AGENTS.md",
+  skills: "Skills",
+  agents: "Agents",
+  rules: "Rules and memories"
+};
+function defaultCategoriesForScope(scope) {
+  return scope === "repository" ? ["instructions", "skills", "agents", "rules"] : ["instructions", "skills", "agents"];
+}
+function selectableCategoriesForScope(scope) {
+  return defaultCategoriesForScope(scope);
+}
+async function resolveSelectedCategories(params) {
+  const scope = params.scope ?? "global";
+  const selectableCategories = selectableCategoriesForScope(scope);
+  const requestedCategories = params.categories?.filter((category) => selectableCategories.includes(category));
+  const initialValues = requestedCategories ?? selectableCategories;
+  if (!params.interactive) {
+    if (params.categories && initialValues.length === 0) {
+      throw new Error(`Selected categories do not apply to ${scope} scope`);
+    }
+    return requestedCategories;
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("Interactive category selection requires a TTY");
+  }
+  const selected = await fe({
+    message: "What do you want to unify?",
+    options: selectableCategories.map((category) => ({
+      value: category,
+      label: CATEGORY_LABELS[category]
+    })),
+    initialValues,
+    required: true
+  });
+  if (pD(selected)) {
+    return null;
+  }
+  return selected;
+}
 function countByCategory(result, key, category) {
   return result[key].filter((entry) => entry.category === category).length;
 }
@@ -36741,15 +37144,24 @@ AIBlueprint agents unify ${source_default.gray(`v${getVersion()}`)}
 `));
     console.log(source_default.gray(`Scope: ${params.scope ?? "global"}`));
     console.log(source_default.gray(params.scope === "repository" ? "Centralizing project agent configuration into .agents" : "Centralizing reusable agent configuration into .agents, then rendering Codex agents"));
-    const preview = await previewAgentsConfiguration(params);
+    const selectedCategories = await resolveSelectedCategories(params);
+    if (selectedCategories === null) {
+      console.log(source_default.gray(`
+Unify cancelled`));
+      return;
+    }
+    const commandParams = { ...params, categories: selectedCategories };
+    const effectiveCategories = selectedCategories ?? defaultCategoriesForScope(params.scope ?? "global");
+    console.log(source_default.gray(`Categories: ${effectiveCategories.map((category) => CATEGORY_LABELS[category]).join(", ")}`));
+    const preview = await previewAgentsConfiguration(commandParams);
     printAgentsUnifyPreview(preview);
     if (!await confirmUnify()) {
       console.log(source_default.gray(`
 Unify cancelled`));
       return;
     }
-    const result = await unifyAgentsConfiguration(params);
-    const codexResult = params.scope === "repository" ? null : await renderCodexAgentsFromMarkdown(params);
+    const result = await unifyAgentsConfiguration(commandParams);
+    const codexResult = params.scope === "repository" || !effectiveCategories.includes("agents") ? null : await renderCodexAgentsFromMarkdown(commandParams);
     console.log(source_default.green(`
 Unify complete`));
     console.log(source_default.gray(`  Shared folder: ${result.agentsDir}`));
@@ -38454,6 +38866,35 @@ async function configsBackupsCreateCommand(reason, options = {}) {
     process.exit(1);
   }
 }
+async function configsBackupsCleanCommand(options = {}) {
+  try {
+    const days = options.days ?? DEFAULT_BACKUP_RETENTION_DAYS;
+    console.log(source_default.gray(`Cleaning config backups older than ${days} day${days !== 1 ? "s" : ""}...`));
+    const result = await cleanConfigBackups(options);
+    if (options.dryRun) {
+      console.log(source_default.yellow(`Dry run: ${result.deleted.length} backup${result.deleted.length !== 1 ? "s" : ""} would be deleted.`));
+    } else {
+      console.log(source_default.green(`Deleted ${result.deleted.length} old backup${result.deleted.length !== 1 ? "s" : ""}.`));
+    }
+    console.log(source_default.gray(`Cutoff: ${formatDate2(result.cutoff)}`));
+    for (const backup of result.deleted) {
+      console.log(source_default.gray(`  ${backup.name}`));
+    }
+    if (result.skipped.length > 0) {
+      console.log(source_default.gray(`Skipped ${result.skipped.length} backup${result.skipped.length !== 1 ? "s" : ""}.`));
+    }
+    if (result.failed.length > 0) {
+      console.error(source_default.red(`Failed to delete ${result.failed.length} backup${result.failed.length !== 1 ? "s" : ""}.`));
+      for (const failure of result.failed) {
+        console.error(source_default.red(`  ${failure.snapshot.name}: ${failure.error}`));
+      }
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(source_default.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+}
 
 // src/commands/openclaw-pro.ts
 import os20 from "os";
@@ -38941,6 +39382,18 @@ var __dirname3 = dirname3(fileURLToPath3(import.meta.url));
 var packageJson = JSON.parse(readFileSync3(join2(__dirname3, "../package.json"), "utf8"));
 var program2 = new Command;
 program2.name("aiblueprint").description("AIBlueprint CLI for setting up AI coding configurations").version(packageJson.version);
+function readUnifyCategories(options) {
+  const categories = [];
+  if (options.agentsMd)
+    categories.push("instructions");
+  if (options.skills)
+    categories.push("skills");
+  if (options.agents)
+    categories.push("agents");
+  if (options.rules)
+    categories.push("rules");
+  return categories.length > 0 ? categories : undefined;
+}
 function registerAgentsCommands(cmd) {
   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)").option("-s, --skip", "Skip interactive prompts and install all features");
   cmd.command("setup").description("Setup AI coding configuration with AIBlueprint defaults").action((options, command) => {
@@ -38968,7 +39421,7 @@ function registerAgentsCommands(cmd) {
       codexFolder: parentOptions.codexFolder
     });
   });
-  cmd.command("unify [scope]").description("Unify agent configuration into .agents (scope: global or projects/repository; default: global)").action((scope, options, command) => {
+  cmd.command("unify [scope]").description("Unify agent configuration into .agents (scope: global or projects/repository; default: global)").option("-i, --interactive", "Choose which categories to unify").option("--agents-md", "Unify instruction files into .agents/AGENTS.md").option("--skills", "Unify skills").option("--agents", "Unify Markdown agents").option("--rules", "Unify repository rules and memories").action((scope, options, command) => {
     const parentOptions = command.parent.opts();
     const requestedScope = scope ?? "global";
     const selectedScope = requestedScope === "projects" || requestedScope === "project" ? "repository" : requestedScope;
@@ -38983,7 +39436,9 @@ function registerAgentsCommands(cmd) {
       claudeCodeFolder: parentOptions.claudeCodeFolder,
       codexFolder: parentOptions.codexFolder,
       agentsFolder: parentOptions.agentsFolder,
-      scope: selectedScope
+      scope: selectedScope,
+      categories: readUnifyCategories(options),
+      interactive: options.interactive
     });
   });
   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) => {
@@ -39068,6 +39523,13 @@ function readConfigOptions(command, options = {}) {
     agentsFolder: findOption("agentsFolder")
   };
 }
+function parseRetentionDays(value) {
+  try {
+    return normalizeBackupRetentionDays(Number(value));
+  } catch (error) {
+    throw new InvalidArgumentError(error instanceof Error ? error.message : String(error));
+  }
+}
 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");
@@ -39119,6 +39581,15 @@ addConfigFolderOptions(configsBackupsCmd.command("create [reason]").description(
     ...folderOptions
   });
 });
+addConfigFolderOptions(configsBackupsCmd.command("clean").description("Delete old config backups managed by retention").option("-d, --days <days>", "Delete backups older than this many days", parseRetentionDays, DEFAULT_BACKUP_RETENTION_DAYS).option("--dry-run", "Show backups that would be deleted without removing them").option("--include-manual", "Also delete manual backups created with configs backups create")).action((options, command) => {
+  const folderOptions = readConfigOptions(command, options);
+  configsBackupsCleanCommand({
+    ...folderOptions,
+    days: options.days,
+    dryRun: options.dryRun,
+    includeManual: options.includeManual
+  });
+});
 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) => {