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

package/dist/cli/upgrade-E2MJAPC7.js

@@ -0,0 +1,136 @@
+(() => {
+  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 {
+  dispatchMeta,
+  handleErrorResult,
+  unsupportedOp
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/upgrade.ts
+import { getLogger, getProjectRoot, getWorkflowTemplatesDir } from "@cleocode/core";
+import { upgradeWorkflows } from "@cleocode/core/internal";
+var log = getLogger("domain:upgrade");
+function resolveTemplatesDir() {
+  return getWorkflowTemplatesDir();
+}
+function toDispatchData(result) {
+  return {
+    outcomes: result.outcomes.map((o) => ({
+      template: o.template,
+      targetPath: o.targetPath,
+      status: o.status,
+      overrideDeclared: o.overrideDeclared
+    })),
+    resolvedTools: result.resolvedTools,
+    hasDrift: result.hasDrift
+  };
+}
+var UpgradeHandler = class {
+  /**
+   * Handle read-only upgrade queries.
+   *
+   * Supported operations:
+   *  - `workflows` — drift detection only; never writes to disk.
+   *                  Effectively forces `dryRun=true` at the query gateway.
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    try {
+      switch (operation) {
+        case "workflows": {
+          const includeRendered = params?.["includeRendered"] === true;
+          const result = await upgradeWorkflows({
+            projectRoot: getProjectRoot(),
+            templatesDir: resolveTemplatesDir(),
+            dryRun: true
+          });
+          const data = toDispatchData(result);
+          return {
+            meta: dispatchMeta("query", "upgrade", operation, startTime),
+            success: true,
+            data: includeRendered ? {
+              ...data,
+              rendered: result.outcomes.map((o) => ({
+                template: o.template,
+                rendered: o.rendered
+              }))
+            } : data
+          };
+        }
+        default:
+          return unsupportedOp("query", "upgrade", operation, startTime);
+      }
+    } catch (err) {
+      log.error({ err, operation }, "UpgradeHandler query error");
+      return handleErrorResult("query", "upgrade", operation, err, startTime);
+    }
+  }
+  /**
+   * Handle upgrade mutations.
+   *
+   * Supported operations:
+   *  - `workflows` — re-render + (optionally) re-write drifted files.
+   *                  Params: `{ force?, dryRun? }`. Returns the per-template
+   *                  outcomes plus the `hasDrift` flag the CLI uses to drive
+   *                  the `--check` exit-code contract.
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    try {
+      switch (operation) {
+        case "workflows": {
+          const force = params?.["force"] === true;
+          const dryRun = params?.["dryRun"] === true;
+          const includeRendered = params?.["includeRendered"] === true;
+          const result = await upgradeWorkflows({
+            projectRoot: getProjectRoot(),
+            templatesDir: resolveTemplatesDir(),
+            force,
+            dryRun
+          });
+          const data = toDispatchData(result);
+          return {
+            meta: dispatchMeta("mutate", "upgrade", operation, startTime),
+            success: true,
+            data: includeRendered ? {
+              ...data,
+              rendered: result.outcomes.map((o) => ({
+                template: o.template,
+                rendered: o.rendered
+              }))
+            } : data
+          };
+        }
+        default:
+          return unsupportedOp("mutate", "upgrade", operation, startTime);
+      }
+    } catch (err) {
+      log.error({ err, operation }, "UpgradeHandler mutate error");
+      return handleErrorResult("mutate", "upgrade", operation, err, startTime);
+    }
+  }
+  /** Declared operations for introspection and validation. */
+  getSupportedOperations() {
+    return {
+      query: ["workflows"],
+      mutate: ["workflows"]
+    };
+  }
+};
+export {
+  UpgradeHandler
+};
+//# sourceMappingURL=upgrade-E2MJAPC7.js.map

package/dist/cli/upgrade-XRSQ4RWH.js

@@ -0,0 +1,243 @@
+(() => {
+  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 {
+  getWorkflowTemplatesDir
+} from "./chunk-EIUXVHNF.js";
+import {
+  createUpgradeProgress
+} from "./chunk-W3JLYKKY.js";
+import "./chunk-UWCZY52R.js";
+import "./chunk-GZFVDR44.js";
+import "./chunk-GRU74UE4.js";
+import {
+  negatedFlag
+} from "./chunk-47JYZAMS.js";
+import "./chunk-C3B7C43W.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/upgrade.ts
+import { resolve } from "node:path";
+import { CleoError, diagnoseUpgrade, runUpgrade, upgradeWorkflows } from "@cleocode/core/internal";
+var workflowsSubcommand = defineCommand({
+  meta: {
+    name: "workflows",
+    description: "Re-render the four release-pipeline workflow templates and report drift (T9536)."
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Print the per-template diff without writing.",
+      default: false
+    },
+    check: {
+      type: "boolean",
+      description: "Exit 1 if drift is detected. Implies --dry-run for write semantics.",
+      default: false
+    },
+    force: {
+      type: "boolean",
+      description: "Overwrite drifted files (excluding `.workflow-overrides.yml` keys).",
+      default: false
+    },
+    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 }) {
+    try {
+      const dryRun = args["dry-run"] === true || args.check === true;
+      const force = args.force === true && !dryRun;
+      const result = await upgradeWorkflows({
+        projectRoot: resolve(process.cwd()),
+        templatesDir: getWorkflowTemplatesDir(),
+        dryRun,
+        force
+      });
+      cliOutput(
+        {
+          outcomes: result.outcomes.map((o) => ({
+            template: o.template,
+            targetPath: o.targetPath,
+            status: o.status,
+            overrideDeclared: o.overrideDeclared
+          })),
+          resolvedTools: result.resolvedTools,
+          hasDrift: result.hasDrift,
+          ...dryRun ? {
+            rendered: result.outcomes.map((o) => ({
+              template: o.template,
+              rendered: o.rendered
+            }))
+          } : {}
+        },
+        { command: "upgrade", operation: "upgrade.workflows" }
+      );
+      if (args.check === true && result.hasDrift) {
+        process.exit(1);
+      }
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var upgradeCommand = defineCommand({
+  meta: {
+    name: "upgrade",
+    description: "Unified project maintenance (storage migration, schema repair, structural fixes, doc refresh)"
+  },
+  subCommands: {
+    workflows: workflowsSubcommand
+  },
+  args: {
+    status: {
+      type: "boolean",
+      description: "Show what needs updating without making changes"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview changes without applying"
+    },
+    diagnose: {
+      type: "boolean",
+      description: "Deep inspection of schema, columns, and migration journals"
+    },
+    "include-global": {
+      type: "boolean",
+      description: "Also check global ~/.cleo data"
+    },
+    "no-auto-migrate": {
+      type: "boolean",
+      description: "Skip automatic JSON->SQLite migration"
+    },
+    detect: {
+      type: "boolean",
+      description: "Force re-detection of project type (ignores staleness)"
+    },
+    "map-codebase": {
+      type: "boolean",
+      description: "Run full codebase analysis and store findings to brain.db"
+    },
+    name: {
+      type: "string",
+      description: "Update project name in project-info and nexus registry"
+    },
+    // Global output format flags — read directly from args (no optsWithGlobals in citty)
+    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, cmd, rawArgs }) {
+    const firstPositional = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstPositional && cmd.subCommands && firstPositional in cmd.subCommands) return;
+    const isHuman = args.human === true || !!process.stdout.isTTY && args.json !== true;
+    const progress = createUpgradeProgress(isHuman);
+    try {
+      if (args.diagnose) {
+        progress.start();
+        progress.step(0, "Running deep schema/migration diagnostics");
+        const result2 = await diagnoseUpgrade();
+        progress.step(4, "Diagnostics complete");
+        cliOutput(result2, { command: "upgrade", operation: "upgrade.diagnose" });
+        if (!result2.success) {
+          progress.error(`${result2.summary.errors} error(s) found`);
+          process.exit(1);
+        }
+        progress.complete(
+          `Diagnostics complete: ${result2.summary.ok} ok, ${result2.summary.warnings} warning(s), ${result2.summary.errors} error(s)`
+        );
+        return;
+      }
+      const isDryRun = !!args["dry-run"] || !!args.status;
+      const includeGlobal = !!args["include-global"];
+      const autoMigrate = !negatedFlag(args, "auto-migrate");
+      const forceDetect = !!args.detect;
+      const mapCodebase = !!args["map-codebase"];
+      const projectName = args.name;
+      progress.start();
+      progress.step(0, "Analyzing current state");
+      if (includeGlobal) {
+        progress.step(1, "Checking global ~/.cleo data");
+      } else {
+        progress.step(1, "Checking storage migration needs");
+      }
+      progress.step(2, "Validating schemas");
+      progress.step(3, isDryRun ? "Previewing changes" : "Applying fixes");
+      const result = await runUpgrade({
+        dryRun: isDryRun,
+        includeGlobal,
+        autoMigrate,
+        forceDetect,
+        mapCodebase,
+        projectName
+      });
+      progress.step(4, "Verifying results");
+      cliOutput(
+        {
+          upToDate: result.upToDate,
+          dryRun: result.dryRun,
+          actions: result.actions,
+          applied: result.applied,
+          errors: result.errors.length > 0 ? result.errors : void 0,
+          summary: result.summary,
+          storageMigration: result.storageMigration
+        },
+        { command: "upgrade" }
+      );
+      if (!result.success) {
+        progress.error("Upgrade failed with errors");
+        process.exit(1);
+      }
+      progress.complete(isDryRun ? "Preview complete" : "Upgrade complete");
+    } catch (err) {
+      if (err instanceof CleoError) {
+        progress.error(err.message);
+        cliError(
+          err.message,
+          err.code,
+          { name: "CleoError", fix: err.fix },
+          { operation: "upgrade" }
+        );
+        process.exit(err.code);
+      }
+      progress.error("Unexpected error during upgrade");
+      throw err;
+    }
+  }
+});
+export {
+  upgradeCommand
+};
+//# sourceMappingURL=upgrade-XRSQ4RWH.js.map

package/dist/cli/verify-WASRGDBA.js

@@ -0,0 +1,191 @@
+(() => {
+  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 {
+  negatedFlag
+} from "./chunk-47JYZAMS.js";
+import {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/verify.ts
+import { ExitCode } from "@cleocode/contracts";
+var verifyCommand = defineCommand({
+  meta: { name: "verify", description: "View or modify verification gates for a task" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to inspect or update",
+      required: false
+    },
+    gate: {
+      type: "string",
+      description: "Set a specific gate by name"
+    },
+    value: {
+      type: "string",
+      description: "Gate value: true or false",
+      default: "true"
+    },
+    agent: {
+      type: "string",
+      description: "Agent setting the gate"
+    },
+    all: {
+      type: "boolean",
+      description: "Mark all required gates as passed"
+    },
+    reset: {
+      type: "boolean",
+      description: "Reset verification to initial state"
+    },
+    evidence: {
+      type: "string",
+      description: `Evidence for the gate (T832/ADR-051). Semicolon-separated atoms: 'commit:<sha>', 'files:<p1,p2>', 'test-run:<report.json>' (a runner's JSON report with test counts: vitest --reporter=json / jest --json numTotalTests,numPassedTests,numFailedTests; or a runner's summary {total,passed,failed,skipped}, e.g. {"total":43,"passed":42,"failed":0,"skipped":1}; or node --test {tests,pass,fail,skipped}; counts must be non-negative integers that add up to the total, and any failure refuses. It proves only what the file says: tool:test or ci:<pr> prove the run), 'tool:<name>' (e.g. tool:test, tool:test-affected, tool:lint), 'url:<url>', 'note:<text>', 'ci:<pr>' (required CI green on the merged PR's merge commit; testsPassed/qaPassed, opt-in via evidence.ciSatisfies).`
+    },
+    explain: {
+      type: "boolean",
+      description: "Enrich read-only view with per-gate evidence breakdown, re-validation status, and blockers[] preventing `cleo complete` (T1013 / ADR-051)."
+    },
+    run: {
+      type: "boolean",
+      description: "Execute the task's typed acceptance gates and report the results. Records no verification, so use `--evidence` to attest (T12308); passing results are cached so the attesting write reuses them instead of re-running (T12621). With a write, `--no-run` executes no typed gate and uses only cached passes, refusing with E_GATE_NOT_CACHED when one is missing."
+    },
+    auto: {
+      type: "boolean",
+      description: "Derive the evidence and record every required gate in one write, exactly as `cleo done` does, without completing the task (T12625). Takes --satisfies and --pr."
+    },
+    satisfies: {
+      type: "string",
+      description: 'With --auto: criteria this work satisfies, e.g. "AC1,AC3" or "all"'
+    },
+    pr: {
+      type: "string",
+      description: "With --auto: the merged PR that implements the task"
+    },
+    fresh: {
+      type: "boolean",
+      description: "Bypass the ADR-061 tool cache and re-run every tool: atom (same as CLEO_EVIDENCE_FRESH=1, which still works). Use only when a cached result is suspect, e.g. after adding an untracked file (T12964)."
+    },
+    "shared-evidence": {
+      type: "boolean",
+      description: "Acknowledge that the same evidence atom is applied to >3 distinct tasks in this session (T1502 / ADR-059). Without this flag, such reuse triggers a warning; in strict mode (CLEO_STRICT_EVIDENCE=1) it is a hard reject."
+    }
+  },
+  async run({ args, cmd }) {
+    if (!args.taskId) {
+      await showUsage(cmd);
+      return;
+    }
+    const isWrite = !!(args.gate || args.all || args.reset);
+    const priorFresh = process.env["CLEO_EVIDENCE_FRESH"];
+    if (args.fresh === true) process.env["CLEO_EVIDENCE_FRESH"] = "1";
+    try {
+      if (args.auto === true) {
+        if (isWrite || args.evidence || args.run === true) {
+          cliError(
+            "--auto derives its own evidence; drop --gate/--all/--reset/--evidence/--run",
+            "E_INVALID_INPUT"
+          );
+          process.exitCode = ExitCode.VALIDATION_ERROR;
+          return;
+        }
+        const { parseDoneOptions } = await import("@cleocode/core/tasks/done-plan.js");
+        const parsed = parseDoneOptions(args.satisfies, args.pr);
+        if (!parsed.ok) {
+          cliError(parsed.message, "E_INVALID_INPUT");
+          process.exitCode = ExitCode.VALIDATION_ERROR;
+          return;
+        }
+        const { recordTaskDone } = await import("@cleocode/core/tasks/done-record.js");
+        const { getProjectRoot } = await import("@cleocode/core/paths.js");
+        const r = await recordTaskDone(args.taskId, {
+          projectRoot: getProjectRoot(),
+          ...parsed.options,
+          ...args.agent ? { agent: args.agent } : {}
+        });
+        if (!r.success) {
+          cliError(r.error.message, r.error.code, { fix: r.error.fix, details: r.error.details });
+          process.exitCode = r.error.exitCode ?? 1;
+          return;
+        }
+        const { plan: _plan, ...summary } = r.data;
+        cliOutput(summary, { command: "verify", operation: "check.gate.auto" });
+        return;
+      }
+      if (args.satisfies !== void 0 || args.pr !== void 0) {
+        cliError("--satisfies and --pr apply only with --auto (or cleo done)", "E_INVALID_INPUT");
+        process.exitCode = ExitCode.VALIDATION_ERROR;
+        return;
+      }
+      if (args.run === true && isWrite) {
+        cliError(
+          "--run reports typed gate results and records nothing; it cannot be combined with --gate/--all/--reset.",
+          ExitCode.VALIDATION_ERROR,
+          {
+            name: "E_VALIDATION",
+            fix: "Run `cleo verify <id> --run` first, then attest with `cleo verify <id> --gate <name> --evidence <atoms>`"
+          },
+          { operation: "check.gate.run" }
+        );
+        process.exitCode = ExitCode.VALIDATION_ERROR;
+        return;
+      }
+      const useExplain = !isWrite && args.explain === true;
+      const operation = isWrite ? "gate.set" : args.run === true ? "gate.run" : useExplain ? "verify.explain" : "gate.status";
+      await dispatchFromCli(
+        isWrite ? "mutate" : "query",
+        "check",
+        operation,
+        {
+          taskId: args.taskId,
+          gate: args.gate,
+          value: args.value === "false" ? false : args.gate ? true : void 0,
+          agent: args.agent,
+          all: args.all,
+          reset: args.reset,
+          evidence: args.evidence,
+          sharedEvidence: args["shared-evidence"] ?? false,
+          // T12621: citty turns `--no-run` into `run: false`; read it through the helper.
+          ...isWrite && negatedFlag(args, "run") ? { noRun: true } : {}
+        },
+        { command: "verify" }
+      );
+    } finally {
+      if (args.fresh === true) {
+        if (priorFresh === void 0) delete process.env["CLEO_EVIDENCE_FRESH"];
+        else process.env["CLEO_EVIDENCE_FRESH"] = priorFresh;
+      }
+    }
+  }
+});
+export {
+  verifyCommand
+};
+//# sourceMappingURL=verify-WASRGDBA.js.map