@cleocode/cleo 2026.4.7 → 2026.4.10

package/dist/cli/index.js

@@ -9932,52 +9932,97 @@ var init_migration_manager = __esm({
 });
 
 // packages/core/src/store/sqlite-backup.ts
+var sqlite_backup_exports = {};
+__export(sqlite_backup_exports, {
+  listBrainBackups: () => listBrainBackups,
+  listSqliteBackups: () => listSqliteBackups,
+  listSqliteBackupsAll: () => listSqliteBackupsAll,
+  vacuumIntoBackup: () => vacuumIntoBackup,
+  vacuumIntoBackupAll: () => vacuumIntoBackupAll
+});
 import { existsSync as existsSync6, mkdirSync, readdirSync as readdirSync3, statSync, unlinkSync } from "node:fs";
 import { join as join6 } from "node:path";
 function formatTimestamp(d) {
   const pad = (n, len = 2) => String(n).padStart(len, "0");
   return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
 }
-function rotateSnapshots(backupDir) {
+function snapshotPattern(prefix) {
+  const safe = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^${safe}-\\d{8}-\\d{6}\\.db$`);
+}
+function rotateSnapshots(backupDir, prefix) {
   try {
-    const files = readdirSync3(backupDir).filter((f) => f.match(/^tasks-\d{8}-\d{6}\.db$/)).map((f) => ({
+    const pattern = snapshotPattern(prefix);
+    const files = readdirSync3(backupDir).filter((f) => pattern.test(f)).map((f) => ({
       name: f,
       path: join6(backupDir, f),
       mtimeMs: statSync(join6(backupDir, f)).mtimeMs
     })).sort((a, b) => a.mtimeMs - b.mtimeMs);
     while (files.length >= MAX_SNAPSHOTS) {
       const oldest = files.shift();
+      if (!oldest) break;
       unlinkSync(oldest.path);
     }
   } catch {
   }
 }
+function snapshotOne(target, backupDir, now2) {
+  const db = target.getDb();
+  if (!db) return;
+  const dest = join6(backupDir, `${target.prefix}-${formatTimestamp(now2)}.db`);
+  db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+  rotateSnapshots(backupDir, target.prefix);
+  const safeDest = dest.replace(/'/g, "''");
+  db.exec(`VACUUM INTO '${safeDest}'`);
+}
 async function vacuumIntoBackup(opts = {}) {
   const now2 = Date.now();
-  if (!opts.force && now2 - _lastBackupEpoch < DEBOUNCE_MS) {
+  const prefix = "tasks";
+  const last = _lastBackupEpoch[prefix] ?? 0;
+  if (!opts.force && now2 - last < DEBOUNCE_MS) {
     return;
   }
   try {
     const cleoDir = getCleoDir(opts.cwd);
     const backupDir = join6(cleoDir, "backups", "sqlite");
     mkdirSync(backupDir, { recursive: true });
-    const db = getNativeDb();
-    if (!db) return;
-    const dest = join6(backupDir, `tasks-${formatTimestamp(/* @__PURE__ */ new Date())}.db`);
-    db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
-    rotateSnapshots(backupDir);
-    const safeDest = dest.replace(/'/g, "''");
-    db.exec(`VACUUM INTO '${safeDest}'`);
-    _lastBackupEpoch = Date.now();
+    const target = SNAPSHOT_TARGETS.find((t) => t.prefix === prefix);
+    if (!target) return;
+    snapshotOne(target, backupDir, /* @__PURE__ */ new Date());
+    _lastBackupEpoch[prefix] = Date.now();
   } catch {
   }
 }
-function listSqliteBackups(cwd) {
+async function vacuumIntoBackupAll(opts = {}) {
+  const nowMs = Date.now();
+  const now2 = /* @__PURE__ */ new Date();
+  let backupDir;
+  try {
+    const cleoDir = getCleoDir(opts.cwd);
+    backupDir = join6(cleoDir, "backups", "sqlite");
+    mkdirSync(backupDir, { recursive: true });
+  } catch {
+    return;
+  }
+  for (const target of SNAPSHOT_TARGETS) {
+    const last = _lastBackupEpoch[target.prefix] ?? 0;
+    if (!opts.force && nowMs - last < DEBOUNCE_MS) {
+      continue;
+    }
+    try {
+      snapshotOne(target, backupDir, now2);
+      _lastBackupEpoch[target.prefix] = Date.now();
+    } catch {
+    }
+  }
+}
+function listSqliteBackupsForPrefix(prefix, cwd) {
   try {
     const cleoDir = getCleoDir(cwd);
     const backupDir = join6(cleoDir, "backups", "sqlite");
     if (!existsSync6(backupDir)) return [];
-    return readdirSync3(backupDir).filter((f) => f.match(/^tasks-\d{8}-\d{6}\.db$/)).map((f) => ({
+    const pattern = snapshotPattern(prefix);
+    return readdirSync3(backupDir).filter((f) => pattern.test(f)).map((f) => ({
       name: f,
       path: join6(backupDir, f),
       mtimeMs: statSync(join6(backupDir, f)).mtimeMs
@@ -9986,15 +10031,33 @@ function listSqliteBackups(cwd) {
     return [];
   }
 }
-var MAX_SNAPSHOTS, DEBOUNCE_MS, _lastBackupEpoch;
+function listSqliteBackups(cwd) {
+  return listSqliteBackupsForPrefix("tasks", cwd);
+}
+function listBrainBackups(cwd) {
+  return listSqliteBackupsForPrefix("brain", cwd);
+}
+function listSqliteBackupsAll(cwd) {
+  const out = {};
+  for (const target of SNAPSHOT_TARGETS) {
+    out[target.prefix] = listSqliteBackupsForPrefix(target.prefix, cwd);
+  }
+  return out;
+}
+var MAX_SNAPSHOTS, DEBOUNCE_MS, _lastBackupEpoch, SNAPSHOT_TARGETS;
 var init_sqlite_backup = __esm({
   "packages/core/src/store/sqlite-backup.ts"() {
     "use strict";
     init_paths();
+    init_brain_sqlite();
     init_sqlite2();
     MAX_SNAPSHOTS = 10;
     DEBOUNCE_MS = 3e4;
-    _lastBackupEpoch = 0;
+    _lastBackupEpoch = {};
+    SNAPSHOT_TARGETS = [
+      { prefix: "tasks", getDb: getNativeDb },
+      { prefix: "brain", getDb: getBrainNativeDb }
+    ];
   }
 });
 
@@ -11134,9 +11197,10 @@ async function getDb(cwd) {
               stdio: "pipe"
             });
             const basename19 = fileToCheck.split(/[\\/]/).pop();
+            const relPath = fileToCheck.replace(gitCwd + sep, "");
             log11.warn(
               { path: fileToCheck },
-              `${basename19} is tracked by project git \u2014 this risks data loss on branch switch. Run: git rm --cached ${fileToCheck.replace(gitCwd + sep, "")} (see ADR-013, T5188)`
+              `${basename19} is tracked by project git \u2014 this risks data loss on branch switch. Resolution (ADR-013 \xA79): \`git rm --cached ${relPath}\` and rely on \`.cleo/backups/sqlite/\` snapshots + \`cleo backup add\` for recovery.`
             );
           } catch {
           }
