@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/chunk-MNJRLSEQ.js

@@ -0,0 +1,107 @@
+(() => {
+  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-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/doctor-projects-registry.ts
+import {
+  applyProjectRegistryRepair,
+  inspectProjectRegistry,
+  RegistryRepairError,
+  rollbackProjectRegistryRepair
+} from "@cleocode/core/doctor/projects.js";
+import { NexusRegistryReadError } from "@cleocode/core/nexus/registry-errors.js";
+var positiveInt = (value) => {
+  const n = typeof value === "string" ? Number.parseInt(value, 10) : Number.NaN;
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+};
+var doctorRegistryCommand = defineCommand({
+  meta: {
+    name: "projects",
+    description: "Machine-wide registry integrity: rebind moved projects by id, flag split identities, missing, temp and home/root rows, each with the exact remedy. Read-only by default; --apply writes a receipt, --rollback <receiptId> restores the prior rows."
+  },
+  args: {
+    "dry-run": { type: "boolean", description: "Report only (the default); write nothing" },
+    apply: { type: "boolean", description: "Rebind moved rows and record missing locations" },
+    rollback: { type: "string", description: "Restore the rows changed by this receipt id" },
+    roots: {
+      type: "string",
+      description: "Comma-separated extra directories to scan for .cleo/project-id"
+    },
+    "max-depth": { type: "string", description: "Scan depth below each root (default 2)" },
+    concurrency: { type: "string", description: "Filesystem reads in flight (default 16)" },
+    "timeout-ms": { type: "string", description: "Budget per filesystem probe (default 2000)" },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run({ args }) {
+    const operation = args.rollback ? "doctor.projects.rollback" : args.apply && !args["dry-run"] ? "doctor.projects.apply" : "doctor.projects.inspect";
+    try {
+      if (typeof args.rollback === "string" && args.rollback.length > 0) {
+        const result = await rollbackProjectRegistryRepair(args.rollback);
+        cliOutput(result, { command: "doctor", operation });
+        return;
+      }
+      const opts = {
+        roots: typeof args.roots === "string" ? args.roots.split(",").map((root) => root.trim()).filter((root) => root.length > 0) : void 0,
+        maxDepth: positiveInt(args["max-depth"]),
+        concurrency: positiveInt(args.concurrency),
+        timeoutMs: positiveInt(args["timeout-ms"])
+      };
+      if (operation === "doctor.projects.apply") {
+        cliOutput(await applyProjectRegistryRepair(opts), { command: "doctor", operation });
+        return;
+      }
+      const report = await inspectProjectRegistry(opts);
+      cliOutput(report, { command: "doctor", operation });
+      if ((report.findings.some((f) => f.kind !== "other-device") || report.ambiguousAliases.length > 0) && (process.exitCode ?? 0) === 0)
+        process.exitCode = 1;
+    } catch (error) {
+      if (error instanceof NexusRegistryReadError) {
+        cliError(
+          error.message,
+          error.code,
+          { name: error.codeName, fix: error.fix, details: error.details },
+          { operation }
+        );
+        process.exitCode = error.code;
+        return;
+      }
+      const code = error instanceof RegistryRepairError ? error.code : "E_DOCTOR_PROJECTS_FAILED";
+      const exitCode = code === "E_NOT_FOUND" ? 4 : 1;
+      cliError(
+        error instanceof Error ? error.message : String(error),
+        exitCode,
+        { name: code },
+        {
+          operation
+        }
+      );
+      process.exitCode = exitCode;
+    }
+  }
+});
+
+export {
+  doctorRegistryCommand
+};
+//# sourceMappingURL=chunk-MNJRLSEQ.js.map

package/dist/cli/chunk-NRKWJLMS.js

@@ -0,0 +1,91 @@
+(() => {
+  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 {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/doctor-manifest-rows.ts
+import {
+  listMalformedManifestRows,
+  listManifestIdentityProblems,
+  MANIFEST_ROW_APPLY_COMMAND,
+  MANIFEST_ROW_REPAIR_COMMAND,
+  repairMalformedManifestRows,
+  rollbackManifestRepair
+} from "@cleocode/core/memory/pipeline-manifest-sqlite.js";
+import { getProjectRoot } from "@cleocode/core/paths.js";
+var doctorManifestRowsCommand = defineCommand({
+  meta: {
+    name: "manifest-rows",
+    description: "List manifest rows whose metadata violates the stored field contract, and (read-only) rows with an invalid id, linked task id or file reference. --repair shows the plan (writes nothing); --repair --apply moves each bad field under _malformed (nothing lost) with a receipt; --rollback <receipt> undoes it."
+  },
+  args: {
+    repair: {
+      type: "boolean",
+      description: "Plan the repair of every malformed row; writes nothing"
+    },
+    apply: {
+      type: "boolean",
+      description: "Write the repair (writes a receipt first); implies --repair"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Plan only (the default for --repair); overrides --apply"
+    },
+    rollback: { type: "string", description: "Undo a repair from its receipt file" },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run({ args }) {
+    const projectRoot = getProjectRoot();
+    if (typeof args.rollback === "string" && args.rollback !== "") {
+      const result = await rollbackManifestRepair(args.rollback, projectRoot);
+      cliOutput(result, { command: "doctor", operation: "doctor.manifest-rows.rollback" });
+      return;
+    }
+    if (args.repair === true || args.apply === true) {
+      const apply = args.apply === true && args["dry-run"] !== true;
+      const receipt = await repairMalformedManifestRows(projectRoot, { dryRun: !apply });
+      cliOutput(
+        apply ? receipt : { ...receipt, apply: receipt.changes.length > 0 ? MANIFEST_ROW_APPLY_COMMAND : null },
+        {
+          command: "doctor",
+          operation: apply ? "doctor.manifest-rows.apply" : "doctor.manifest-rows.plan"
+        }
+      );
+      return;
+    }
+    const rows = await listMalformedManifestRows(projectRoot);
+    const identity = await listManifestIdentityProblems(projectRoot);
+    cliOutput(
+      { rows, repair: rows.length > 0 ? MANIFEST_ROW_REPAIR_COMMAND : null, identity },
+      { command: "doctor", operation: "doctor.manifest-rows.run" }
+    );
+    const invalidIdentity = identity.some((r) => r.issues.some((i) => i.code === "E_VALIDATION"));
+    if ((rows.length > 0 || invalidIdentity) && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorManifestRowsCommand
+};
+//# sourceMappingURL=chunk-NRKWJLMS.js.map

package/dist/cli/chunk-NSHV2JNM.js

@@ -0,0 +1,48 @@
+(() => {
+  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 {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/doctor-legacy-reaper.ts
+import { scanLegacyReaper } from "@cleocode/core/doctor/legacy-reaper.js";
+var doctorLegacyReaperCommand = defineCommand({
+  meta: {
+    name: "legacy-reaper",
+    description: "Detect the legacy cleo-mcp-reaper user timer that kills processes by generic `MainThread` comm \u2014 it terminates live Codex CLI sessions. --fix disables and masks it."
+  },
+  args: {
+    fix: { type: "boolean", description: "Disable and mask any legacy unit that can still fire" },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  run({ args }) {
+    const report = scanLegacyReaper({ fix: args.fix === true });
+    cliOutput(report, { command: "doctor", operation: "doctor.legacy-reaper.run" });
+    if (report.armed && !report.remediated) {
+      if (process.exitCode === void 0 || process.exitCode === 0) process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorLegacyReaperCommand
+};
+//# sourceMappingURL=chunk-NSHV2JNM.js.map

package/dist/cli/chunk-NWTATTEQ.js

@@ -0,0 +1,210 @@
+(() => {
+  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
+} from "./chunk-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/llm-stream.ts
+async function buildSession(provider, model) {
+  const [{ resolveCredentialsAsync }, { ConcreteSession }, { ModelRunner }, { deriveApiWire }] = await Promise.all([
+    import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/credentials.js"
+    ),
+    import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/concrete-session.js"
+    ),
+    import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/model-runner.js"
+    ),
+    import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/api-mode.js"
+    )
+  ]);
+  const cred = await resolveCredentialsAsync(provider);
+  if (!cred.apiKey) {
+    throw new Error(
+      `No credential found for provider '${provider}'. Run \`cleo login ${provider}\` (for OAuth) or \`cleo llm add ${provider} <key>\` (for API key).`
+    );
+  }
+  const wire = deriveApiWire(provider, cred.authType);
+  const resolvedCredential = {
+    provider,
+    label: "default",
+    token: cred.apiKey,
+    authType: cred.authType,
+    expiresAt: null,
+    refreshToken: null,
+    extraHeaders: {},
+    baseUrl: wire.baseUrl,
+    awsProfile: null
+  };
+  const transport = ModelRunner.buildTransportFromCredential(
+    provider,
+    resolvedCredential,
+    wire.apiMode
+  );
+  return new ConcreteSession({ transport, model, credential: resolvedCredential });
+}
+async function getComputeCost() {
+  const { computeCost } = await import(
+    /* webpackIgnore: true */
+    "@cleocode/core/llm/usage-pricing"
+  );
+  return computeCost;
+}
+async function resolveDefaultModel(provider) {
+  const [{ getProviderProfile }, { IMPLICIT_FALLBACK_MODEL }] = await Promise.all([
+    import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/provider-registry/index.js"
+    ),
+    import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/role-resolver.js"
+    )
+  ]);
+  const profile = await getProviderProfile(provider);
+  return profile?.defaultModel ?? IMPLICIT_FALLBACK_MODEL;
+}
+async function runLlmStream(opts) {
+  const stdout = opts.stdout ?? process.stdout;
+  const stderr = opts.stderr ?? process.stderr;
+  const session = opts._sessionOverride ?? await buildSession(opts.provider, opts.model ?? await resolveDefaultModel(opts.provider));
+  const sendOpts = {
+    ...opts.system != null ? { systemSuffix: opts.system } : {}
+  };
+  const messages = [{ role: "user", content: opts.prompt }];
+  let finalUsage = { inputTokens: 0, outputTokens: 0, costUsd: null };
+  const stream = session.stream(messages, sendOpts);
+  for await (const delta of stream) {
+    if (delta.text) {
+      stdout.write(delta.text);
+    }
+    if (delta.reasoning && opts.showThink) {
+      stderr.write(delta.reasoning);
+    }
+    if (delta.usage !== null) {
+      const { inputTokens, outputTokens } = delta.usage;
+      let costUsd = null;
+      try {
+        const computeCost = await getComputeCost();
+        const raw = computeCost({ inputTokens, outputTokens }, session.model);
+        costUsd = raw === 0 ? null : raw;
+      } catch {
+      }
+      finalUsage = { inputTokens, outputTokens, costUsd };
+    }
+  }
+  stderr.write(`${JSON.stringify(finalUsage)}
+`);
+  return finalUsage;
+}
+var streamCommand = defineCommand({
+  meta: {
+    name: "stream",
+    description: "Stream a single-prompt completion via LlmTransport.stream(). Text deltas are written to stdout incrementally. Reasoning/think blocks go to stderr (requires --think). A JSON usage summary is printed to stderr at stream end."
+  },
+  args: {
+    provider: {
+      type: "positional",
+      description: "Provider transport (anthropic | openai | gemini | moonshot | openrouter | \u2026)",
+      required: true
+    },
+    prompt: {
+      type: "positional",
+      description: "Prompt text to send to the model.",
+      required: true
+    },
+    model: {
+      type: "string",
+      description: "Model identifier override (e.g. 'claude-sonnet-4-6'). Uses provider default when omitted."
+    },
+    "max-tokens": {
+      type: "string",
+      description: "Maximum output tokens (default: 4096)."
+    },
+    temperature: {
+      type: "string",
+      description: "Sampling temperature in 0.0\u20131.0 (default: 0.7)."
+    },
+    think: {
+      type: "boolean",
+      description: "Emit reasoning/think blocks to stderr (default: off).",
+      default: false
+    },
+    system: {
+      type: "string",
+      description: "Optional system prompt prepended to the conversation."
+    }
+  },
+  async run({ args }) {
+    const a = args;
+    const provider = String(a["provider"] ?? "").trim();
+    const prompt = String(a["prompt"] ?? "").trim();
+    if (!provider) {
+      cliError(
+        "cleo llm stream: <provider> is required.",
+        2,
+        { name: "E_VALIDATION", fix: "Pass a provider as the first positional argument." },
+        { operation: "llm.stream" }
+      );
+      process.exit(2);
+    }
+    if (!prompt) {
+      cliError(
+        "cleo llm stream: <prompt> is required.",
+        2,
+        { name: "E_VALIDATION", fix: "Pass a prompt as the second positional argument." },
+        { operation: "llm.stream" }
+      );
+      process.exit(2);
+    }
+    const model = typeof a["model"] === "string" && a["model"] ? a["model"] : void 0;
+    const maxTokensRaw = typeof a["max-tokens"] === "string" ? Number(a["max-tokens"]) : void 0;
+    const maxTokens = maxTokensRaw !== void 0 && !Number.isNaN(maxTokensRaw) ? maxTokensRaw : void 0;
+    const tempRaw = typeof a["temperature"] === "string" ? parseFloat(a["temperature"]) : void 0;
+    const temperature = tempRaw !== void 0 && !Number.isNaN(tempRaw) ? tempRaw : void 0;
+    const showThink = a["think"] === true;
+    const system = typeof a["system"] === "string" && a["system"] ? a["system"] : void 0;
+    void maxTokens;
+    void temperature;
+    try {
+      await runLlmStream({ provider, prompt, model, maxTokens, temperature, showThink, system });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      cliError(
+        `cleo llm stream: ${msg}`,
+        1,
+        { name: "E_LLM_STREAM_FAILED" },
+        { operation: "llm.stream" }
+      );
+      process.exit(1);
+    }
+  }
+});
+
+export {
+  runLlmStream,
+  streamCommand
+};
+//# sourceMappingURL=chunk-NWTATTEQ.js.map

package/dist/cli/chunk-OAPN46TC.js

@@ -0,0 +1,89 @@
+(() => {
+  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 {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/doctor-tool-locks.ts
+import { CANONICAL_TOOLS } from "@cleocode/core/tasks/tool-resolver.js";
+import { listSlotHolders, reapOrphanedSlots } from "@cleocode/core/tasks/tool-semaphore.js";
+var doctorToolLocksCommand = defineCommand({
+  meta: {
+    name: "tool-locks",
+    description: "Inspect the machine-wide evidence-tool semaphore: which slots are held, by which pid, and whether that pid is still alive. Read-only; --reap frees provably-orphaned slots."
+  },
+  args: {
+    reap: {
+      type: "boolean",
+      description: "Free slots whose recorded holder is no longer running. Fails safe: an unknown holder, a holder on another host, or any error counts as ALIVE and is never reaped."
+    },
+    tool: {
+      type: "string",
+      description: "Restrict to one canonical tool (test, build, lint, typecheck, \u2026)."
+    },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run({ args }) {
+    const requested = typeof args.tool === "string" && args.tool.length > 0 ? args.tool : null;
+    const tools = requested ? CANONICAL_TOOLS.filter((t) => t === requested) : [...CANONICAL_TOOLS];
+    if (requested && tools.length === 0) {
+      cliOutput(
+        { error: `Unknown canonical tool "${requested}"`, known: [...CANONICAL_TOOLS] },
+        { command: "doctor", operation: "doctor.tool-locks.run" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const reaped = [];
+    if (args.reap === true) {
+      for (const tool of tools) reaped.push(...reapOrphanedSlots(tool));
+    }
+    const slots = tools.flatMap(
+      (tool) => listSlotHolders(tool).map((row) => ({
+        tool,
+        slot: row.slot,
+        held: row.held,
+        alive: row.alive,
+        orphaned: row.held && !row.alive,
+        holder: row.holder
+      }))
+    );
+    const orphaned = slots.filter((s) => s.orphaned);
+    cliOutput(
+      {
+        slots,
+        heldCount: slots.filter((s) => s.held).length,
+        orphanedCount: orphaned.length,
+        reaped,
+        reapApplied: args.reap === true
+      },
+      { command: "doctor", operation: "doctor.tool-locks.run" }
+    );
+    if (orphaned.length > 0 && (process.exitCode ?? 0) === 0) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorToolLocksCommand
+};
+//# sourceMappingURL=chunk-OAPN46TC.js.map

package/dist/cli/chunk-OGV57L4J.js

@@ -0,0 +1,59 @@
+(() => {
+  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);
+  };
+})();
+
+// packages/cleo/src/cli/paths.ts
+import { BRAIN_DB_FILENAME, CLEO_DIR_NAME, WORKFLOWS_SUBDIR } from "@cleocode/runtime/gateway";
+var AGENTS_SUBDIR = "agents";
+var CANT_AGENTS_SUBDIR = "cant/agents";
+var TEMPLATES_SUBDIR = "templates";
+var RESTORE_IMPORTED_SUBDIR = "restore-imported";
+var TASKS_DB_FILENAME = "tasks.db";
+var CONDUIT_DB_FILENAME = "conduit.db";
+var NEXUS_DB_FILENAME = "nexus.db";
+var SIGNALDOCK_DB_FILENAME = "signaldock.db";
+var CONFIG_JSON = "config.json";
+var PROJECT_INFO_JSON = "project-info.json";
+var PROJECT_CONTEXT_JSON = "project-context.json";
+var RESTORE_CONFLICTS_MD = "restore-conflicts.md";
+var MIGRATE_MEMORY_HASHES_JSON = "migrate-memory-hashes.json";
+var CLEO_INJECTION_MD = "CLEO-INJECTION.md";
+var CLI_PROJECT_BACKUP_FILES = [
+  `${CLEO_DIR_NAME}/${TASKS_DB_FILENAME}`,
+  `${CLEO_DIR_NAME}/${BRAIN_DB_FILENAME}`,
+  `${CLEO_DIR_NAME}/${CONDUIT_DB_FILENAME}`,
+  `${CLEO_DIR_NAME}/${CONFIG_JSON}`,
+  `${CLEO_DIR_NAME}/${PROJECT_INFO_JSON}`,
+  `${CLEO_DIR_NAME}/${PROJECT_CONTEXT_JSON}`
+];
+var CLI_GLOBAL_BACKUP_FILES = [NEXUS_DB_FILENAME, SIGNALDOCK_DB_FILENAME];
+var RESTORE_DEFAULT_FILE = TASKS_DB_FILENAME;
+
+export {
+  CLEO_DIR_NAME,
+  AGENTS_SUBDIR,
+  CANT_AGENTS_SUBDIR,
+  TEMPLATES_SUBDIR,
+  RESTORE_IMPORTED_SUBDIR,
+  CONFIG_JSON,
+  PROJECT_INFO_JSON,
+  RESTORE_CONFLICTS_MD,
+  MIGRATE_MEMORY_HASHES_JSON,
+  CLEO_INJECTION_MD,
+  CLI_PROJECT_BACKUP_FILES,
+  CLI_GLOBAL_BACKUP_FILES,
+  RESTORE_DEFAULT_FILE
+};
+//# sourceMappingURL=chunk-OGV57L4J.js.map