@cleocode/cleo 2026.5.133 → 2026.5.134

package/dist/cli/index.js

@@ -39572,8 +39572,8 @@ var init_consent = __esm({
         const a = args;
         const enableClaudeCode = a["enable-claude-code"] === true;
         const disableClaudeCode = a["disable-claude-code"] === true;
-        const showStatus = a["status"] === true;
-        if (!enableClaudeCode && !disableClaudeCode && !showStatus) {
+        const showStatus2 = a["status"] === true;
+        if (!enableClaudeCode && !disableClaudeCode && !showStatus2) {
           cliError("Specify one of --enable-claude-code, --disable-claude-code, or --status.", 6, {
             name: "E_INVALID_INPUT",
             fix: "Run `cleo auth consent --status` to see current consent state."
@@ -39599,7 +39599,7 @@ var init_consent = __esm({
         const CONSENT_KEY = "auth.claudeCodeConsentGiven";
         const SOURCE_ID = "claude-code";
         const PROVIDER = "anthropic";
-        if (showStatus) {
+        if (showStatus2) {
           const resolved = await getConfigValue3(CONSENT_KEY);
           const consentEnabled = resolved.value === true;
           const suppressed = isSuppressed(PROVIDER, SOURCE_ID);
@@ -52107,6 +52107,267 @@ var init_exists = __esm({
   }
 });
 
+// packages/cleo/src/cli/commands/exodus.ts
+var exodus_exports = {};
+__export(exodus_exports, {
+  exodusCommand: () => exodusCommand
+});
+import { resolveDualScopeDbPath } from "@cleocode/core/store/dual-scope-db.js";
+import {
+  buildExodusPlan,
+  runExodusMigrate,
+  runExodusStatus,
+  runExodusVerify,
+  sourcesPresent
+} from "@cleocode/core/store/exodus/index.js";
+function fmtBytes2(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+function showStatus() {
+  const result = runExodusStatus(process.cwd());
+  humanInfo("Exodus status:");
+  humanInfo(`  Staging dir present: ${result.hasStaging ? result.stagingDir ?? "yes" : "none"}`);
+  humanInfo(`  Project cleo.db:     ${result.projectDbExists ? "present" : "not yet created"}`);
+  humanInfo(`  Global  cleo.db:     ${result.globalDbExists ? "present" : "not yet created"}`);
+  humanInfo("");
+  humanInfo("  Source DBs:");
+  for (const s of result.sources) {
+    const size = s.exists ? `${(s.bytes / 1024).toFixed(1)} KB` : "-";
+    humanInfo(`    ${s.exists ? "\u2713" : "\u2717"} ${s.name.padEnd(22)} ${size.padStart(10)}  ${s.path}`);
+  }
+  if (result.journal) {
+    const done = result.journal.tables.filter((t) => t.status === "done").length;
+    const total = result.journal.tables.length;
+    humanInfo("");
+    humanInfo(`  Journal: ${done}/${total} tables done, started ${result.journal.startedAt}`);
+  }
+  cliOutput(result, { command: "exodus status" });
+}
+var migrateSubCommand, verifySubCommand, statusSubCommand, exodusCommand;
+var init_exodus = __esm({
+  "packages/cleo/src/cli/commands/exodus.ts"() {
+    "use strict";
+    init_src2();
+    init_define_cli_command();
+    init_subcommand_guard();
+    init_renderers();
+    migrateSubCommand = defineCommand({
+      meta: {
+        name: "migrate",
+        description: "Migrate legacy multi-DB fleet into consolidated dual-scope cleo.db"
+      },
+      args: {
+        "dry-run": {
+          type: "boolean",
+          description: "Preview migration plan without writing anything",
+          default: false
+        },
+        "force-cross-version": {
+          type: "boolean",
+          description: "Skip schema-version guard (AC9 \u2014 use with care)",
+          default: false
+        }
+      },
+      async run({ args }) {
+        const dryRun = args["dry-run"] === true;
+        const forceCrossVersion = args["force-cross-version"] === true;
+        const plan = buildExodusPlan(process.cwd());
+        humanInfo(`Exodus migration plan:`);
+        humanInfo(
+          `  Source DBs (${plan.sources.length} total, ${fmtBytes2(plan.totalSourceBytes)} combined):`
+        );
+        for (const s of plan.sources) {
+          humanInfo(`    [${s.targetScope.padEnd(7)}] ${s.name.padEnd(20)} ${s.path}`);
+        }
+        humanInfo(`  Target project cleo.db: ${plan.projectDbPath}`);
+        humanInfo(`  Target global  cleo.db: ${plan.globalDbPath}`);
+        humanInfo(`  Available disk: ${fmtBytes2(plan.availableBytes)}`);
+        humanInfo(`  Required (3\xD7): ${fmtBytes2(3 * plan.totalSourceBytes)}`);
+        humanInfo(`  Disk pre-flight: ${plan.diskPreflight ? "PASS" : "FAIL"}`);
+        if (plan.resumeFromStaging) {
+          humanInfo(`  Resuming from existing staging: ${plan.stagingDir}`);
+        }
+        if (dryRun) {
+          cliOutput(
+            {
+              kind: "generic",
+              dryRun: true,
+              plan: {
+                sources: plan.sources.map((s) => ({
+                  name: s.name,
+                  path: s.path,
+                  targetScope: s.targetScope
+                })),
+                totalSourceBytes: plan.totalSourceBytes,
+                availableBytes: plan.availableBytes,
+                diskPreflight: plan.diskPreflight,
+                stagingDir: plan.stagingDir,
+                resumeFromStaging: plan.resumeFromStaging,
+                projectDbPath: plan.projectDbPath,
+                globalDbPath: plan.globalDbPath
+              }
+            },
+            { command: "exodus migrate" }
+          );
+          return;
+        }
+        if (!sourcesPresent(plan.sources)) {
+          cliError(
+            "No legacy source DBs found. Nothing to migrate.",
+            4 /* NOT_FOUND */,
+            { name: "E_NO_SOURCES" },
+            { operation: "exodus.migrate" }
+          );
+          process.exitCode = 4 /* NOT_FOUND */;
+          return;
+        }
+        if (!plan.diskPreflight) {
+          cliError(
+            `Insufficient disk space for exodus. Need \u22653\xD7 source size (${fmtBytes2(plan.totalSourceBytes)}), have ${fmtBytes2(plan.availableBytes)}.`,
+            6 /* VALIDATION_ERROR */,
+            { name: "E_DISK_PREFLIGHT_FAIL" },
+            { operation: "exodus.migrate" }
+          );
+          process.exitCode = 6 /* VALIDATION_ERROR */;
+          return;
+        }
+        humanInfo("Starting migration\u2026");
+        const result = await runExodusMigrate(plan, forceCrossVersion, (msg) => humanInfo(`  ${msg}`));
+        if (!result.ok) {
+          cliError(
+            result.error ?? "Migration failed",
+            1 /* GENERAL_ERROR */,
+            { name: "E_EXODUS_MIGRATE_FAILED" },
+            { operation: "exodus.migrate" }
+          );
+          process.exitCode = 1 /* GENERAL_ERROR */;
+          return;
+        }
+        const copied = result.tables.filter((t) => !t.skipped).reduce((n, t) => n + t.rowsCopied, 0);
+        const skipped = result.tables.filter((t) => t.skipped).length;
+        cliOutput(
+          {
+            kind: "generic",
+            ok: true,
+            summary: {
+              tablesProcessed: result.tables.length,
+              rowsCopied: copied,
+              tablesSkipped: skipped,
+              stagingDir: result.stagingDir,
+              backupCount: result.backupPaths.length
+            },
+            tables: result.tables
+          },
+          {
+            command: "exodus migrate",
+            message: `Migration complete. ${result.tables.length} tables processed, ${copied} rows copied.`
+          }
+        );
+      }
+    });
+    verifySubCommand = defineCommand({
+      meta: {
+        name: "verify",
+        description: "Verify row-level equivalence between legacy DBs and consolidated cleo.db"
+      },
+      args: {
+        "show-passing": {
+          type: "boolean",
+          description: "Include passing tables in human output (default: failures only)",
+          default: false
+        }
+      },
+      run({ args }) {
+        const showPassing = args["show-passing"] === true;
+        const plan = buildExodusPlan(process.cwd());
+        const projectDbPath = resolveDualScopeDbPath("project", process.cwd());
+        const globalDbPath = resolveDualScopeDbPath("global");
+        humanInfo("Running equivalence verification\u2026");
+        const result = runExodusVerify(
+          plan.sources,
+          projectDbPath,
+          globalDbPath,
+          (msg) => humanInfo(`  ${msg}`)
+        );
+        if (!result.ok && result.error) {
+          cliError(
+            result.error,
+            1 /* GENERAL_ERROR */,
+            { name: "E_EXODUS_VERIFY_FAILED" },
+            { operation: "exodus.verify" }
+          );
+          process.exitCode = 1 /* GENERAL_ERROR */;
+          return;
+        }
+        const failures = result.tables.filter((t) => !t.countMatch || !t.hashMatch);
+        const passing = result.tables.filter((t) => t.countMatch && t.hashMatch);
+        if (failures.length > 0) {
+          humanInfo(`
+Failed tables (${failures.length}):`);
+          for (const t of failures) {
+            humanInfo(
+              `  FAIL [${t.scope}] ${t.tableName}: source=${t.sourceCount}, target=${t.targetCount}, hashMatch=${t.hashMatch}`
+            );
+          }
+        }
+        if (showPassing && passing.length > 0) {
+          humanInfo(`
+Passing tables (${passing.length}):`);
+          for (const t of passing) {
+            humanInfo(`  OK   [${t.scope}] ${t.tableName}: ${t.sourceCount} rows`);
+          }
+        }
+        cliOutput(
+          {
+            kind: "generic",
+            ok: result.ok,
+            summary: {
+              totalTables: result.tables.length,
+              passing: passing.length,
+              failing: failures.length
+            },
+            failures,
+            ...showPassing ? { passing } : {}
+          },
+          {
+            command: "exodus verify",
+            message: result.ok ? `All ${passing.length} tables verified \u2014 equivalence confirmed.` : `${failures.length} table(s) failed equivalence check.`
+          }
+        );
+        if (!result.ok) {
+          process.exitCode = 1 /* GENERAL_ERROR */;
+        }
+      }
+    });
+    statusSubCommand = defineCommand({
+      meta: {
+        name: "status",
+        description: "Show exodus migration status (staging, source DBs, target DBs)"
+      },
+      run() {
+        showStatus();
+      }
+    });
+    exodusCommand = defineCommand({
+      meta: {
+        name: "exodus",
+        description: "[TRANSITIONAL] Migrate legacy multi-DB fleet to consolidated dual-scope cleo.db (SG-DB-SUBSTRATE-V2)"
+      },
+      subCommands: {
+        migrate: migrateSubCommand,
+        verify: verifySubCommand,
+        status: statusSubCommand
+      },
+      async run({ cmd, rawArgs }) {
+        if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+        showStatus();
+      }
+    });
+  }
+});
+
 // packages/cleo/src/cli/commands/export-tasks.ts
 var export_tasks_exports = {};
 __export(export_tasks_exports, {
@@ -74461,18 +74722,18 @@ var COMMAND_MANIFEST = [
     description: "Claim a task by assigning it to an agent",
     load: async () => (await Promise.resolve().then(() => (init_claim(), claim_exports))).claimCommand
   },
-  {
-    exportName: "classifyCommand",
-    name: "classify",
-    description: "Classify a task: readiness verdict (proceed|grill) + persona routing (agent, confidence)",
-    load: async () => (await Promise.resolve().then(() => (init_classify(), classify_exports))).classifyCommand
-  },
   {
     exportName: "unclaimCommand",
     name: "unclaim",
     description: "Unclaim a task by removing its current assignee",
     load: async () => (await Promise.resolve().then(() => (init_claim(), claim_exports))).unclaimCommand
   },
+  {
+    exportName: "classifyCommand",
+    name: "classify",
+    description: "Classify a task: readiness verdict (proceed|grill) + persona routing (agent, confidence)",
+    load: async () => (await Promise.resolve().then(() => (init_classify(), classify_exports))).classifyCommand
+  },
   {
     exportName: "codeCommand",
     name: "code",
@@ -74659,6 +74920,12 @@ var COMMAND_MANIFEST = [
     description: "Check if a task ID exists (exit 0=exists, 4=not found)",
     load: async () => (await Promise.resolve().then(() => (init_exists(), exists_exports))).existsCommand
   },
+  {
+    exportName: "exodusCommand",
+    name: "exodus",
+    description: "[TRANSITIONAL] Migrate legacy multi-DB fleet to consolidated dual-scope cleo.db (SG-DB-SUBSTRATE-V2)",
+    load: async () => (await Promise.resolve().then(() => (init_exodus(), exodus_exports))).exodusCommand
+  },
   {
     exportName: "exportTasksCommand",
     name: "export-tasks",