@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/restore-VBR5XNML.js

@@ -0,0 +1,470 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  dispatchRaw
+} from "./chunk-L7ONYSV6.js";
+import {
+  CLEO_DIR_NAME,
+  RESTORE_CONFLICTS_MD,
+  RESTORE_DEFAULT_FILE
+} from "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import {
+  cliError,
+  cliOutput,
+  humanLine
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/restore.ts
+import fs from "node:fs";
+import path from "node:path";
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+import {
+  CleoError,
+  getProjectRoot,
+  getTaskAccessor,
+  parseConflictReport,
+  setAtPath
+} from "@cleocode/core";
+import { parseConflictReport as parseConflictReport2 } from "@cleocode/core";
+var finalizeCommand = defineCommand({
+  meta: {
+    name: "finalize",
+    description: "Apply manually-resolved conflicts from .cleo/restore-conflicts.md"
+  },
+  async run() {
+    const projectRoot = getProjectRoot();
+    const reportPath = path.join(projectRoot, CLEO_DIR_NAME, RESTORE_CONFLICTS_MD);
+    if (!fs.existsSync(reportPath)) {
+      humanLine("No pending restore conflicts. Nothing to finalize.");
+      return;
+    }
+    const content = fs.readFileSync(reportPath, "utf-8");
+    const allResolutions = parseConflictReport(content);
+    const pending = allResolutions.filter(
+      (r) => r.section === "manual" && (r.resolution === "A" || r.resolution === "B")
+    );
+    if (pending.length === 0) {
+      const stillPending = allResolutions.filter(
+        (r) => r.section === "manual" && r.resolution === "manual-review"
+      );
+      if (stillPending.length > 0) {
+        humanLine(
+          "No manual resolutions found in .cleo/restore-conflicts.md.\nEdit the file to mark resolutions, then re-run 'cleo restore finalize'."
+        );
+        return;
+      }
+      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const archivePath2 = path.join(
+        projectRoot,
+        ".cleo",
+        `restore-conflicts-${timestamp2}.md.finalized`
+      );
+      fs.renameSync(reportPath, archivePath2);
+      cliOutput(
+        { applied: 0, archivedTo: archivePath2 },
+        { command: "restore", message: "No pending resolutions", operation: "restore.finalize" }
+      );
+      return;
+    }
+    const byFile = /* @__PURE__ */ new Map();
+    for (const r of pending) {
+      const existing = byFile.get(r.filename);
+      if (existing) {
+        existing.push(r);
+      } else {
+        byFile.set(r.filename, [r]);
+      }
+    }
+    let applied = 0;
+    for (const [filename, resolutions] of byFile) {
+      const filePath = path.join(projectRoot, CLEO_DIR_NAME, filename);
+      if (!fs.existsSync(filePath)) continue;
+      const raw = fs.readFileSync(filePath, "utf-8");
+      const obj = JSON.parse(raw);
+      for (const r of resolutions) {
+        const value = r.resolution === "A" ? r.localValue : r.importedValue;
+        setAtPath(obj, r.fieldPath, value);
+        applied++;
+      }
+      fs.writeFileSync(filePath, JSON.stringify(obj, null, 2));
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const archivePath = path.join(
+      projectRoot,
+      CLEO_DIR_NAME,
+      `restore-conflicts-${timestamp}.md.finalized`
+    );
+    fs.renameSync(reportPath, archivePath);
+    cliOutput(
+      { applied, archivedTo: archivePath },
+      {
+        command: "restore",
+        message: `Finalized ${applied} conflict resolutions. Conflict report archived.`,
+        operation: "restore.finalize"
+      }
+    );
+  }
+});
+var STORE_FILE_LABELS = /* @__PURE__ */ new Set(["tasks.db", "brain.db", "cleo.db"]);
+var backupSubCommand = defineCommand({
+  meta: {
+    name: "backup",
+    description: "Restore the project store (.cleo/cleo.db: tasks and brain) from a named snapshot (--snapshot) or a backup id (--id): the snapshot is verified, live writers refuse it, and the replaced store is kept as a pre-restore backup. --file config.json restores a config file."
+  },
+  args: {
+    snapshot: {
+      type: "string",
+      description: "A snapshot file of this project's store under .cleo/backups/ (e.g. cleo-identity-refill-*.db, tasks-*.db)"
+    },
+    id: {
+      type: "string",
+      description: "A backup id from `cleo backup list` (its store file is restored)"
+    },
+    "allow-external": {
+      type: "boolean",
+      description: "With --snapshot: accept a file outside this project's .cleo/backups/",
+      default: false
+    },
+    file: {
+      type: "string",
+      description: "Config file to restore from the newest numbered backup (config.json). The store restores only through --snapshot or --id"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview what would be restored",
+      default: false
+    },
+    scope: {
+      type: "string",
+      description: "With --snapshot/--id: project (.cleo/cleo.db, the default) or global (<CLEO_HOME>/cleo.db: the global brain, nexus, agent registry). A global restore needs every cleo process stopped (agent sessions, daemons, Studio): nearly all of them hold the global store open",
+      default: "project"
+    },
+    "confirm-owner-store": {
+      type: "boolean",
+      description: "From inside a git worktree: allow overwriting the owning project's LIVE store (refused without it)",
+      default: false
+    }
+  },
+  async run({ args }) {
+    try {
+      if (args.snapshot !== void 0 || args.id !== void 0) {
+        const { restoreStoreSnapshot } = await import("@cleocode/core/store/restore-store.js");
+        const scope2 = args.scope === "global" ? "global" : "project";
+        const result = await restoreStoreSnapshot({
+          scope: scope2,
+          projectRoot: scope2 === "global" ? process.cwd() : getProjectRoot(),
+          snapshot: args.snapshot,
+          backupId: args.id,
+          dryRun: args["dry-run"] === true,
+          allowExternal: args["allow-external"] === true,
+          confirmOwnerStore: args["confirm-owner-store"] === true,
+          cwd: process.cwd()
+        });
+        cliOutput(result, {
+          command: "restore",
+          operation: "admin.backup.restore-store",
+          ...result.dryRun ? { message: "Dry run - no changes made" } : {}
+        });
+        return;
+      }
+      const fileName = args.file ?? RESTORE_DEFAULT_FILE;
+      const scope = args.scope ?? "project";
+      if (STORE_FILE_LABELS.has(fileName)) {
+        throw new CleoError(
+          ExitCode.INVALID_INPUT,
+          `E_RESTORE_STORE_LABEL: --file ${fileName} cannot restore the live store (.cleo/cleo.db holds tasks and brain)`,
+          {
+            fix: "cleo backup list, then cleo restore backup --id <backupId> (or --snapshot <file>)"
+          }
+        );
+      }
+      const response = await dispatchRaw("mutate", "admin", "backup", {
+        action: "restore.file",
+        file: fileName,
+        dryRun: args["dry-run"] || void 0,
+        scope,
+        confirmOwnerStore: args["confirm-owner-store"] || void 0
+      });
+      if (!response.success) {
+        const code = ExitCode[response.error?.code] ?? ExitCode.GENERAL_ERROR;
+        throw new CleoError(code, response.error?.message ?? "Backup restore failed");
+      }
+      const data = response.data;
+      if (args["dry-run"]) {
+        cliOutput(
+          {
+            dryRun: true,
+            file: fileName,
+            wouldRestore: data?.from,
+            targetPath: data?.targetPath
+          },
+          {
+            command: "restore",
+            message: "Dry run - no changes made",
+            operation: "admin.backup.restore"
+          }
+        );
+        return;
+      }
+      cliOutput(
+        {
+          restored: true,
+          file: fileName,
+          restoredFrom: data?.from,
+          targetPath: data?.targetPath
+        },
+        { command: "restore", operation: "admin.backup.restore" }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var taskSubCommand = defineCommand({
+  meta: {
+    name: "task",
+    description: "Restore task from terminal state (archived, cancelled, or completed) back to active"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to restore",
+      required: true
+    },
+    status: {
+      type: "string",
+      description: "Status to restore task as (default: pending)",
+      default: "pending"
+    },
+    "preserve-status": {
+      type: "boolean",
+      description: "Keep the original task status",
+      default: false
+    },
+    reason: {
+      type: "string",
+      description: "Reason for restoring/reopening the task"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview changes without applying",
+      default: false
+    }
+  },
+  async run({ args }) {
+    try {
+      const taskId = args.taskId;
+      const idPattern = /^T\d{3,}$/;
+      if (!idPattern.test(taskId)) {
+        throw new CleoError(ExitCode.INVALID_INPUT, `Invalid task ID: ${taskId}`);
+      }
+      const accessor = await getTaskAccessor();
+      const activeTask = await accessor.loadSingleTask(taskId);
+      if (activeTask) {
+        if (activeTask.status === "cancelled") {
+          if (args["dry-run"]) {
+            cliOutput(
+              {
+                dryRun: true,
+                taskId,
+                title: activeTask.title,
+                previousStatus: activeTask.status,
+                newStatus: args["preserve-status"] ? activeTask.status : args.status,
+                source: "active-tasks"
+              },
+              {
+                command: "restore",
+                message: "Dry run - no changes made",
+                operation: "tasks.restore"
+              }
+            );
+            return;
+          }
+          const response = await dispatchRaw("mutate", "tasks", "restore", { taskId });
+          if (!response.success) {
+            const code = ExitCode[response.error?.code] ?? ExitCode.GENERAL_ERROR;
+            throw new CleoError(code, response.error?.message ?? "Task restore failed");
+          }
+          const resultData = response.data;
+          cliOutput(
+            {
+              restored: true,
+              taskId: resultData?.task,
+              count: resultData?.count,
+              source: "active-tasks"
+            },
+            { command: "restore", operation: "tasks.restore" }
+          );
+          return;
+        } else if (activeTask.status === "done") {
+          if (args["dry-run"]) {
+            const newStatus = args["preserve-status"] ? activeTask.status : args.status;
+            cliOutput(
+              {
+                dryRun: true,
+                taskId,
+                title: activeTask.title,
+                previousStatus: activeTask.status,
+                newStatus,
+                source: "active-tasks"
+              },
+              {
+                command: "restore",
+                message: "Dry run - no changes made",
+                operation: "tasks.restore"
+              }
+            );
+            return;
+          }
+          const targetStatus = args["preserve-status"] ? void 0 : args.status;
+          const response = await dispatchRaw("mutate", "tasks", "restore", {
+            taskId,
+            from: "done",
+            status: targetStatus,
+            reason: args.reason
+          });
+          if (!response.success) {
+            const code = ExitCode[response.error?.code] ?? ExitCode.GENERAL_ERROR;
+            throw new CleoError(code, response.error?.message ?? "Task restore failed");
+          }
+          const resultData = response.data;
+          cliOutput(
+            {
+              restored: true,
+              taskId: resultData?.task,
+              previousStatus: resultData?.previousStatus,
+              newStatus: resultData?.newStatus,
+              source: "active-tasks"
+            },
+            { command: "restore", operation: "tasks.restore" }
+          );
+          return;
+        } else {
+          throw new CleoError(
+            ExitCode.VALIDATION_ERROR,
+            `Task ${taskId} is already active with status: ${activeTask.status}`
+          );
+        }
+      }
+      if (args["dry-run"]) {
+        const archiveData = await accessor.loadArchive();
+        if (archiveData) {
+          const archivedTasks = archiveData.archivedTasks;
+          if (Array.isArray(archivedTasks)) {
+            const task = archivedTasks.find((t) => t.id === taskId);
+            if (task) {
+              cliOutput(
+                {
+                  dryRun: true,
+                  taskId,
+                  title: task.title,
+                  previousStatus: task.status,
+                  newStatus: args["preserve-status"] ? task.status : args.status,
+                  source: "archive"
+                },
+                {
+                  command: "restore",
+                  message: "Dry run - no changes made",
+                  operation: "tasks.restore"
+                }
+              );
+              return;
+            }
+          }
+        }
+        throw new CleoError(
+          ExitCode.NOT_FOUND,
+          `Task ${taskId} not found in active tasks or archive`,
+          {
+            fix: `cleo find "${taskId}" to search for the task`
+          }
+        );
+      }
+      try {
+        const targetStatus = args["preserve-status"] ? void 0 : args.status;
+        const response = await dispatchRaw("mutate", "tasks", "restore", {
+          taskId,
+          from: "archive",
+          status: targetStatus,
+          preserveStatus: !!args["preserve-status"]
+        });
+        if (!response.success) {
+          const code = ExitCode[response.error?.code] ?? ExitCode.GENERAL_ERROR;
+          throw new CleoError(code, response.error?.message ?? "Task unarchive failed");
+        }
+        const resultData = response.data;
+        cliOutput(
+          {
+            restored: true,
+            taskId: resultData?.task,
+            title: resultData?.title,
+            newStatus: resultData?.status,
+            source: "archive"
+          },
+          { command: "restore", operation: "tasks.restore" }
+        );
+      } catch {
+        throw new CleoError(
+          ExitCode.NOT_FOUND,
+          `Task ${taskId} not found in active tasks or archive`,
+          {
+            fix: `cleo find "${taskId}" to search for the task`
+          }
+        );
+      }
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var restoreCommand = defineCommand({
+  meta: {
+    name: "restore",
+    description: "Restore from backup or restore tasks from terminal states (archived, cancelled, completed)"
+  },
+  subCommands: {
+    finalize: finalizeCommand,
+    backup: backupSubCommand,
+    task: taskSubCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  parseConflictReport2 as parseConflictReport,
+  restoreCommand
+};
+//# sourceMappingURL=restore-VBR5XNML.js.map

package/dist/cli/revert-32LDNSGP.js

@@ -0,0 +1,240 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/revert.ts
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { cwd as processCwd } from "node:process";
+import { E_RECEIPT_NOT_FOUND } from "@cleocode/core/sentient/chain-walker.js";
+import { SENTIENT_STATE_FILE } from "@cleocode/core/sentient/daemon.js";
+import { loadSigningIdentity } from "@cleocode/core/sentient/kms.js";
+import { executeSquashedRevert } from "@cleocode/core/sentient/revert-executor.js";
+import { collectMergeCommits } from "@cleocode/core/sentient/revert-walker.js";
+import {
+  E_OWNER_ATTESTATION_REQUIRED,
+  readSentientState
+} from "@cleocode/core/sentient/state.js";
+var OWNER_PUBKEYS_FILE = ".cleo/owner-pubkeys.json";
+function resolveProjectRoot(arg) {
+  return arg && arg.length > 0 ? arg : processCwd();
+}
+function emitSuccess(payload, _jsonMode, _humanLine) {
+  cliOutput(payload, { command: "revert", operation: "revert.execute" });
+}
+function emitFailure(code, message, _jsonMode) {
+  cliError(message, 1, { name: code });
+  process.exit(1);
+}
+async function loadOwnerAttestation(attestationFilePath) {
+  let raw;
+  if (attestationFilePath) {
+    try {
+      raw = await readFile(attestationFilePath, "utf-8");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to read attestation file "${attestationFilePath}": ${message}`);
+    }
+  } else if (process.env["CLEO_OWNER_ATTESTATION"]) {
+    raw = process.env["CLEO_OWNER_ATTESTATION"];
+  }
+  if (!raw) {
+    throw new Error(
+      'Owner attestation is required. Provide one of:\n  --attestation-file <path>   path to a JSON attestation file\n  CLEO_OWNER_ATTESTATION      JSON string in environment variable\n\nAttestation format:\n  { "afterRevertReceiptId": "<receiptId>",\n    "issuedAt": "<ISO-8601>",\n    "ownerPubkey": "<hex-64>",\n    "sig": "<ed25519-hex-128>" }'
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("Owner attestation is not valid JSON");
+  }
+  const obj = parsed;
+  if (typeof obj["afterRevertReceiptId"] !== "string" || typeof obj["issuedAt"] !== "string" || typeof obj["ownerPubkey"] !== "string" || typeof obj["sig"] !== "string") {
+    throw new Error(
+      "Owner attestation is missing required fields: afterRevertReceiptId, issuedAt, ownerPubkey, sig"
+    );
+  }
+  return obj;
+}
+async function loadOwnerPubkeys(projectRoot) {
+  const path = join(projectRoot, OWNER_PUBKEYS_FILE);
+  try {
+    const raw = await readFile(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      return new Set(parsed.filter((k) => typeof k === "string"));
+    }
+    return /* @__PURE__ */ new Set();
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+var revertCommand = defineCommand({
+  meta: {
+    name: "revert",
+    description: "Owner kill-switch: squash-revert all sentient merge commits from a receipt ID"
+  },
+  args: {
+    from: {
+      type: "string",
+      description: "Receipt ID to revert from (inclusive)"
+    },
+    "attestation-file": {
+      type: "string",
+      description: "Path to owner attestation JSON file (alternatively set CLEO_OWNER_ATTESTATION env var)"
+    },
+    "include-human": {
+      type: "boolean",
+      description: "Allow reverting commits not authored by the sentient agent"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Print commits that would be reverted without executing"
+    },
+    json: {
+      type: "boolean",
+      description: "Emit LAFS JSON envelope"
+    },
+    project: {
+      type: "string",
+      description: "Project root (defaults to process cwd)"
+    }
+  },
+  async run({ args }) {
+    const projectRoot = resolveProjectRoot(args.project);
+    const jsonMode = args.json === true;
+    const dryRun = args["dry-run"] === true;
+    const includeHuman = args["include-human"] === true;
+    const fromReceiptId = args.from;
+    const attestationFile = args["attestation-file"];
+    if (!fromReceiptId) {
+      emitFailure(
+        "E_MISSING_FLAG",
+        "--from <receiptId> is required. Usage: cleo revert --from <receiptId>",
+        jsonMode
+      );
+    }
+    let attestation;
+    if (!dryRun) {
+      try {
+        attestation = await loadOwnerAttestation(attestationFile);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        emitFailure(E_OWNER_ATTESTATION_REQUIRED, message, jsonMode);
+      }
+    }
+    if (attestation && attestation.afterRevertReceiptId !== fromReceiptId) {
+      emitFailure(
+        E_OWNER_ATTESTATION_REQUIRED,
+        `attestation.afterRevertReceiptId "${attestation.afterRevertReceiptId}" does not match --from "${fromReceiptId}"`,
+        jsonMode
+      );
+    }
+    const allowedPubkeys = await loadOwnerPubkeys(projectRoot);
+    if (attestation && allowedPubkeys.size > 0 && !allowedPubkeys.has(attestation.ownerPubkey)) {
+      emitFailure(
+        E_OWNER_ATTESTATION_REQUIRED,
+        `Attestation pubkey "${attestation.ownerPubkey}" is not in the owner allowlist at ${join(projectRoot, OWNER_PUBKEYS_FILE)}`,
+        jsonMode
+      );
+    }
+    let commits;
+    let mergeEvents;
+    try {
+      const result = await collectMergeCommits(projectRoot, fromReceiptId);
+      commits = result.commits;
+      mergeEvents = result.events;
+    } catch (err) {
+      const errCode = err.code === E_RECEIPT_NOT_FOUND ? E_RECEIPT_NOT_FOUND : "E_CHAIN_WALK_FAILED";
+      const message = err instanceof Error ? err.message : String(err);
+      emitFailure(errCode, message, jsonMode);
+    }
+    if (commits.length === 0) {
+      emitSuccess(
+        {
+          receiptId: fromReceiptId,
+          commits: [],
+          message: "No merge commits found starting from this receipt \u2014 nothing to revert"
+        },
+        jsonMode,
+        `No merge commits found starting from receipt ${fromReceiptId}. Nothing to revert.`
+      );
+      return;
+    }
+    if (dryRun) {
+      const lines = commits.map((sha, i) => `  [${i + 1}] ${sha}`).join("\n");
+      emitSuccess(
+        { dryRun: true, fromReceiptId, commits, count: commits.length },
+        jsonMode,
+        `Dry-run: would revert ${commits.length} commit(s) from ${fromReceiptId}:
+${lines}`
+      );
+      return;
+    }
+    let identity;
+    try {
+      identity = await loadSigningIdentity(projectRoot);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      emitFailure("E_KMS_LOAD", message, jsonMode);
+    }
+    try {
+      const result = await executeSquashedRevert({
+        cleoRoot: projectRoot,
+        commits,
+        mergeEvents,
+        fromReceiptId,
+        identity,
+        includeHuman
+      });
+      const statePath = join(projectRoot, SENTIENT_STATE_FILE);
+      const state = await readSentientState(statePath);
+      emitSuccess(
+        {
+          revertCommitSha: result.revertCommitSha,
+          revertedRange: result.revertedRange,
+          eventsReverted: mergeEvents.length,
+          revertEventReceiptId: result.revertEventReceiptId,
+          humanCommitPresent: result.humanCommitPresent,
+          globalPauseSet: true,
+          pausedByRevert: state.pausedByRevert
+        },
+        jsonMode,
+        `Revert complete.
+  Reverted: ${result.revertedRange.length} commit(s)
+  Squash commit: ${result.revertCommitSha}
+  Revert event: ${result.revertEventReceiptId}
+  Global pause: ACTIVE (run 'cleo sentient resume' with owner attestation to clear)`
+      );
+    } catch (err) {
+      const errCode = err.code ?? "E_REVERT_FAILED";
+      const message = err instanceof Error ? err.message : String(err);
+      emitFailure(errCode, message, jsonMode);
+    }
+  }
+});
+export {
+  revertCommand
+};
+//# sourceMappingURL=revert-32LDNSGP.js.map