@cleocode/cleo 2026.3.0 → 2026.3.1

package/dist/cli/index.js

@@ -758,6 +758,65 @@ var init_node_sqlite_adapter = __esm({
   }
 });
 
+// src/store/sqlite-backup.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, statSync, unlinkSync } from "node:fs";
+import { join as join3 } 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) {
+  try {
+    const files = readdirSync(backupDir).filter((f) => f.match(/^tasks-\d{8}-\d{6}\.db$/)).map((f) => ({ name: f, path: join3(backupDir, f), mtimeMs: statSync(join3(backupDir, f)).mtimeMs })).sort((a, b) => a.mtimeMs - b.mtimeMs);
+    while (files.length >= MAX_SNAPSHOTS) {
+      const oldest = files.shift();
+      unlinkSync(oldest.path);
+    }
+  } catch {
+  }
+}
+async function vacuumIntoBackup(opts = {}) {
+  const now = Date.now();
+  if (!opts.force && now - _lastBackupEpoch < DEBOUNCE_MS) {
+    return;
+  }
+  try {
+    const cleoDir = getCleoDir(opts.cwd);
+    const backupDir = join3(cleoDir, "backups", "sqlite");
+    mkdirSync2(backupDir, { recursive: true });
+    const db = getNativeDb();
+    if (!db) return;
+    const dest = join3(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();
+  } catch {
+  }
+}
+function listSqliteBackups(cwd) {
+  try {
+    const cleoDir = getCleoDir(cwd);
+    const backupDir = join3(cleoDir, "backups", "sqlite");
+    if (!existsSync2(backupDir)) return [];
+    return readdirSync(backupDir).filter((f) => f.match(/^tasks-\d{8}-\d{6}\.db$/)).map((f) => ({ name: f, path: join3(backupDir, f), mtimeMs: statSync(join3(backupDir, f)).mtimeMs })).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  } catch {
+    return [];
+  }
+}
+var MAX_SNAPSHOTS, DEBOUNCE_MS, _lastBackupEpoch;
+var init_sqlite_backup = __esm({
+  "src/store/sqlite-backup.ts"() {
+    "use strict";
+    init_paths();
+    init_sqlite();
+    MAX_SNAPSHOTS = 10;
+    DEBOUNCE_MS = 3e4;
+    _lastBackupEpoch = 0;
+  }
+});
+
 // src/store/sqlite.ts
 var sqlite_exports = {};
 __export(sqlite_exports, {
@@ -773,16 +832,74 @@ __export(sqlite_exports, {
   resolveMigrationsFolder: () => resolveMigrationsFolder,
   schema: () => schema_exports
 });
-import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, copyFileSync, unlinkSync as unlinkSync2, renameSync as renameSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname3, join as join3, resolve as resolve3 } from "node:path";
+import { dirname as dirname3, join as join4, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { eq } from "drizzle-orm";
 import { readMigrationFiles } from "drizzle-orm/migrator";
 import { drizzle } from "drizzle-orm/sqlite-proxy";
 import { migrate } from "drizzle-orm/sqlite-proxy/migrator";
 function getDbPath(cwd) {
-  return join3(getCleoDirAbsolute(cwd), DB_FILENAME);
+  return join4(getCleoDirAbsolute(cwd), DB_FILENAME);
+}
+async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
+  const log5 = getLogger("sqlite");
+  try {
+    const countResult = nativeDb.prepare("SELECT COUNT(*) as cnt FROM tasks").get();
+    const taskCount = countResult?.cnt ?? 0;
+    if (taskCount > 0) return;
+    const backups = listSqliteBackups(cwd);
+    if (backups.length === 0) {
+      return;
+    }
+    const newestBackup = backups[0];
+    const backupDb = new DatabaseSync2(newestBackup.path, { readOnly: true });
+    let backupTaskCount = 0;
+    try {
+      const backupCount = backupDb.prepare("SELECT COUNT(*) as cnt FROM tasks").get();
+      backupTaskCount = backupCount?.cnt ?? 0;
+    } finally {
+      backupDb.close();
+    }
+    if (backupTaskCount < MIN_BACKUP_TASK_COUNT) {
+      return;
+    }
+    log5.warn(
+      { dbPath, backupPath: newestBackup.path, backupTasks: backupTaskCount },
+      `Empty database detected with ${backupTaskCount}-task backup available. Auto-recovering from backup. This likely happened because git-tracked WAL/SHM files were overwritten during a branch switch (T5188).`
+    );
+    nativeDb.close();
+    const walPath = dbPath + "-wal";
+    const shmPath = dbPath + "-shm";
+    try {
+      unlinkSync2(walPath);
+    } catch {
+    }
+    try {
+      unlinkSync2(shmPath);
+    } catch {
+    }
+    const tempPath = dbPath + ".recovery-tmp";
+    copyFileSync(newestBackup.path, tempPath);
+    renameSync2(tempPath, dbPath);
+    log5.info(
+      { dbPath, backupPath: newestBackup.path, restoredTasks: backupTaskCount },
+      "Database auto-recovered from backup successfully."
+    );
+    const restoredNativeDb = openNativeDatabase(dbPath);
+    _nativeDb = restoredNativeDb;
+    const callback = createDrizzleCallback(restoredNativeDb);
+    const batchCb = createBatchCallback(restoredNativeDb);
+    const restoredDb = drizzle(callback, batchCb, { schema: schema_exports });
+    await runMigrations(restoredNativeDb, restoredDb);
+    _db = restoredDb;
+  } catch (err) {
+    log5.error(
+      { err, dbPath },
+      "Auto-recovery from backup failed. Continuing with empty database."
+    );
+  }
 }
 async function getDb(cwd) {
   const requestedPath = getDbPath(cwd);
@@ -794,7 +911,7 @@ async function getDb(cwd) {
   _initPromise = (async () => {
     const dbPath = requestedPath;
     _dbPath = dbPath;
-    mkdirSync2(dirname3(dbPath), { recursive: true });
+    mkdirSync3(dirname3(dbPath), { recursive: true });
     const nativeDb = openNativeDatabase(dbPath);
     _nativeDb = nativeDb;
     const callback = createDrizzleCallback(nativeDb);
@@ -807,19 +924,28 @@ async function getDb(cwd) {
     nativeDb.exec(
       `INSERT OR IGNORE INTO schema_meta (key, value) VALUES ('task_id_sequence', '{"counter":0,"lastId":"T000","checksum":"seed"}')`
     );
+    await autoRecoverFromBackup(nativeDb, dbPath, cwd);
     if (!_gitTrackingChecked) {
       _gitTrackingChecked = true;
       try {
         const { execFileSync: execFileSync9 } = await import("node:child_process");
-        execFileSync9("git", ["ls-files", "--error-unmatch", dbPath], {
-          cwd: resolve3(dbPath, "..", ".."),
-          stdio: "pipe"
-        });
+        const gitCwd = resolve3(dbPath, "..", "..");
+        const filesToCheck = [dbPath, dbPath + "-wal", dbPath + "-shm"];
         const log5 = getLogger("sqlite");
-        log5.warn(
-          { dbPath },
-          "tasks.db is tracked by project git \u2014 this risks data loss on git operations. Run: git rm --cached .cleo/tasks.db (see ADR-013)"
-        );
+        for (const fileToCheck of filesToCheck) {
+          try {
+            execFileSync9("git", ["ls-files", "--error-unmatch", fileToCheck], {
+              cwd: gitCwd,
+              stdio: "pipe"
+            });
+            const basename10 = fileToCheck.split("/").pop();
+            log5.warn(
+              { path: fileToCheck },
+              `${basename10} is tracked by project git \u2014 this risks data loss on branch switch. Run: git rm --cached ${fileToCheck.replace(gitCwd + "/", "")} (see ADR-013, T5188)`
+            );
+          } catch {
+          }
+        }
       } catch {
       }
     }
@@ -835,7 +961,7 @@ async function getDb(cwd) {
 function resolveMigrationsFolder() {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname2 = dirname3(__filename);
-  return join3(__dirname2, "..", "..", "drizzle");
+  return join4(__dirname2, "..", "..", "drizzle");
 }
 function tableExists(nativeDb, tableName) {
   const result = nativeDb.prepare(
@@ -929,12 +1055,12 @@ async function getSchemaVersion(cwd) {
   return result[0]?.value ?? null;
 }
 function dbExists(cwd) {
-  return existsSync2(getDbPath(cwd));
+  return existsSync3(getDbPath(cwd));
 }
 function getNativeDb() {
   return _nativeDb;
 }
-var _require2, DatabaseSync2, DB_FILENAME, SQLITE_SCHEMA_VERSION, SCHEMA_VERSION, _db, _nativeDb, _dbPath, _initPromise, _gitTrackingChecked, MAX_MIGRATION_RETRIES, MIGRATION_RETRY_BASE_DELAY_MS, MIGRATION_RETRY_MAX_DELAY_MS;
+var _require2, DatabaseSync2, DB_FILENAME, SQLITE_SCHEMA_VERSION, SCHEMA_VERSION, _db, _nativeDb, _dbPath, _initPromise, _gitTrackingChecked, MIN_BACKUP_TASK_COUNT, MAX_MIGRATION_RETRIES, MIGRATION_RETRY_BASE_DELAY_MS, MIGRATION_RETRY_MAX_DELAY_MS;
 var init_sqlite = __esm({
   "src/store/sqlite.ts"() {
     "use strict";
@@ -942,6 +1068,7 @@ var init_sqlite = __esm({
     init_paths();
     init_node_sqlite_adapter();
     init_logger();
+    init_sqlite_backup();
     _require2 = createRequire2(import.meta.url);
     ({ DatabaseSync: DatabaseSync2 } = _require2("node:sqlite"));
     DB_FILENAME = "tasks.db";
@@ -952,6 +1079,7 @@ var init_sqlite = __esm({
     _dbPath = null;
     _initPromise = null;
     _gitTrackingChecked = false;
+    MIN_BACKUP_TASK_COUNT = 10;
     MAX_MIGRATION_RETRIES = 5;
     MIGRATION_RETRY_BASE_DELAY_MS = 100;
     MIGRATION_RETRY_MAX_DELAY_MS = 2e3;
@@ -1182,7 +1310,7 @@ __export(atomic_exports, {
 });
 import writeFileAtomic from "write-file-atomic";
 import { readFile, mkdir, rename, unlink } from "node:fs/promises";
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
 async function atomicWrite(filePath, data, options) {
   try {
@@ -1220,37 +1348,37 @@ async function atomicWriteJson(filePath, data, options) {
 async function atomicDatabaseMigration(dbPath, tempPath, validateFn) {
   const backupPath = `${dbPath}.backup`;
   try {
-    if (!existsSync3(tempPath)) {
+    if (!existsSync4(tempPath)) {
       throw new Error(`Temp database not found: ${tempPath}`);
     }
     const isValid = await validateFn(tempPath);
     if (!isValid) {
       throw new Error(`Temp database validation failed: ${tempPath}`);
     }
-    if (existsSync3(dbPath)) {
+    if (existsSync4(dbPath)) {
       await rename(dbPath, backupPath);
     }
     await rename(tempPath, dbPath);
     return {
       success: true,
       tempPath,
-      backupPath: existsSync3(backupPath) ? backupPath : void 0
+      backupPath: existsSync4(backupPath) ? backupPath : void 0
     };
   } catch (err) {
     return {
       success: false,
       tempPath,
-      backupPath: existsSync3(backupPath) ? backupPath : void 0,
+      backupPath: existsSync4(backupPath) ? backupPath : void 0,
       error: String(err)
     };
   }
 }
 async function restoreDatabaseFromBackup(dbPath, backupPath) {
   try {
-    if (!existsSync3(backupPath)) {
+    if (!existsSync4(backupPath)) {
       return false;
     }
-    if (existsSync3(dbPath)) {
+    if (existsSync4(dbPath)) {
       await unlink(dbPath);
     }
     await rename(backupPath, dbPath);
@@ -1261,7 +1389,7 @@ async function restoreDatabaseFromBackup(dbPath, backupPath) {
 }
 async function cleanupMigrationArtifacts(backupPath) {
   try {
-    if (existsSync3(backupPath)) {
+    if (existsSync4(backupPath)) {
       await unlink(backupPath);
     }
     return true;
@@ -1295,7 +1423,7 @@ var init_atomic = __esm({
 
 // src/store/backup.ts
 import { copyFile, rename as fsRename, readdir, unlink as unlink2, stat, mkdir as mkdir2 } from "node:fs/promises";
-import { join as join4, basename } from "node:path";
+import { join as join5, basename } from "node:path";
 async function createBackup(filePath, backupDir, maxBackups = DEFAULT_MAX_BACKUPS) {
   try {
     await mkdir2(backupDir, { recursive: true });
@@ -1309,14 +1437,14 @@ async function createBackup(filePath, backupDir, maxBackups = DEFAULT_MAX_BACKUP
       );
     }
     for (let i = maxBackups; i >= 1; i--) {
-      const current = join4(backupDir, `${fileName}.${i}`);
+      const current = join5(backupDir, `${fileName}.${i}`);
       if (i === maxBackups) {
         try {
           await unlink2(current);
         } catch {
         }
       } else {
-        const next = join4(backupDir, `${fileName}.${i + 1}`);
+        const next = join5(backupDir, `${fileName}.${i + 1}`);
         try {
           await stat(current);
           await fsRename(current, next);
@@ -1324,7 +1452,7 @@ async function createBackup(filePath, backupDir, maxBackups = DEFAULT_MAX_BACKUP
         }
       }
     }
-    const backupPath = join4(backupDir, `${fileName}.1`);
+    const backupPath = join5(backupDir, `${fileName}.1`);
     await copyFile(filePath, backupPath);
     return backupPath;
   } catch (err) {
@@ -1344,7 +1472,7 @@ async function listBackups(fileName, backupDir) {
       const numA = parseInt(a.slice(prefix.length), 10);
       const numB = parseInt(b.slice(prefix.length), 10);
       return numA - numB;
-    }).map((e) => join4(backupDir, e));
+    }).map((e) => join5(backupDir, e));
   } catch {
     return [];
   }
@@ -2119,15 +2247,15 @@ var init_sqlite_data_accessor = __esm({
 
 // src/store/git-checkpoint.ts
 import { readFile as readFile2, writeFile } from "node:fs/promises";
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { join as join5, resolve as resolve4 } from "node:path";
+import { join as join6, resolve as resolve4 } from "node:path";
 function makeCleoGitEnv(cleoDir) {
   const abs = resolve4(cleoDir);
   return {
     ...process.env,
-    GIT_DIR: join5(abs, ".git"),
+    GIT_DIR: join6(abs, ".git"),
     GIT_WORK_TREE: abs
   };
 }
@@ -2145,7 +2273,7 @@ async function cleoGitCommand(args, cleoDir) {
   }
 }
 function isCleoGitInitialized(cleoDir) {
-  return existsSync4(join5(cleoDir, ".git", "HEAD"));
+  return existsSync5(join6(cleoDir, ".git", "HEAD"));
 }
 async function loadCheckpointConfig(cwd) {
   try {
@@ -2172,25 +2300,25 @@ async function isCleoGitRepo(cleoDir) {
   return result.success && (result.stdout === "true" || isCleoGitInitialized(cleoDir));
 }
 function isMergeInProgress(cleoDir) {
-  return existsSync4(join5(cleoDir, ".git", "MERGE_HEAD"));
+  return existsSync5(join6(cleoDir, ".git", "MERGE_HEAD"));
 }
 async function isDetachedHead(cleoDir) {
   const result = await cleoGitCommand(["symbolic-ref", "HEAD"], cleoDir);
   return !result.success;
 }
 function isRebaseInProgress(cleoDir) {
-  return existsSync4(join5(cleoDir, ".git", "rebase-merge")) || existsSync4(join5(cleoDir, ".git", "rebase-apply"));
+  return existsSync5(join6(cleoDir, ".git", "rebase-merge")) || existsSync5(join6(cleoDir, ".git", "rebase-apply"));
 }
 async function recordCheckpointTime(cleoDir) {
   try {
-    const stateFile = join5(cleoDir, CHECKPOINT_STATE_FILE);
+    const stateFile = join6(cleoDir, CHECKPOINT_STATE_FILE);
     await writeFile(stateFile, String(Math.floor(Date.now() / 1e3)));
   } catch {
   }
 }
 async function getLastCheckpointTime(cleoDir) {
   try {
-    const stateFile = join5(cleoDir, CHECKPOINT_STATE_FILE);
+    const stateFile = join6(cleoDir, CHECKPOINT_STATE_FILE);
     const content = await readFile2(stateFile, "utf-8");
     const epoch = parseInt(content.trim(), 10);
     return isNaN(epoch) ? 0 : epoch;
@@ -2201,8 +2329,8 @@ async function getLastCheckpointTime(cleoDir) {
 async function getChangedStateFiles(cleoDir) {
   const changed = [];
   for (const stateFile of STATE_FILES) {
-    const fullPath = join5(cleoDir, stateFile);
-    if (!existsSync4(fullPath)) continue;
+    const fullPath = join6(cleoDir, stateFile);
+    if (!existsSync5(fullPath)) continue;
     const diffResult = await cleoGitCommand(["diff", "--quiet", "--", stateFile], cleoDir);
     const cachedResult = await cleoGitCommand(["diff", "--cached", "--quiet", "--", stateFile], cleoDir);
     const untrackedResult = await cleoGitCommand(
@@ -2226,7 +2354,7 @@ async function shouldCheckpoint(options) {
   const config = await loadCheckpointConfig(cwd);
   if (!config.enabled) return false;
   const cleoDir = getCleoDir(cwd);
-  if (!existsSync4(cleoDir)) return false;
+  if (!existsSync5(cleoDir)) return false;
   if (!isCleoGitInitialized(cleoDir)) return false;
   if (!await isCleoGitRepo(cleoDir)) return false;
   if (isMergeInProgress(cleoDir)) return false;
@@ -2324,55 +2452,6 @@ var init_git_checkpoint = __esm({
   }
 });
 
-// src/store/sqlite-backup.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync, 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) {
-  try {
-    const files = readdirSync(backupDir).filter((f) => f.match(/^tasks-\d{8}-\d{6}\.db$/)).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();
-      unlinkSync(oldest.path);
-    }
-  } catch {
-  }
-}
-async function vacuumIntoBackup(opts = {}) {
-  const now = Date.now();
-  if (!opts.force && now - _lastBackupEpoch < DEBOUNCE_MS) {
-    return;
-  }
-  try {
-    const cleoDir = getCleoDir(opts.cwd);
-    const backupDir = join6(cleoDir, "backups", "sqlite");
-    mkdirSync3(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();
-  } catch {
-  }
-}
-var MAX_SNAPSHOTS, DEBOUNCE_MS, _lastBackupEpoch;
-var init_sqlite_backup = __esm({
-  "src/store/sqlite-backup.ts"() {
-    "use strict";
-    init_paths();
-    init_sqlite();
-    MAX_SNAPSHOTS = 10;
-    DEBOUNCE_MS = 3e4;
-    _lastBackupEpoch = 0;
-  }
-});
-
 // src/core/sequence/index.ts
 var sequence_exports = {};
 __export(sequence_exports, {
@@ -2381,7 +2460,7 @@ __export(sequence_exports, {
   repairSequence: () => repairSequence,
   showSequence: () => showSequence
 });
-import { existsSync as existsSync6, readFileSync as readFileSync2, renameSync as renameSync2 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync2, renameSync as renameSync3 } from "node:fs";
 import { join as join7 } from "node:path";
 import { eq as eq4 } from "drizzle-orm";
 function getLegacySequenceJsonPath(cwd) {
@@ -2412,10 +2491,10 @@ function renameLegacyFile(path) {
   const migratedPath = `${path}.migrated`;
   try {
     if (!existsSync6(migratedPath)) {
-      renameSync2(path, migratedPath);
+      renameSync3(path, migratedPath);
       return;
     }
-    renameSync2(path, `${migratedPath}.${Date.now()}`);
+    renameSync3(path, `${migratedPath}.${Date.now()}`);
   } catch {
   }
 }
@@ -5331,7 +5410,7 @@ var init_find = __esm({
 });
 
 // src/store/file-utils.ts
-import { readFileSync as readFileSync3, writeFileSync, renameSync as renameSync3, existsSync as existsSync8, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4, readdirSync as readdirSync2 } from "node:fs";
+import { readFileSync as readFileSync3, writeFileSync, renameSync as renameSync4, existsSync as existsSync8, unlinkSync as unlinkSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2 } from "node:fs";
 import { join as join8, dirname as dirname6, basename as basename2 } from "node:path";
 import { randomBytes as randomBytes2 } from "node:crypto";
 import * as lockfile2 from "proper-lockfile";
@@ -5346,13 +5425,13 @@ function rotateBackup(filePath) {
     const current = join8(backupDir, `${name}.${i}`);
     if (i === MAX_BACKUPS) {
       try {
-        unlinkSync2(current);
+        unlinkSync3(current);
       } catch {
       }
     } else {
       const next = join8(backupDir, `${name}.${i + 1}`);
       try {
-        if (existsSync8(current)) renameSync3(current, next);
+        if (existsSync8(current)) renameSync4(current, next);
       } catch {
       }
     }
@@ -5372,10 +5451,10 @@ function writeJsonFileAtomic(filePath, data, indent = 2) {
     if (existsSync8(filePath)) {
       rotateBackup(filePath);
     }
-    renameSync3(tempPath, filePath);
+    renameSync4(tempPath, filePath);
   } catch (error) {
     try {
-      unlinkSync2(tempPath);
+      unlinkSync3(tempPath);
     } catch {
     }
     throw error;
@@ -6860,7 +6939,7 @@ import {
   writeFileSync as writeFileSync2,
   mkdirSync as mkdirSync7,
   readdirSync as readdirSync3,
-  copyFileSync,
+  copyFileSync as copyFileSync2,
   statSync as statSync3,
   rmSync
 } from "node:fs";
@@ -6936,7 +7015,7 @@ function copyDirContents(srcDir, dstDir, manifestLines, copiedFiles) {
         for (const sf of readdirSync3(srcPath)) {
           if (!copiedFiles.has(sf)) {
             try {
-              copyFileSync(join13(srcPath, sf), join13(dstPath, sf));
+              copyFileSync2(join13(srcPath, sf), join13(dstPath, sf));
               copiedFiles.add(sf);
               count2++;
             } catch {
@@ -6944,7 +7023,7 @@ function copyDirContents(srcDir, dstDir, manifestLines, copiedFiles) {
           }
         }
       } else if (!copiedFiles.has(entry)) {
-        copyFileSync(srcPath, dstPath);
+        copyFileSync2(srcPath, dstPath);
         copiedFiles.add(entry);
         count2++;
       }
@@ -10474,7 +10553,6 @@ var init_relates = __esm({
     init_paths();
     init_errors();
     init_exit_codes();
-    init_data_safety_central();
   }
 });
 
@@ -15330,7 +15408,7 @@ function getMigrationStatus(projectRoot, opts) {
 // src/core/system/cleanup.ts
 init_errors();
 init_exit_codes();
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync4, existsSync as existsSync17, readdirSync as readdirSync4, unlinkSync as unlinkSync3 } from "node:fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync4, existsSync as existsSync17, readdirSync as readdirSync4, unlinkSync as unlinkSync4 } from "node:fs";
 import { join as join17 } from "node:path";
 function cleanupSystem(projectRoot, params) {
   if (!params.target) {
@@ -15381,11 +15459,11 @@ function cleanupSystem(projectRoot, params) {
                   if (params.olderThan && meta.timestamp < params.olderThan) {
                     items.push(file.replace(".meta.json", ""));
                     if (!dryRun) {
-                      unlinkSync3(metaFilePath);
+                      unlinkSync4(metaFilePath);
                       for (const bf of readdirSync4(fullDir)) {
                         if (bf.includes(meta.backupId)) {
                           try {
-                            unlinkSync3(join17(fullDir, bf));
+                            unlinkSync4(join17(fullDir, bf));
                           } catch {
                           }
                         }
@@ -15410,7 +15488,7 @@ function cleanupSystem(projectRoot, params) {
             items.push(file);
             if (!dryRun) {
               try {
-                unlinkSync3(join17(cleoDir, file));
+                unlinkSync4(join17(cleoDir, file));
               } catch {
               }
             }
@@ -30211,7 +30289,7 @@ function registerPlanCommand(program2) {
 }
 
 // src/core/otel/index.ts
-import { readFileSync as readFileSync41, existsSync as existsSync55, writeFileSync as writeFileSync14, copyFileSync as copyFileSync2 } from "node:fs";
+import { readFileSync as readFileSync41, existsSync as existsSync55, writeFileSync as writeFileSync14, copyFileSync as copyFileSync3 } from "node:fs";
 import { join as join59 } from "node:path";
 function getProjectRoot2() {
   let dir = process.cwd();
@@ -30310,7 +30388,7 @@ async function clearOtelData() {
   const tokenFile = getTokenFilePath();
   if (existsSync55(tokenFile)) {
     const backup = `${tokenFile}.backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-    copyFileSync2(tokenFile, backup);
+    copyFileSync3(tokenFile, backup);
     writeFileSync14(tokenFile, "");
     return { message: "Token tracking cleared", backup };
   }
@@ -30701,7 +30779,7 @@ init_paths();
 
 // src/core/upgrade.ts
 init_paths();
-import { existsSync as existsSync59, readFileSync as readFileSync43, writeFileSync as writeFileSync15, mkdirSync as mkdirSync19, readdirSync as readdirSync18, copyFileSync as copyFileSync3 } from "node:fs";
+import { existsSync as existsSync59, readFileSync as readFileSync43, writeFileSync as writeFileSync15, mkdirSync as mkdirSync19, readdirSync as readdirSync18, copyFileSync as copyFileSync4 } from "node:fs";
 import { join as join63 } from "node:path";
 init_agent_outputs();
 
@@ -30901,7 +30979,7 @@ var MigrationLogger = class {
       if (!existsSync56(logsDir)) {
         return;
       }
-      const { readdirSync: readdirSync20, unlinkSync: unlinkSync4 } = __require("node:fs");
+      const { readdirSync: readdirSync20, unlinkSync: unlinkSync5 } = __require("node:fs");
       const files = readdirSync20(logsDir).filter((f) => f.startsWith("migration-") && f.endsWith(".jsonl")).map((f) => ({
         name: f,
         path: join60(logsDir, f),
@@ -30910,7 +30988,7 @@ var MigrationLogger = class {
       const filesToRemove = files.slice(this.config.maxLogFiles);
       for (const file of filesToRemove) {
         try {
-          unlinkSync4(file.path);
+          unlinkSync5(file.path);
         } catch {
         }
       }
@@ -31235,7 +31313,7 @@ async function runUpgrade(options = {}) {
           if (!existsSync59(backupDir)) {
             mkdirSync19(backupDir, { recursive: true });
           }
-          copyFileSync3(dbPath2, dbBackupPath);
+          copyFileSync4(dbPath2, dbBackupPath);
           const { createHash: createHash8 } = await import("node:crypto");
           const origChecksum = createHash8("sha256").update(readFileSync43(dbPath2)).digest("hex");
           const backupChecksum = createHash8("sha256").update(readFileSync43(dbBackupPath)).digest("hex");
@@ -31254,8 +31332,8 @@ async function runUpgrade(options = {}) {
           logger.info("backup", "verified", "Backup integrity verified", { checksum: origChecksum });
         }
         if (existsSync59(dbTempPath)) {
-          const { unlinkSync: unlinkSync4 } = await import("node:fs");
-          unlinkSync4(dbTempPath);
+          const { unlinkSync: unlinkSync5 } = await import("node:fs");
+          unlinkSync5(dbTempPath);
         }
         const configPath = join63(cleoDir2, "config.json");
         let configBackup = null;
@@ -31287,7 +31365,7 @@ async function runUpgrade(options = {}) {
         if (result.success) {
           const totalImported = result.tasksImported + result.archivedImported;
           if (totalImported === 0 && existsSync59(dbBackupPath)) {
-            copyFileSync3(dbBackupPath, dbPath2);
+            copyFileSync4(dbBackupPath, dbPath2);
             if (configBackup) {
               writeFileSync15(configPath, configBackup);
             }
@@ -31329,7 +31407,7 @@ async function runUpgrade(options = {}) {
           }
         } else {
           if (existsSync59(dbBackupPath)) {
-            copyFileSync3(dbBackupPath, dbPath2);
+            copyFileSync4(dbBackupPath, dbPath2);
           }
           if (configBackup) {
             writeFileSync15(configPath, configBackup);
@@ -31356,7 +31434,7 @@ async function runUpgrade(options = {}) {
           if (existsSync59(safetyDir)) {
             const backups = readdirSync18(safetyDir).filter((f) => f.startsWith("tasks.db.pre-migration.")).sort().reverse();
             if (backups.length > 0 && !existsSync59(dbPath2)) {
-              copyFileSync3(join63(safetyDir, backups[0]), dbPath2);
+              copyFileSync4(join63(safetyDir, backups[0]), dbPath2);
             }
           }
         } catch {
@@ -31445,11 +31523,11 @@ async function runUpgrade(options = {}) {
           mkdirSync19(backupDir, { recursive: true });
           for (const f of foundStale) {
             const src = join63(cleoDir, f);
-            copyFileSync3(src, join63(backupDir, f));
+            copyFileSync4(src, join63(backupDir, f));
           }
-          const { unlinkSync: unlinkSync4 } = await import("node:fs");
+          const { unlinkSync: unlinkSync5 } = await import("node:fs");
           for (const f of foundStale) {
-            unlinkSync4(join63(cleoDir, f));
+            unlinkSync5(join63(cleoDir, f));
           }
           actions.push({
             action: "stale_json_cleanup",