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

package/dist/cli/chunk-VB3LDPL5.js

@@ -0,0 +1,46 @@
+(() => {
+  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/renderers/colors.ts
+import {
+  BLUE,
+  BOLD,
+  BOX,
+  CYAN,
+  DIM,
+  GREEN,
+  hRule,
+  MAGENTA,
+  NC,
+  priorityColor,
+  prioritySymbol,
+  RED,
+  shortDate,
+  statusColor,
+  statusSymbol,
+  YELLOW
+} from "@cleocode/core/render/colors";
+
+export {
+  BOLD,
+  CYAN,
+  DIM,
+  GREEN,
+  NC,
+  RED,
+  YELLOW
+};
+//# sourceMappingURL=chunk-VB3LDPL5.js.map

package/dist/cli/chunk-VLEYOOPH.js

@@ -0,0 +1,31 @@
+(() => {
+  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/cleo-error-like.ts
+function asCleoErrorLike(err) {
+  if (!(err instanceof Error)) return null;
+  const candidate = err;
+  return typeof candidate.code === "number" && Number.isInteger(candidate.code) && typeof candidate.toLAFSError === "function" ? candidate : null;
+}
+function cleoErrorCodeName(typed) {
+  return typeof typed.codeName === "string" && typed.codeName.length > 0 ? typed.codeName : typed.toLAFSError().code;
+}
+
+export {
+  asCleoErrorLike,
+  cleoErrorCodeName
+};
+//# sourceMappingURL=chunk-VLEYOOPH.js.map

package/dist/cli/chunk-W3JLYKKY.js

@@ -0,0 +1,140 @@
+(() => {
+  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 {
+  isQuiet
+} from "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/progress.ts
+import { stderr } from "node:process";
+var ProgressTracker = class {
+  enabled;
+  prefix;
+  currentStep = 0;
+  totalSteps;
+  steps;
+  constructor(options) {
+    this.enabled = options.enabled;
+    this.prefix = options.prefix ?? "CLEO";
+    this.steps = options.steps;
+    this.totalSteps = options.steps.length;
+  }
+  /**
+   * Start the progress tracker.
+   */
+  start() {
+    if (!this.enabled || isQuiet()) return;
+    this.currentStep = 0;
+    stderr.write(`
+${this.prefix}: Starting...
+`);
+  }
+  /**
+   * Update to a specific step.
+   */
+  step(index, message) {
+    if (!this.enabled || isQuiet()) return;
+    this.currentStep = index;
+    const stepName = this.steps[index] ?? message ?? "Working...";
+    const progress = `[${index + 1}/${this.totalSteps}]`;
+    stderr.write(`  ${progress} ${stepName}...
+`);
+  }
+  /**
+   * Move to next step.
+   */
+  next(message) {
+    this.step(this.currentStep + 1, message);
+  }
+  /**
+   * Mark as complete with optional summary.
+   *
+   * @remarks
+   * Writes to stderr (not stdout) so that progress messages never pollute
+   * the machine-readable JSON envelope on stdout. Stdout MUST contain exactly
+   * one JSON object per CLI invocation (ADR-039 / T927).
+   */
+  complete(summary) {
+    if (!this.enabled || isQuiet()) return;
+    if (summary) {
+      stderr.write(`
+${this.prefix}: \u2713 ${summary}
+
+`);
+    } else {
+      stderr.write(`
+${this.prefix}: \u2713 Complete
+
+`);
+    }
+  }
+  /**
+   * Report an error.
+   */
+  error(message) {
+    if (!this.enabled || isQuiet()) return;
+    stderr.write(`
+${this.prefix}: \u2717 ${message}
+
+`);
+  }
+};
+function createSelfUpdateProgress(enabled) {
+  return new ProgressTracker({
+    enabled,
+    prefix: "CLEO",
+    steps: [
+      "Detecting installation type",
+      "Checking current version",
+      "Querying npm registry",
+      "Comparing versions",
+      "Running post-update checks",
+      "Finalizing"
+    ]
+  });
+}
+function createDoctorProgress(enabled) {
+  return new ProgressTracker({
+    enabled,
+    prefix: "CLEO Doctor",
+    steps: [
+      "Checking CLEO directory",
+      "Verifying tasks database",
+      "Checking configuration",
+      "Validating schemas",
+      "Running health checks"
+    ]
+  });
+}
+function createUpgradeProgress(enabled) {
+  return new ProgressTracker({
+    enabled,
+    prefix: "CLEO Upgrade",
+    steps: [
+      "Analyzing current state",
+      "Checking storage migration needs",
+      "Validating schemas",
+      "Applying fixes",
+      "Verifying results"
+    ]
+  });
+}
+
+export {
+  createSelfUpdateProgress,
+  createDoctorProgress,
+  createUpgradeProgress
+};
+//# sourceMappingURL=chunk-W3JLYKKY.js.map

package/dist/cli/chunk-WWCYZYSN.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-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-row-identity.ts
+import { getProjectRoot } from "@cleocode/core/paths.js";
+var doctorRowIdentityCommand = defineCommand({
+  meta: {
+    name: "row-identity",
+    description: "Plan the from-scratch row-identity refill of a store whose identity predates the current recipe: the share verdict, its evidence (link, vault state, journal state, and whether Cleo Nexus holds any checkpoint of the project, asked read-only) and the rows it clears. --refill --apply runs it when the store is provably unshared, after a snapshot."
+  },
+  args: {
+    refill: { type: "boolean", description: "Plan the full refill (a dry run without --apply)" },
+    apply: {
+      type: "boolean",
+      description: "With --refill: snapshot the store, then re-derive every identity value from scratch. Refused unless the verdict is unshared and CLEO_ROW_UID_FILL=1"
+    },
+    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 { rowIdentityRefill } = await import("@cleocode/core/doctor/row-identity-refill.js");
+    const apply = args.refill === true && args.apply === true;
+    const report = await rowIdentityRefill(getProjectRoot(), { apply });
+    cliOutput(report, {
+      command: "doctor",
+      operation: apply ? "doctor.row-identity.refill" : "doctor.row-identity.plan"
+    });
+    const failed = report.action === "refuse" || apply && !report.applied && report.action !== "none";
+    if (failed && (process.exitCode ?? 0) === 0) process.exitCode = 1;
+  }
+});
+
+export {
+  doctorRowIdentityCommand
+};
+//# sourceMappingURL=chunk-WWCYZYSN.js.map

package/dist/cli/chunk-XA5WISNV.js

@@ -0,0 +1,52 @@
+(() => {
+  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-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-nexus-residency.ts
+import { getCleoHome } from "@cleocode/core/core-paths";
+import { scanNexusSchemaResidency } from "@cleocode/core/doctor/nexus-schema-residency.js";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+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-XA5WISNV.js.map

package/dist/cli/chunk-XHRZ7OYZ.js

@@ -0,0 +1,132 @@
+(() => {
+  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/domains/_meta.ts
+import { createDispatchMeta } from "@cleocode/runtime/gateway/dispatch";
+function dispatchMeta(gateway, domain, operation, startTime, source = "cli") {
+  return createDispatchMeta(gateway, domain, operation, startTime, source);
+}
+
+// packages/cleo/src/dispatch/domains/_base.ts
+function envelopeToEngineResult(envelope) {
+  if (envelope.success) {
+    return {
+      success: true,
+      data: envelope.data,
+      ...envelope.page ? { page: envelope.page } : {}
+    };
+  }
+  const e = envelope.error;
+  return {
+    success: false,
+    error: {
+      code: String(e?.code ?? "E_INTERNAL"),
+      message: e?.message ?? "Unknown error",
+      ...e?.exitCode !== void 0 ? { exitCode: e.exitCode } : {},
+      ...e?.details !== void 0 ? { details: e.details } : {},
+      ...e?.fix !== void 0 ? { fix: e.fix } : {},
+      ...e?.alternatives ? { alternatives: e.alternatives } : {},
+      ...e?.problemDetails !== void 0 ? { problemDetails: e.problemDetails } : {}
+    }
+  };
+}
+function wrapResult(result, gateway, domain, operation, startTime) {
+  if (result.success) {
+    return {
+      meta: dispatchMeta(gateway, domain, operation, startTime),
+      success: true,
+      data: result.data,
+      ...result.page ? { page: result.page } : {}
+    };
+  }
+  return {
+    meta: dispatchMeta(gateway, domain, operation, startTime),
+    success: false,
+    error: {
+      code: result.error.code,
+      message: result.error.message,
+      details: result.error.details,
+      exitCode: result.error.exitCode,
+      fix: result.error.fix,
+      alternatives: result.error.alternatives,
+      ...result.error.problemDetails ? { problemDetails: result.error.problemDetails } : {}
+    }
+  };
+}
+function errorResult(gateway, domain, operation, code, message, startTime) {
+  return {
+    meta: dispatchMeta(gateway, domain, operation, startTime),
+    success: false,
+    error: { code, message }
+  };
+}
+function unsupportedOp(gateway, domain, operation, startTime) {
+  return {
+    meta: dispatchMeta(gateway, domain, operation, startTime),
+    success: false,
+    error: { code: "E_INVALID_OPERATION", message: `Unknown ${domain} ${gateway}: ${operation}` }
+  };
+}
+function getListParams(params) {
+  const limit = typeof params?.limit === "number" && params.limit > 0 ? params.limit : void 0;
+  const offset = typeof params?.offset === "number" && params.offset > 0 ? params.offset : void 0;
+  return { limit, offset };
+}
+function paramString(params, key) {
+  const v = params?.[key];
+  return typeof v === "string" ? v : void 0;
+}
+function paramStringRequired(params, key) {
+  const v = params?.[key];
+  return typeof v === "string" ? v : "";
+}
+function paramNumber(params, key) {
+  const v = params?.[key];
+  return typeof v === "number" ? v : void 0;
+}
+function paramBool(params, key) {
+  const v = params?.[key];
+  return typeof v === "boolean" ? v : void 0;
+}
+function paramStringArray(params, key) {
+  const v = params?.[key];
+  if (!Array.isArray(v)) return void 0;
+  return v.filter((item) => typeof item === "string");
+}
+function handleErrorResult(gateway, domain, operation, error, startTime) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    meta: dispatchMeta(gateway, domain, operation, startTime),
+    success: false,
+    error: { code: "E_INTERNAL", message }
+  };
+}
+
+export {
+  dispatchMeta,
+  envelopeToEngineResult,
+  wrapResult,
+  errorResult,
+  unsupportedOp,
+  getListParams,
+  paramString,
+  paramStringRequired,
+  paramNumber,
+  paramBool,
+  paramStringArray,
+  handleErrorResult
+};
+//# sourceMappingURL=chunk-XHRZ7OYZ.js.map

package/dist/cli/chunk-XLPMIGJJ.js

@@ -0,0 +1,148 @@
+(() => {
+  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,
+  handleRawError,
+  maybeEmitDescribe
+} from "./chunk-L7ONYSV6.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/complete.ts
+var completeCommandArgs = {
+  taskId: {
+    type: "positional",
+    description: "ID of the task to complete",
+    required: true
+  },
+  notes: {
+    type: "string",
+    description: "Completion notes"
+  },
+  changeset: {
+    type: "string",
+    description: "Changeset reference"
+  },
+  "verification-note": {
+    type: "string",
+    description: "Evidence that acceptance criteria were met"
+  },
+  "acknowledge-risk": {
+    type: "string",
+    description: "Reason for acknowledging CRITICAL impact risk (bypasses nexusImpact gate)"
+  },
+  "override-reason": {
+    type: "string",
+    description: "Reason for bypassing E_EPIC_HAS_PENDING_CHILDREN guard (audited to .cleo/audit/premature-close.jsonl)"
+  },
+  // T10509 — AC-coverage gate (load-bearing IVTR closure)
+  "waive-ac": {
+    type: "string",
+    description: "Comma-separated AC tokens (UUIDs or AC<n> aliases) to waive from the AC-coverage gate. Requires --waive-reason. Audited to .cleo/audit/ac-waiver.jsonl."
+  },
+  "waive-reason": {
+    type: "string",
+    description: "Mandatory justification text for --waive-ac. Captured verbatim in the audit row."
+  },
+  // T10538 — cancelled-child waiver gate (PM-Core V2 agent-trust)
+  "waive-cancelled-children": {
+    type: "string",
+    description: "Reason for completing a parent that has cancelled children. Cancelled work does not silently satisfy completion; the reason is audited to .cleo/audit/cancelled-child-waiver.jsonl."
+  },
+  // T11954 (DHQ-071) — depends-edge waiver for stale/over-specified deps
+  "waive-depends": {
+    type: "string",
+    description: "Reason for completing a task whose own work is done but whose depends edges point at not-yet-terminal tasks (stale/over-specified). Audited to .cleo/audit/depends-waiver.jsonl."
+  },
+  // T12503 — optimistic concurrency
+  "if-match": {
+    type: "string",
+    description: "Fail with E_CONFLICT unless the task updatedAt still equals this version (from cleo show). Guards against completing over a concurrent edit."
+  }
+};
+function completeDispatchParams(args) {
+  const str = (key) => args[key];
+  return {
+    taskId: args.taskId,
+    notes: str("notes"),
+    changeset: str("changeset"),
+    verificationNote: str("verification-note"),
+    acknowledgeRisk: str("acknowledge-risk"),
+    overrideReason: str("override-reason"),
+    // T10509 — AC-coverage gate waiver path
+    waiveAc: str("waive-ac"),
+    waiveReason: str("waive-reason"),
+    // T10538 — cancelled-child waiver (PM-Core V2 agent-trust)
+    cancelledChildWaiverReason: str("waive-cancelled-children"),
+    // T11954 (DHQ-071) — depends-edge waiver for stale/over-specified deps
+    waiveDependsReason: str("waive-depends"),
+    // T12503 — optimistic concurrency
+    expectedUpdatedAt: str("if-match")
+  };
+}
+var completeCommand = defineCommand({
+  meta: {
+    name: "complete",
+    description: "Mark a task as completed (requires active session)"
+  },
+  args: completeCommandArgs,
+  async run({ args }) {
+    if (maybeEmitDescribe("mutate", "tasks", "complete", { command: "complete" })) return;
+    const response = await dispatchRaw("mutate", "tasks", "complete", completeDispatchParams(args));
+    if (!response.success) {
+      handleRawError(response, { command: "complete", operation: "tasks.complete" });
+    }
+    const data = response.data;
+    if (response.meta.mutateProjection === "mvi") {
+      cliOutput(response.data, { command: "complete", operation: "tasks.complete" });
+      return;
+    }
+    const task = data?.task ?? data;
+    const output = { task };
+    if (data?.alreadyDone === true) {
+      output["alreadyDone"] = true;
+    }
+    if (typeof data?.note === "string") {
+      output["note"] = data.note;
+    }
+    const autoCompleted = data?.autoCompleted;
+    if (Array.isArray(autoCompleted) && autoCompleted.length > 0) {
+      output["autoCompleted"] = autoCompleted;
+    }
+    const unblockedTasks = data?.unblockedTasks;
+    if (Array.isArray(unblockedTasks) && unblockedTasks.length > 0) {
+      output["unblockedTasks"] = unblockedTasks;
+    }
+    if (typeof data?.focusCleared === "boolean") output["focusCleared"] = data.focusCleared;
+    if (data?.nextSuggested !== void 0) output["nextSuggested"] = data.nextSuggested;
+    const worktreeAutoComplete = data?.worktreeAutoComplete;
+    if (worktreeAutoComplete && typeof worktreeAutoComplete === "object") {
+      output["worktreeAutoComplete"] = worktreeAutoComplete;
+    }
+    cliOutput(output, { command: "complete", operation: "tasks.complete" });
+  }
+});
+
+export {
+  completeCommandArgs,
+  completeDispatchParams,
+  completeCommand
+};
+//# sourceMappingURL=chunk-XLPMIGJJ.js.map

package/dist/cli/chunk-YY66LFZF.js

@@ -0,0 +1,29 @@
+(() => {
+  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/lib/subcommand-guard.ts
+function isSubCommandDispatch(rawArgs, subCommands) {
+  if (!rawArgs || !subCommands) return false;
+  const firstArg = rawArgs.find((a) => !a.startsWith("-"));
+  if (!firstArg) return false;
+  if (typeof subCommands !== "object") return false;
+  return firstArg in subCommands;
+}
+
+export {
+  isSubCommandDispatch
+};
+//# sourceMappingURL=chunk-YY66LFZF.js.map