@@ -21847,6 +21911,13 @@ Tasks completed: ${payload.tasksCompleted.join(", ") || "none"}`,
   }
   await maybeRefreshMemoryBridge(projectRoot);
 }
+async function handleSessionEndBackup(projectRoot, _payload) {
+  try {
+    const { vacuumIntoBackupAll: vacuumIntoBackupAll2 } = await Promise.resolve().then(() => (init_sqlite_backup(), sqlite_backup_exports));
+    await vacuumIntoBackupAll2({ cwd: projectRoot, force: true });
+  } catch {
+  }
+}
 var init_session_hooks = __esm({
   "packages/core/src/hooks/handlers/session-hooks.ts"() {
     "use strict";
@@ -21865,6 +21936,12 @@ var init_session_hooks = __esm({
       handler: handleSessionEnd,
       priority: 100
     });
+    hooks.register({
+      id: "backup-session-end",
+      event: "SessionEnd",
+      handler: handleSessionEndBackup,
+      priority: 10
+    });
   }
 });
 
@@ -41954,15 +42031,19 @@ var init_scaffold = __esm({
     ];
     CLEO_GITIGNORE_FALLBACK = `# .cleo/.gitignore \u2014 Deny-by-default for CLEO project data
 # Ignore everything, then explicitly allow only tracked files.
+#
+# ADR-013 \xA79 (2026-04-07, T5158): config.json + project-info.json are
+# runtime snapshots regenerated by \`cleo init\`, not tracked in git.
+# Recovery for all four runtime files (tasks.db, brain.db, config.json,
+# project-info.json) is provided by \`cleo backup add\` snapshots under
+# .cleo/backups/. See .cleo/adrs/ADR-013 for the full recovery story.
 
 # Step 1: Ignore everything
 *
 
 # Allow list
 !.gitignore
-!config.json
 !project-context.json
-!project-info.json
 !setup-otel.sh
 !DATA-SAFETY-IMPLEMENTATION-SUMMARY.md
 !adrs/
