@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/chunk-AWCQH2W5.js

@@ -0,0 +1,35 @@
+(() => {
+  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/dispatch/registry.ts
+import {
+  deriveGatewayMatrix,
+  getActiveDomains,
+  getByDomain,
+  getByGateway,
+  getByTier,
+  getCounts,
+  getGatewayDomains,
+  OPERATIONS,
+  resolve,
+  validateRequiredParams
+} from "@cleocode/runtime/gateway";
+
+export {
+  OPERATIONS,
+  resolve
+};
+//# sourceMappingURL=chunk-AWCQH2W5.js.map

package/dist/cli/chunk-AYA6F4ZT.js

@@ -0,0 +1,56 @@
+(() => {
+  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-malformed-ids.ts
+import { getProjectRoot } from "@cleocode/core";
+import { scanMalformedTaskIds } from "@cleocode/core/doctor/malformed-task-ids.js";
+var doctorMalformedIdsCommand = defineCommand({
+  meta: {
+    name: "malformed-ids",
+    description: "Report task rows whose id is not a valid task identifier \u2014 rows that `cleo list` returns but `show`/`update`/`delete` cannot address. Read-only unless --fix is given; --fix refuses any row other tables still reference, and reports them instead."
+  },
+  args: {
+    fix: {
+      type: "boolean",
+      description: "Delete unaddressable rows in one transaction. Refuses any row still referenced by another table \u2014 deleting those would manufacture the orphans `doctor fk-check` detects."
+    },
+    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 report = await scanMalformedTaskIds(getProjectRoot(), { fix: args.fix === true });
+    cliOutput(report, {
+      command: "doctor",
+      operation: "doctor.malformed-ids.run"
+    });
+    const unresolved = report.rows.length > 0 && !report.deleted;
+    if (unresolved && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorMalformedIdsCommand
+};
+//# sourceMappingURL=chunk-AYA6F4ZT.js.map

package/dist/cli/chunk-BCEXRFA2.js

@@ -0,0 +1,76 @@
+(() => {
+  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-credentials.ts
+import { join } from "node:path";
+import { getCleoHome, getProjectRoot } from "@cleocode/core/paths.js";
+import {
+  auditAgentRegistryKeys,
+  migrateProjectCredentialsAtRoot
+} from "@cleocode/core/store/credential-transfer.js";
+var doctorCredentialsCommand = defineCommand({
+  meta: {
+    name: "credentials",
+    description: "Report project credentials still encrypted under the legacy path-bound key (moving the project would strand them) and agent registry keys that are not recoverable. --fix re-keys project credentials to the project's identity in place and flags unrecoverable agent keys requires_reauth. Idempotent; never deletes. Unrecoverable credentials are listed with their re-entry command."
+  },
+  args: {
+    fix: {
+      type: "boolean",
+      description: "Re-key path-bound credentials in place (default: report only)."
+    },
+    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 dryRun = args.fix !== true;
+    const result = await migrateProjectCredentialsAtRoot(getProjectRoot(), { dryRun });
+    const agents = await auditAgentRegistryKeys(join(getCleoHome(), "cleo.db"), { dryRun });
+    cliOutput(
+      {
+        projectDbPath: result.projectDbPath,
+        projectId: result.projectId,
+        applied: !result.dryRun,
+        [result.dryRun ? "wouldMigrate" : "migrated"]: result.migrated,
+        current: result.current,
+        requiresReentry: result.reentry,
+        agentRegistry: {
+          globalDbPath: agents.globalDbPath,
+          current: agents.current,
+          requiresReentry: agents.reentry,
+          flaggedRequiresReauth: agents.flagged
+        }
+      },
+      { command: "doctor", operation: "doctor.credentials.run" }
+    );
+    const pending = result.dryRun && result.migrated.length > 0;
+    const unrecoverable = result.reentry.length + agents.reentry.length;
+    if ((pending || unrecoverable > 0) && (process.exitCode ?? 0) === 0) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorCredentialsCommand
+};
+//# sourceMappingURL=chunk-BCEXRFA2.js.map

package/dist/cli/chunk-BPEVD37G.js

@@ -0,0 +1,124 @@
+(() => {
+  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/llm-cost.ts
+import { getProjectRoot } from "@cleocode/core/internal";
+import { computeCost } from "@cleocode/core/llm/usage-pricing";
+function resolveSessionId(raw) {
+  if (raw === "current") {
+    const envId = process.env["CLEO_SESSION_ID"];
+    if (envId) return envId;
+    return "current";
+  }
+  return raw;
+}
+async function loadSessionCostBreakdown(projectRoot, sessionId) {
+  const { listTokenUsage } = await import(
+    /* webpackIgnore: true */
+    "@cleocode/core/internal"
+  );
+  const result = await listTokenUsage(projectRoot, {
+    sessionId,
+    limit: 1e3
+    // Practical upper bound for a single session.
+  });
+  const entries = result.records.map(
+    (row) => {
+      const usage = {
+        inputTokens: row.inputTokens,
+        outputTokens: row.outputTokens
+      };
+      const model = row.model ?? "unknown";
+      return {
+        id: row.id,
+        provider: row.provider,
+        model: row.model,
+        usage,
+        costUsd: computeCost(usage, model),
+        createdAt: row.createdAt
+      };
+    }
+  );
+  entries.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return entries;
+}
+var costCommand = defineCommand({
+  meta: {
+    name: "cost",
+    description: 'Compute cumulative USD cost for an LLM session from recorded token_usage entries. Use "current" to resolve the active session from CLEO_SESSION_ID. Returns totalUsd=0 when no usage records exist yet (ADR-072 Wave 4b pending).'
+  },
+  args: {
+    sessionId: {
+      type: "positional",
+      description: 'Session id to query, or "current" for the active session',
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    const a = args;
+    const rawSessionId = String(a["sessionId"] ?? "");
+    if (!rawSessionId) {
+      cliError("session-id is required", 6, {
+        name: "E_VALIDATION",
+        fix: 'Provide a session id or "current": cleo llm cost <session-id>'
+      });
+      process.exit(6);
+    }
+    const sessionId = resolveSessionId(rawSessionId);
+    const projectRoot = getProjectRoot(process.cwd());
+    let breakdown;
+    try {
+      breakdown = await loadSessionCostBreakdown(projectRoot, sessionId);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`Failed to query token_usage: ${message}`, 1, {
+        name: "E_QUERY_FAILED",
+        fix: "Ensure tasks.db is initialized: cleo session start"
+      });
+      process.exit(1);
+    }
+    const totalUsd = breakdown.reduce((sum, entry) => sum + entry.costUsd, 0);
+    const result = {
+      sessionId,
+      totalUsd,
+      recordCount: breakdown.length,
+      breakdown
+    };
+    if (breakdown.length === 0) {
+      result.note = "No token_usage records found for this session. Live usage wiring is pending ADR-072 Wave 4b (LlmExecutor done event). Records will appear automatically once that wave ships.";
+    }
+    cliOutput(result, {
+      command: "llm-cost",
+      operation: "llm.cost"
+    });
+  }
+});
+
+export {
+  costCommand
+};
+//# sourceMappingURL=chunk-BPEVD37G.js.map

package/dist/cli/chunk-C3B7C43W.js

@@ -0,0 +1,16 @@
+(() => {
+  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);
+  };
+})();
+//# sourceMappingURL=chunk-C3B7C43W.js.map

package/dist/cli/chunk-DVTPIZJM.js

@@ -0,0 +1,72 @@
+(() => {
+  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,
+  humanInfo
+} from "./chunk-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/doctor-exodus.ts
+import { buildExodusHealth } from "@cleocode/core/store/exodus/index.js";
+function fmtBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  if (n < 1024 * 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)} MB`;
+  return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+var doctorExodusCommand = defineCommand({
+  meta: {
+    name: "exodus-health",
+    description: "Read-only exodus health report: per-scope migration state, legacy DB sizes, completion markers, disk headroom, and the kill-switch \u2014 with recommended next steps."
+  },
+  run() {
+    const health = buildExodusHealth(process.cwd());
+    for (const sc of [health.project, health.global]) {
+      humanInfo(
+        `  [${sc.scope}] state=${sc.state}  consolidated=${sc.consolidatedExists ? "yes" : "no"}  marker=${sc.markerPresent ? "yes" : "no"}`
+      );
+      for (const s of sc.legacySources) {
+        humanInfo(
+          `      ${s.present ? "\u2713" : "\xB7"} ${s.name.padEnd(18)} ${s.present ? fmtBytes(s.bytes) : "-"}${s.large ? "  \u26A0 LARGE" : ""}`
+        );
+      }
+    }
+    humanInfo(
+      `  disk: ${fmtBytes(health.availableBytes)} free / ${fmtBytes(health.requiredBytes)} required \u2014 ${health.diskHeadroomOk ? "OK" : "LOW"}`
+    );
+    humanInfo(
+      `  kill-switch (CLEO_DISABLE_EXODUS_ON_OPEN): ${health.killSwitchSet ? "SET" : "off"}`
+    );
+    if (health.recommendations.length > 0) {
+      humanInfo("  recommendations:");
+      for (const r of health.recommendations) humanInfo(`    \u2022 ${r}`);
+    }
+    cliOutput(
+      { kind: "generic", ...health },
+      {
+        command: "doctor exodus",
+        message: `exodus health: project=${health.project.state}, global=${health.global.state}${health.dataParityOk ? "" : `, ${health.dataDeficits} DEFICIT(S)`}.`
+      }
+    );
+  }
+});
+
+export {
+  doctorExodusCommand
+};
+//# sourceMappingURL=chunk-DVTPIZJM.js.map

package/dist/cli/chunk-DYABOIHB.js

@@ -0,0 +1,96 @@
+(() => {
+  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,
+  humanInfo
+} from "./chunk-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/doctor-repair.ts
+import { DB_INVENTORY, ExitCode } from "@cleocode/contracts";
+import { getLogger, getProjectRoot } from "@cleocode/core";
+import { repairMalformedDbs } from "@cleocode/core/store/repair-malformed-dbs.js";
+var doctorRepairCommand = defineCommand({
+  meta: {
+    name: "repair",
+    description: "Detect malformed CLEO databases (PRAGMA quick_check) and restore each from its freshest validated snapshot via the recovery pipeline (quarantine \u2192 restore \u2192 verify). Defaults to every present DB; use --role to narrow, --dry-run to plan without mutating."
+  },
+  args: {
+    role: {
+      type: "string",
+      description: `Repair only this DB role (one of: ${DB_INVENTORY.map((e) => e.role).join(", ")})`,
+      default: ""
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Detect + plan only \u2014 report what would be repaired without quarantining/restoring",
+      default: false
+    },
+    "confirm-owner-store": {
+      type: "boolean",
+      description: "From inside a git worktree: allow overwriting the owning project's LIVE store (refused without it)",
+      default: false
+    }
+  },
+  run({ args }) {
+    const roleArg = typeof args.role === "string" ? args.role.trim() : "";
+    const dryRun = args["dry-run"] === true;
+    if (roleArg.length > 0 && !DB_INVENTORY.some((e) => e.role === roleArg)) {
+      const validRoles = DB_INVENTORY.map((e) => e.role).join(", ");
+      cliError(
+        `Unknown DB role "${roleArg}". Valid roles: ${validRoles}.`,
+        ExitCode.VALIDATION_ERROR,
+        {
+          name: "E_VALIDATION",
+          fix: "Run `cleo doctor repair --help` for the list of valid roles."
+        },
+        { command: "doctor repair" }
+      );
+      process.exitCode = ExitCode.VALIDATION_ERROR;
+      return;
+    }
+    const result = repairMalformedDbs({
+      projectRoot: getProjectRoot(),
+      roles: roleArg.length > 0 ? [roleArg] : void 0,
+      dryRun,
+      logger: getLogger("doctor-repair"),
+      // T12708: the invocation directory; core never falls back to it.
+      cwd: process.cwd(),
+      confirmOwnerStore: args["confirm-owner-store"] === true
+    });
+    for (const r of result.roles) {
+      if (!r.healthy) {
+        humanInfo(`  [${r.action.toUpperCase()}] ${r.role} \u2014 ${r.detail}`);
+      }
+    }
+    const verb = dryRun ? "would repair" : "repaired";
+    cliOutput(result, {
+      command: "doctor repair",
+      message: result.malformedCount === 0 ? `All ${result.roles.length} inspected DB(s) healthy \u2014 nothing to repair.` : `${result.malformedCount} malformed DB(s): ${verb} ${result.repairedCount}, ${result.failedCount} failed.`
+    });
+    if (result.failedCount > 0) {
+      process.exitCode = ExitCode.GENERAL_ERROR;
+    }
+  }
+});
+
+export {
+  doctorRepairCommand
+};
+//# sourceMappingURL=chunk-DYABOIHB.js.map

package/dist/cli/chunk-EBRZ76HS.js

@@ -0,0 +1,51 @@
+(() => {
+  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-nexus-residency.ts
+import { getCleoHome, getProjectRoot } from "@cleocode/core";
+import { scanNexusSchemaResidency } from "@cleocode/core/doctor/nexus-schema-residency.js";
+var doctorNexusResidencyCommand = defineCommand({
+  meta: {
+    name: "nexus-residency",
+    description: "Report nexus tables resident in the wrong store \u2014 graph tables orphaned in the global cleo.db, or a bare-name registry table that resolves in both schemas. Read-only."
+  },
+  args: {
+    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() {
+    const result = scanNexusSchemaResidency(getProjectRoot(), getCleoHome());
+    cliOutput(result, {
+      command: "doctor",
+      operation: "doctor.nexus-residency.run"
+    });
+    if (result.findings.length > 0 && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorNexusResidencyCommand
+};
+//# sourceMappingURL=chunk-EBRZ76HS.js.map

package/dist/cli/chunk-EGOTK2HA.js

@@ -0,0 +1,57 @@
+(() => {
+  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-worktree-stores.ts
+import { scanWorktreeStores } from "@cleocode/core/doctor/worktree-stores.js";
+import { getProjectRoot, resolveStoreOwnerRoot } from "@cleocode/core/paths.js";
+var doctorWorktreeStoresCommand = defineCommand({
+  meta: {
+    name: "worktree-stores",
+    description: "List store files (.cleo/*.db, *.bak) stranded inside the project worktrees and report whether each holds rows newer than the parent store. Read-only \u2014 deletes nothing."
+  },
+  args: {
+    "skip-compare": {
+      type: "boolean",
+      description: "List files only; skip the per-table row comparison against the parent store"
+    },
+    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 = resolveStoreOwnerRoot(getProjectRoot());
+    const result = scanWorktreeStores(projectRoot, { skipCompare: args["skip-compare"] === true });
+    cliOutput(result, {
+      command: "doctor",
+      operation: "doctor.worktree-stores.run",
+      message: `${result.strandedFileCount} stranded store file(s) in ${result.entries.length} worktree(s); ${result.filesWithNewerRows.length} hold rows the parent store lacks.`
+    });
+    if (result.filesWithNewerRows.length > 0 && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorWorktreeStoresCommand
+};
+//# sourceMappingURL=chunk-EGOTK2HA.js.map