@@ -41977,6 +42058,8 @@ var init_scaffold = __esm({
 *.db-shm
 *.db-wal
 *.db-journal
+config.json
+project-info.json
 log.json
 bypass-log.json
 qa-log.json
@@ -62372,9 +62455,39 @@ var init_audit2 = __esm({
 });
 
 // packages/core/src/system/backup.ts
-import { existsSync as existsSync85, mkdirSync as mkdirSync19, readdirSync as readdirSync28, readFileSync as readFileSync60, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join86 } from "node:path";
-function createBackup2(projectRoot, opts) {
+import {
+  copyFileSync as copyFileSync7,
+  existsSync as existsSync85,
+  mkdirSync as mkdirSync19,
+  readdirSync as readdirSync28,
+  readFileSync as readFileSync60,
+  renameSync as renameSync6,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync12
+} from "node:fs";
+import { dirname as dirname17, join as join86 } from "node:path";
+function safeSqliteSnapshot(db, destPath) {
+  if (!db) return false;
+  db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+  const safeDest = destPath.replace(/'/g, "''");
+  db.exec(`VACUUM INTO '${safeDest}'`);
+  return true;
+}
+function atomicWriteSync(destPath, data) {
+  mkdirSync19(dirname17(destPath), { recursive: true });
+  const tmp = `${destPath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync12(tmp, data);
+    renameSync6(tmp, destPath);
+  } catch (err) {
+    try {
+      unlinkSync5(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function createBackup2(projectRoot, opts) {
   const cleoDir = join86(projectRoot, ".cleo");
   const btype = opts?.type || "snapshot";
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
@@ -62383,23 +62496,48 @@ function createBackup2(projectRoot, opts) {
   if (!existsSync85(backupDir)) {
     mkdirSync19(backupDir, { recursive: true });
   }
-  const filesToBackup = ["tasks.db", "brain.db", "config.json", "project-info.json"];
+  try {
+    const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
+    await getDb4(projectRoot);
+  } catch {
+  }
+  try {
+    const { getBrainDb: getBrainDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+    await getBrainDb2(projectRoot);
+  } catch {
+  }
+  const sqliteTargets = [
+    { file: "tasks.db", getDb: getNativeDb },
+    { file: "brain.db", getDb: getBrainNativeDb }
+  ];
+  const jsonTargets = ["config.json", "project-info.json"];
   const backedUp = [];
-  for (const file2 of filesToBackup) {
-    const src = join86(cleoDir, file2);
-    if (existsSync85(src)) {
-      const dest = join86(backupDir, `${file2}.${backupId}`);
-      try {
-        const content = readFileSync60(src);
-        writeFileSync12(dest, content);
-        backedUp.push(file2);
-      } catch {
+  for (const target of sqliteTargets) {
+    const src = join86(cleoDir, target.file);
+    if (!existsSync85(src)) continue;
+    const dest = join86(backupDir, `${target.file}.${backupId}`);
+    try {
+      const ok = safeSqliteSnapshot(target.getDb(), dest);
+      if (ok) {
+        backedUp.push(target.file);
       }
+    } catch {
+    }
+  }
+  for (const file2 of jsonTargets) {
+    const src = join86(cleoDir, file2);
+    if (!existsSync85(src)) continue;
+    const dest = join86(backupDir, `${file2}.${backupId}`);
+    try {
+      const content = readFileSync60(src);
+      atomicWriteSync(dest, content);
+      backedUp.push(file2);
+    } catch {
     }
   }
   const metaPath = join86(backupDir, `${backupId}.meta.json`);
   try {
-    writeFileSync12(
+    atomicWriteSync(
       metaPath,
       JSON.stringify(
         {
@@ -62411,8 +62549,7 @@ function createBackup2(projectRoot, opts) {
         },
         null,
         2
-      ),
-      "utf-8"
+      )
     );
   } catch {
   }
@@ -62476,13 +62613,17 @@ function restoreBackup(projectRoot, params) {
   const restored = [];
   for (const file2 of meta.files ?? []) {
     const backupFile = join86(backupDir, `${file2}.${params.backupId}`);
-    if (existsSync85(backupFile)) {
-      try {
+    if (!existsSync85(backupFile)) continue;
+    const destPath = join86(cleoDir, file2);
+    try {
+      if (file2.endsWith(".db")) {
+        copyFileSync7(backupFile, destPath);
+      } else {
         const content = readFileSync60(backupFile);
-        writeFileSync12(join86(cleoDir, file2), content);
-        restored.push(file2);
-      } catch {
+        atomicWriteSync(destPath, content);
       }
+      restored.push(file2);
+    } catch {
     }
   }
   return {
@@ -62497,6 +62638,8 @@ var init_backup2 = __esm({
     "use strict";
     init_src();
     init_errors3();
+    init_brain_sqlite();
+    init_sqlite2();
   }
 });
 
@@ -62572,7 +62715,7 @@ var init_audit_prune = __esm({
 });
 
 // packages/core/src/system/cleanup.ts
-import { existsSync as existsSync86, readdirSync as readdirSync29, readFileSync as readFileSync61, unlinkSync as unlinkSync5, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync86, readdirSync as readdirSync29, readFileSync as readFileSync61, unlinkSync as unlinkSync6, writeFileSync as writeFileSync13 } from "node:fs";
 import { join as join88 } from "node:path";
 async function cleanupSystem(projectRoot, params) {
   if (!params.target) {
@@ -62631,11 +62774,11 @@ async function cleanupSystem(projectRoot, params) {
                   if (params.olderThan && meta.timestamp < params.olderThan) {
                     items.push(file2.replace(".meta.json", ""));
                     if (!dryRun) {
-                      unlinkSync5(metaFilePath);
+                      unlinkSync6(metaFilePath);
                       for (const bf of readdirSync29(fullDir)) {
                         if (bf.includes(meta.backupId)) {
                           try {
-                            unlinkSync5(join88(fullDir, bf));
+                            unlinkSync6(join88(fullDir, bf));
                           } catch {
                           }
                         }
@@ -62667,7 +62810,7 @@ async function cleanupSystem(projectRoot, params) {
             items.push(file2);
             if (!dryRun) {
               try {
-                unlinkSync5(join88(cleoDir, file2));
+                unlinkSync6(join88(cleoDir, file2));
               } catch {
               }
             }
@@ -62824,14 +62967,14 @@ import {
   mkdirSync as mkdirSync21,
   readdirSync as readdirSync30,
   readFileSync as readFileSync62,
-  renameSync as renameSync6,
-  unlinkSync as unlinkSync6,
+  renameSync as renameSync7,
+  unlinkSync as unlinkSync7,
   writeFileSync as writeFileSync14
 } from "node:fs";
-import { basename as basename14, dirname as dirname17, join as join90 } from "node:path";
+import { basename as basename14, dirname as dirname18, join as join90 } from "node:path";
 import * as lockfile2 from "proper-lockfile";
 function rotateBackup(filePath) {
-  const dir = dirname17(filePath);
+  const dir = dirname18(filePath);
   const name2 = basename14(filePath);
   const backupDir = join90(dir, ".backups");
   if (!existsSync88(backupDir)) {
@@ -62841,13 +62984,13 @@ function rotateBackup(filePath) {
     const current = join90(backupDir, `${name2}.${i}`);
     if (i === MAX_BACKUPS) {
       try {
-        unlinkSync6(current);
+        unlinkSync7(current);
       } catch {
       }
     } else {
       const next = join90(backupDir, `${name2}.${i + 1}`);
       try {
-        if (existsSync88(current)) renameSync6(current, next);
+        if (existsSync88(current)) renameSync7(current, next);
       } catch {
       }
     }
@@ -62859,7 +63002,7 @@ function rotateBackup(filePath) {
   }
 }
 function writeJsonFileAtomic(filePath, data, indent = 2) {
-  const dir = dirname17(filePath);
+  const dir = dirname18(filePath);
   const tempPath = join90(dir, `.${basename14(filePath)}.${randomBytes12(6).toString("hex")}.tmp`);
   const content = JSON.stringify(data, null, indent) + "\n";
   writeFileSync14(tempPath, content, "utf-8");
@@ -62867,10 +63010,10 @@ function writeJsonFileAtomic(filePath, data, indent = 2) {
     if (existsSync88(filePath)) {
       rotateBackup(filePath);
     }
-    renameSync6(tempPath, filePath);
+    renameSync7(tempPath, filePath);
   } catch (error40) {
     try {
-      unlinkSync6(tempPath);
+      unlinkSync7(tempPath);
     } catch {
     }
     throw error40;
@@ -67442,8 +67585,8 @@ var init_docs_sync = __esm({
 
 // packages/core/src/validation/doctor/project-cache.ts
 import { createHash as createHash11 } from "node:crypto";
-import { existsSync as existsSync101, mkdirSync as mkdirSync22, readFileSync as readFileSync73, unlinkSync as unlinkSync7, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname18, join as join102 } from "node:path";
+import { existsSync as existsSync101, mkdirSync as mkdirSync22, readFileSync as readFileSync73, unlinkSync as unlinkSync8, writeFileSync as writeFileSync18 } from "node:fs";
+import { dirname as dirname19, join as join102 } from "node:path";
 function getCacheFilePath(cleoHome) {
   const home = cleoHome ?? getCleoHome();
   return join102(home, CACHE_FILE2);
@@ -67454,7 +67597,7 @@ function initCacheFile(cacheFile) {
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
     projects: {}
   };
-  const dir = dirname18(cacheFile);
+  const dir = dirname19(cacheFile);
   if (!existsSync101(dir)) {
     mkdirSync22(dir, { recursive: true });
   }
@@ -67530,7 +67673,7 @@ function clearProjectCache(projectHash, cacheFile) {
 function clearEntireCache(cacheFile) {
   const cachePath = cacheFile ?? getCacheFilePath();
   if (existsSync101(cachePath)) {
-    unlinkSync7(cachePath);
+    unlinkSync8(cachePath);
   }
   initCacheFile(cachePath);
 }
@@ -68538,7 +68681,7 @@ var init_gap_check = __esm({
 // packages/core/src/validation/manifest.ts
 import { existsSync as existsSync102 } from "node:fs";
 import { appendFile as appendFile3, mkdir as mkdir15, readFile as readFile16 } from "node:fs/promises";
-import { dirname as dirname19 } from "node:path";
+import { dirname as dirname20 } from "node:path";
 async function findManifestEntry(taskId, manifestPath) {
   if (!manifestPath) {
     try {
@@ -68659,7 +68802,7 @@ async function validateManifestEntry(taskId, manifestEntry, manifestPath = DEFAU
   };
 }
 async function logRealCompliance(taskId, validationResult, agentType = "unknown", compliancePath = DEFAULT_COMPLIANCE_PATH) {
-  const metricsDir = dirname19(compliancePath);
+  const metricsDir = dirname20(compliancePath);
   await mkdir15(metricsDir, { recursive: true });
   const { score, pass, violations } = validationResult;
   const violationCount = violations.length;
@@ -69826,13 +69969,13 @@ __export(init_exports, {
 import { existsSync as existsSync105, readdirSync as readdirSync36, readFileSync as readFileSync75 } from "node:fs";
 import { copyFile as copyFile4, lstat, mkdir as mkdir16, readFile as readFile17, symlink, unlink as unlink4, writeFile as writeFile11 } from "node:fs/promises";
 import { platform as platform4 } from "node:os";
-import { basename as basename17, dirname as dirname20, join as join104 } from "node:path";
+import { basename as basename17, dirname as dirname21, join as join104 } from "node:path";
 async function resolveSeedAgentsDir() {
   try {
     const { createRequire: createRequire9 } = await import("node:module");
     const req = createRequire9(import.meta.url);
     const agentsPkgMain = req.resolve("@cleocode/agents/package.json");
-    const agentsPkgRoot = dirname20(agentsPkgMain);
+    const agentsPkgRoot = dirname21(agentsPkgMain);
     const candidate = join104(agentsPkgRoot, "seed-agents");
     if (existsSync105(candidate)) {
       return candidate;
@@ -69860,7 +70003,7 @@ async function initAgentDefinition(created, warnings) {
     const { createRequire: createRequire9 } = await import("node:module");
     const req = createRequire9(import.meta.url);
     const agentsPkgMain = req.resolve("@cleocode/agents/package.json");
-    const agentsPkgRoot = dirname20(agentsPkgMain);
+    const agentsPkgRoot = dirname21(agentsPkgMain);
     const candidate = join104(agentsPkgRoot, "cleo-subagent");
     if (existsSync105(candidate)) {
       agentSourceDir = candidate;
@@ -69879,7 +70022,7 @@ async function initAgentDefinition(created, warnings) {
     return;
   }
   const globalAgentsDir = join104(getAgentsHome(), "agents", "cleo-subagent");
-  await mkdir16(dirname20(globalAgentsDir), { recursive: true });
+  await mkdir16(dirname21(globalAgentsDir), { recursive: true });
   try {
     try {
       const stat4 = await lstat(globalAgentsDir);
@@ -69927,7 +70070,7 @@ async function initCoreSkills(created, warnings) {
       const { createRequire: createRequire9 } = await import("node:module");
       const req = createRequire9(import.meta.url);
       const skillsPkgMain = req.resolve("@cleocode/skills/package.json");
-      const skillsPkgRoot = dirname20(skillsPkgMain);
+      const skillsPkgRoot = dirname21(skillsPkgMain);
       if (existsSync105(join104(skillsPkgRoot, "skills.json"))) {
         ctSkillsRoot = skillsPkgRoot;
       }
@@ -69962,7 +70105,7 @@ async function initCoreSkills(created, warnings) {
     const coreSkills = skills.filter((s) => s.tier <= 2);
     const installed = [];
     for (const skill of coreSkills) {
-      const skillSourceDir = dirname20(join104(ctSkillsRoot, skill.path));
+      const skillSourceDir = dirname21(join104(ctSkillsRoot, skill.path));
       if (!existsSync105(skillSourceDir)) {
         continue;
       }
@@ -70640,8 +70783,8 @@ async function bootstrapGlobalCleo(options) {
 }
 async function writeTemplateTo(content, destPath, isDryRun) {
   if (isDryRun) return false;
-  const { dirname: dirname28 } = await import("node:path");
-  await mkdir17(dirname28(destPath), { recursive: true });
+  const { dirname: dirname29 } = await import("node:path");
+  await mkdir17(dirname29(destPath), { recursive: true });
   await writeFile12(destPath, content);
   return true;
 }
@@ -75470,7 +75613,7 @@ var init_engine_compat = __esm({
 
 // packages/core/src/memory/pipeline-manifest-sqlite.ts
 import { createHash as createHash12 } from "node:crypto";
-import { existsSync as existsSync110, readFileSync as readFileSync79, renameSync as renameSync7 } from "node:fs";
+import { existsSync as existsSync110, readFileSync as readFileSync79, renameSync as renameSync8 } from "node:fs";
 import { join as join108 } from "node:path";
 import { and as and10, count as count2, desc as desc5, eq as eq13, gte as gte3, isNull as isNull3, like as like3, lte as lte2, or as or5 } from "drizzle-orm";
 async function getDb3(cwd) {
@@ -78495,6 +78638,7 @@ var init_store3 = __esm({
     init_lock();
     init_provider();
     init_safety_data_accessor();
+    init_sqlite_backup();
   }
 });
 
@@ -78507,7 +78651,7 @@ __export(migration_sqlite_exports, {
   migrateJsonToSqliteAtomic: () => migrateJsonToSqliteAtomic
 });
 import { existsSync as existsSync114, mkdirSync as mkdirSync23, readFileSync as readFileSync83 } from "node:fs";
-import { dirname as dirname21, join as join111 } from "node:path";
+import { dirname as dirname22, join as join111 } from "node:path";
 function topoSortTasks(tasks2) {
   const taskMap = new Map(tasks2.map((t) => [t.id, t]));
   const sorted = [];
@@ -78585,7 +78729,7 @@ async function migrateJsonToSqliteAtomic(cwd, tempDbPath, logger) {
   closeDb2();
   try {
     logger?.info("import", "init", "Initializing node:sqlite for migration");
-    mkdirSync23(dirname21(tempDbPath), { recursive: true });
+    mkdirSync23(dirname22(tempDbPath), { recursive: true });
     const nativeDb = openNativeDatabase(tempDbPath, { enableWal: true });
     const db = drizzle({ client: nativeDb, schema: tasks_schema_exports });
     logger?.info("import", "create-tables", "Running drizzle migrations to create tables");
@@ -79180,7 +79324,7 @@ var init_repair = __esm({
 
 // packages/core/src/upgrade.ts
 import {
-  copyFileSync as copyFileSync7,
+  copyFileSync as copyFileSync8,
   existsSync as existsSync115,
   mkdirSync as mkdirSync24,
   readdirSync as readdirSync39,
@@ -79273,7 +79417,7 @@ async function runUpgrade(options = {}) {
           if (!existsSync115(backupDir)) {
             mkdirSync24(backupDir, { recursive: true });
           }
-          copyFileSync7(dbPath2, dbBackupPath);
+          copyFileSync8(dbPath2, dbBackupPath);
           const { createHash: createHash14 } = await import("node:crypto");
           const origChecksum = createHash14("sha256").update(readFileSync84(dbPath2)).digest("hex");
           const backupChecksum = createHash14("sha256").update(readFileSync84(dbBackupPath)).digest("hex");
@@ -79294,8 +79438,8 @@ async function runUpgrade(options = {}) {
           });
         }
         if (existsSync115(dbTempPath)) {
-          const { unlinkSync: unlinkSync8 } = await import("node:fs");
-          unlinkSync8(dbTempPath);
+          const { unlinkSync: unlinkSync9 } = await import("node:fs");
+          unlinkSync9(dbTempPath);
         }
         const configPath = join112(cleoDir2, "config.json");
         let configBackup = null;
@@ -79329,7 +79473,7 @@ async function runUpgrade(options = {}) {
         if (result.success) {
           const totalImported = result.tasksImported + result.archivedImported;
           if (totalImported === 0 && existsSync115(dbBackupPath)) {
-            copyFileSync7(dbBackupPath, dbPath2);
+            copyFileSync8(dbBackupPath, dbPath2);
             if (configBackup) {
               writeFileSync21(configPath, configBackup);
             }
@@ -79371,7 +79515,7 @@ async function runUpgrade(options = {}) {
           }
         } else {
           if (existsSync115(dbBackupPath)) {
-            copyFileSync7(dbBackupPath, dbPath2);
+            copyFileSync8(dbBackupPath, dbPath2);
           }
           if (configBackup) {
             writeFileSync21(configPath, configBackup);
@@ -79398,7 +79542,7 @@ async function runUpgrade(options = {}) {
           if (existsSync115(safetyDir)) {
             const backups = readdirSync39(safetyDir).filter((f) => f.startsWith("tasks.db.pre-migration.")).sort().reverse();
             if (backups.length > 0 && !existsSync115(dbPath2)) {
-              copyFileSync7(join112(safetyDir, backups[0]), dbPath2);
+              copyFileSync8(join112(safetyDir, backups[0]), dbPath2);
             }
           }
         } catch {
@@ -79496,11 +79640,11 @@ async function runUpgrade(options = {}) {
           mkdirSync24(backupDir, { recursive: true });
           for (const f of foundStale) {
             const src = join112(cleoDir, f);
-            copyFileSync7(src, join112(backupDir, f));
+            copyFileSync8(src, join112(backupDir, f));
           }
-          const { unlinkSync: unlinkSync8 } = await import("node:fs");
+          const { unlinkSync: unlinkSync9 } = await import("node:fs");
           for (const f of foundStale) {
-            unlinkSync8(join112(cleoDir, f));
+            unlinkSync9(join112(cleoDir, f));
           }
           actions.push({
             action: "stale_json_cleanup",
@@ -81695,7 +81839,7 @@ var init_schema_validator = __esm({
 // packages/core/src/validation/validate-ops.ts
 import { execFileSync as execFileSync12 } from "node:child_process";
 import { appendFileSync as appendFileSync10, existsSync as existsSync119, mkdirSync as mkdirSync25, readFileSync as readFileSync89 } from "node:fs";
-import { dirname as dirname22, join as join113, resolve as resolve12 } from "node:path";
+import { dirname as dirname23, join as join113, resolve as resolve12 } from "node:path";
 function readJsonFile2(filePath) {
   try {
     const raw = readFileSync89(filePath, "utf-8");
@@ -82003,7 +82147,7 @@ function coreComplianceRecord(taskId, result, protocol, violations, projectRoot)
     throw new Error(`Invalid result: ${result}. Valid: ${validResults.join(", ")}`);
   }
   const compliancePath = join113(projectRoot, ".cleo", "metrics", "COMPLIANCE.jsonl");
-  const dir = dirname22(compliancePath);
+  const dir = dirname23(compliancePath);
   if (!existsSync119(dir)) {
     mkdirSync25(dir, { recursive: true });
   }
@@ -82808,7 +82952,7 @@ var init_plan = __esm({
 import { execFileSync as execFileSync13 } from "node:child_process";
 import { createCipheriv, createDecipheriv, createHmac, randomBytes as randomBytes15 } from "node:crypto";
 import { chmod as chmod2, mkdir as mkdir18, readFile as readFile20, stat as stat2, writeFile as writeFile13 } from "node:fs/promises";
-import { dirname as dirname23, join as join115 } from "node:path";
+import { dirname as dirname24, join as join115 } from "node:path";
 function getMachineKeyPath() {
   if (process.platform === "win32") {
     const appData = process.env["LOCALAPPDATA"] ?? process.env["APPDATA"];
@@ -82859,7 +83003,7 @@ async function getMachineKey() {
   } catch (err) {
     if (err instanceof Error && "code" in err && err.code === "ENOENT") {
       const key = randomBytes15(KEY_LENGTH);
-      await mkdir18(dirname23(keyPath), { recursive: true });
+      await mkdir18(dirname24(keyPath), { recursive: true });
       await writeFile13(keyPath, key, { mode: 384 });
       if (process.platform === "win32") {
         try {
@@ -83688,6 +83832,7 @@ __export(internal_exports, {
   listAdrs: () => listAdrs,
   listAgentInstances: () => listAgentInstances,
   listBackups: () => listBackups,
+  listBrainBackups: () => listBrainBackups,
   listChains: () => listChains,
   listEpicsWithLifecycle: () => listEpicsWithLifecycle,
   listLabels: () => listLabels,
@@ -83695,6 +83840,8 @@ __export(internal_exports, {
   listPhases: () => listPhases2,
   listRemotes: () => listRemotes,
   listSessions: () => listSessions,
+  listSqliteBackups: () => listSqliteBackups,
+  listSqliteBackupsAll: () => listSqliteBackupsAll,
   listStickies: () => listStickies,
   listStrictnessPresets: () => listStrictnessPresets,
   listSystemBackups: () => listSystemBackups,
@@ -83931,6 +84078,8 @@ __export(internal_exports, {
   updatePatternStats: () => updatePatternStats,
   updateProjectName: () => updateProjectName,
   updateTask: () => updateTask,
+  vacuumIntoBackup: () => vacuumIntoBackup,
+  vacuumIntoBackupAll: () => vacuumIntoBackupAll,
   validateAgainstSchema: () => validateAgainstSchema,
   validateAllAdrs: () => validateAllAdrs,
   validateArchitectureDecisionTask: () => validateArchitectureDecisionTask,
@@ -84060,6 +84209,7 @@ var init_internal = __esm({
     init_session_store();
     init_signaldock_sqlite();
     init_sqlite2();
+    init_sqlite_backup();
     init_task_store();
     init_tasks_schema();
     init_validation_schemas();
@@ -91086,9 +91236,9 @@ async function systemHealth(projectRoot, params) {
     return engineError("E_GENERAL", err.message);
   }
 }
-function systemBackup(projectRoot, params) {
+async function systemBackup(projectRoot, params) {
   try {
-    const result = createBackup2(projectRoot, params);
+    const result = await createBackup2(projectRoot, params);
     return { success: true, data: result };
   } catch (err) {
     return engineError("E_GENERAL", err.message);
@@ -93388,7 +93538,7 @@ var init_admin2 = __esm({
                 });
                 return wrapResult(result2, "mutate", "admin", operation, startTime);
               }
-              const result = systemBackup(
+              const result = await systemBackup(
                 projectRoot,
                 params
               );
@@ -99763,7 +99913,7 @@ var init_cli = __esm({
 
 // packages/cleo/src/cli/index.ts
 import { readFileSync as readFileSync98 } from "node:fs";
-import { dirname as dirname27, join as join125 } from "node:path";
+import { dirname as dirname28, join as join125 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/_chunks/libs/scule.mjs
@@ -101925,7 +102075,7 @@ function registerBugCommand(program) {
 // packages/cleo/src/cli/commands/cant.ts
 init_renderers();
 import { existsSync as existsSync123, mkdirSync as mkdirSync26, readFileSync as readFileSync94, writeFileSync as writeFileSync22 } from "node:fs";
-import { dirname as dirname24, isAbsolute as isAbsolute3, join as join119, resolve as resolve14 } from "node:path";
+import { dirname as dirname25, isAbsolute as isAbsolute3, join as join119, resolve as resolve14 } from "node:path";
 function registerCantCommand(program) {
   const cant = program.command("cant").description("CANT DSL tooling");
   cant.command("parse <file>").description("Parse a .cant file and emit the AST").action(async (file2) => {
@@ -102017,7 +102167,7 @@ function registerCantCommand(program) {
           let written = 0;
           for (const outputFile of result.outputFiles) {
             const outputPath = isAbsolute3(outputFile.path) ? outputFile.path : join119(projectRoot, outputFile.path);
-            mkdirSync26(dirname24(outputPath), { recursive: true });
+            mkdirSync26(dirname25(outputPath), { recursive: true });
             writeFileSync22(outputPath, outputFile.content, "utf-8");
             written++;
             if (isVerbose) {
@@ -102757,14 +102907,14 @@ function registerDetectCommand(program) {
 init_src();
 init_renderers();
 import { existsSync as existsSync124, readdirSync as readdirSync41, readFileSync as readFileSync95 } from "node:fs";
-import { dirname as dirname25, join as join120 } from "node:path";
+import { dirname as dirname26, join as join120 } from "node:path";
 function findProjectRoot() {
   let currentDir = process.cwd();
   while (currentDir !== "/") {
     if (existsSync124(join120(currentDir, "package.json"))) {
       return currentDir;
     }
-    const parent = dirname25(currentDir);
+    const parent = dirname26(currentDir);
     if (parent === currentDir) break;
     currentDir = parent;
   }
@@ -103678,7 +103828,7 @@ init_src2();
 init_renderers();
 import { execFileSync as execFileSync16 } from "node:child_process";
 import { existsSync as existsSync125, mkdirSync as mkdirSync27, readFileSync as readFileSync96, writeFileSync as writeFileSync23 } from "node:fs";
-import { dirname as dirname26, join as join122 } from "node:path";
+import { dirname as dirname27, join as join122 } from "node:path";
 function getChangelogSource(cwd) {
   const configPath = getConfigPath(cwd);
   try {
@@ -103830,7 +103980,7 @@ function registerGenerateChangelogCommand(program) {
         const content = generateForPlatform(targetPlatform, sourceContent, repoSlug, limit);
         if (!dryRun) {
           const fullPath = join122(getProjectRoot(), outputPath);
-          mkdirSync27(dirname26(fullPath), { recursive: true });
+          mkdirSync27(dirname27(fullPath), { recursive: true });
           writeFileSync23(fullPath, content, "utf-8");
         }
         results.push({ platform: targetPlatform, path: outputPath, written: !dryRun });
@@ -103851,7 +104001,7 @@ function registerGenerateChangelogCommand(program) {
           );
           if (!dryRun) {
             const fullPath = join122(getProjectRoot(), platformConfig.path);
-            mkdirSync27(dirname26(fullPath), { recursive: true });
+            mkdirSync27(dirname27(fullPath), { recursive: true });
             writeFileSync23(fullPath, content, "utf-8");
           }
           results.push({
@@ -107339,7 +107489,7 @@ var codeCommand = defineCommand({
 
 // packages/cleo/src/cli/index.ts
 function getPackageVersion() {
-  const pkgPath = join125(dirname27(fileURLToPath5(import.meta.url)), "../../package.json");
+  const pkgPath = join125(dirname28(fileURLToPath5(import.meta.url)), "../../package.json");
   const pkg = JSON.parse(readFileSync98(pkgPath, "utf-8"));
   return pkg.version;
 }