@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/chunk-YUZJI67I.js

@@ -0,0 +1,108 @@
+(() => {
+  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-skill-fixtures.ts
+import {
+  auditSkillFixtures,
+  repairSkillFixtures,
+  restoreSkillFixtures
+} from "@cleocode/core/system/skill-fixtures.js";
+var doctorSkillFixturesCommand = defineCommand({
+  meta: {
+    name: "skill-fixtures",
+    description: "Find caamp test fixtures left in the real skills root (UUID-named and known fixture dirs whose content matches the tests). Read-only; --repair quarantines them with a receipt (--dry-run to preview)."
+  },
+  args: {
+    repair: {
+      type: "boolean",
+      description: "Move every fixture into <cleoHome>/audit/skill-fixture-quarantine/<receiptId>/ and append a receipt. Unclassified entries are reported, never moved."
+    },
+    restore: {
+      type: "string",
+      description: "Move the entries quarantined by this repair receipt id back to their original paths (never over an occupied path). Appends a restored receipt."
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "With --repair or --restore: report the receipt without touching disk"
+    },
+    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["dry-run"] === true;
+    if (typeof args.restore === "string" && args.restore.length > 0) {
+      try {
+        const receipt = restoreSkillFixtures(args.restore, { dryRun });
+        cliOutput(
+          { restore: receipt, audit: auditSkillFixtures() },
+          { command: "doctor", operation: "doctor.skill-fixtures.run" }
+        );
+        if (receipt.skipped.length > 0 && !dryRun) process.exitCode = 1;
+      } catch (err) {
+        cliError(
+          err instanceof Error ? err.message : String(err),
+          1,
+          {
+            name: "E_SKILL_FIXTURE_RESTORE_FAILED",
+            fix: "Pass a receipt id from <cleoHome>/audit/skill-fixtures.jsonl whose repair finished and has not been restored. Entries restored before a failure are listed in that file; the rest stay in quarantine."
+          },
+          { operation: "doctor.skill-fixtures.run" }
+        );
+        process.exitCode = 1;
+      }
+      return;
+    }
+    let result = null;
+    if (args.repair === true) {
+      try {
+        result = repairSkillFixtures({ dryRun });
+      } catch (err) {
+        cliError(
+          err instanceof Error ? err.message : String(err),
+          1,
+          {
+            name: "E_SKILL_FIXTURE_REPAIR_FAILED",
+            fix: "Entries moved before the failure are in the quarantine dir named by the intent receipt in <cleoHome>/audit/skill-fixtures.jsonl; the rest are untouched. Re-run `cleo doctor skill-fixtures --repair`."
+          },
+          { operation: "doctor.skill-fixtures.run" }
+        );
+        process.exitCode = 1;
+        return;
+      }
+    }
+    const audit = result?.audit ?? auditSkillFixtures();
+    cliOutput(
+      { ...audit, receipt: result?.receipt ?? null },
+      { command: "doctor", operation: "doctor.skill-fixtures.run" }
+    );
+    if (!audit.healthy && !dryRun && (process.exitCode ?? 0) === 0) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorSkillFixturesCommand
+};
+//# sourceMappingURL=chunk-YUZJI67I.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

package/dist/cli/chunk-ZBISIPCK.js

@@ -0,0 +1,78 @@
+(() => {
+  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/describe-context.ts
+var describeRequested = false;
+function setDescribeMode(requested) {
+  describeRequested = requested;
+}
+function isDescribeMode() {
+  return describeRequested;
+}
+
+// packages/cleo/src/cli/idempotency-context.ts
+var currentIdempotencyKey;
+function setIdempotencyKeyContext(key) {
+  currentIdempotencyKey = key;
+}
+function getIdempotencyKeyContext() {
+  return currentIdempotencyKey;
+}
+function extractIdempotencyKeyArg(argv) {
+  const sanitized = [];
+  let idempotencyKey;
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--") {
+      sanitized.push(...argv.slice(i));
+      break;
+    }
+    if (token === "--idempotency-key") {
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) {
+        idempotencyKey = next;
+        i++;
+      }
+      continue;
+    }
+    if (token?.startsWith("--idempotency-key=")) {
+      idempotencyKey = token.slice("--idempotency-key=".length);
+      continue;
+    }
+    if (token !== void 0) sanitized.push(token);
+  }
+  return { argv: sanitized, idempotencyKey };
+}
+
+// packages/cleo/src/cli/projection-context.ts
+var currentOptOut = false;
+function setProjectionOptOut(optOut) {
+  currentOptOut = optOut;
+}
+function getProjectionOptOut() {
+  return currentOptOut;
+}
+
+export {
+  setDescribeMode,
+  isDescribeMode,
+  setIdempotencyKeyContext,
+  getIdempotencyKeyContext,
+  extractIdempotencyKeyArg,
+  setProjectionOptOut,
+  getProjectionOptOut
+};
+//# sourceMappingURL=chunk-ZBISIPCK.js.map

package/dist/cli/chunk-ZZTHTMQP.js

@@ -0,0 +1,77 @@
+(() => {
+  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-ac-bindings.ts
+import { ExitCode } from "@cleocode/contracts";
+import { scanOrphanAcBindings } from "@cleocode/core/doctor/orphan-ac-bindings.js";
+import { getProjectRoot } from "@cleocode/core/paths.js";
+var doctorAcBindingsCommand = defineCommand({
+  meta: {
+    name: "ac-bindings",
+    description: "Report evidence bindings whose acceptance criterion no longer exists (dangling tasks_evidence_ac_bindings rows). Read-only unless --fix is given; --fix removes them, recording each removed row in the task audit log (ac.bindings.pruned)."
+  },
+  args: {
+    fix: {
+      type: "boolean",
+      description: "Delete the orphan bindings in one transaction, after writing each row to the task audit log so binding history (alias-drift detection) is kept."
+    },
+    limit: {
+      type: "string",
+      description: "Maximum orphan rows echoed in the report (default 50; counts are exact)"
+    },
+    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 }) {
+    let limit;
+    if (typeof args.limit === "string") {
+      if (!/^\d+$/.test(args.limit.trim())) {
+        cliError(
+          `--limit must be a non-negative integer (got '${args.limit}')`,
+          ExitCode.VALIDATION_ERROR,
+          { name: "E_VALIDATION" }
+        );
+        return;
+      }
+      limit = Number.parseInt(args.limit, 10);
+    }
+    const report = await scanOrphanAcBindings(getProjectRoot(), {
+      fix: args.fix === true,
+      limit
+    });
+    cliOutput(report, {
+      command: "doctor",
+      operation: "doctor.ac-bindings.run"
+    });
+    const unresolved = report.orphanCount > report.removed;
+    if (unresolved && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorAcBindingsCommand
+};
+//# sourceMappingURL=chunk-ZZTHTMQP.js.map

package/dist/cli/claim-KPENYHIQ.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 {
+  dispatchFromCli
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/claim.ts
+var claimCommand = defineCommand({
+  meta: {
+    name: "claim",
+    description: "Take, renew (--renew) or override (--take-over expired, --force-claim live) your session's leased claim on a task"
+  },
+  args: {
+    taskId: { type: "positional", description: "Task ID to claim", required: true },
+    agent: {
+      type: "string",
+      description: "Agent ID recorded with the lease (default: the session's agent / CLEO_AGENT_ID)"
+    },
+    renew: { type: "boolean", description: "Renew your own lease on the task" },
+    "take-over": {
+      type: "boolean",
+      description: "Take over another session's EXPIRED lease (audited)"
+    },
+    "force-claim": {
+      type: "boolean",
+      description: "Take over another session's LIVE lease (audited)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "claim",
+      {
+        taskId: args.taskId,
+        ...typeof args.agent === "string" && args.agent ? { agentId: args.agent } : {},
+        ...args.renew === true ? { renew: true } : {},
+        ...args["take-over"] === true ? { takeOver: true } : {},
+        ...args["force-claim"] === true ? { forceClaim: true } : {}
+      },
+      { command: "claim", operation: "tasks.claim" }
+    );
+  }
+});
+var unclaimCommand = defineCommand({
+  meta: {
+    name: "unclaim",
+    description: "Release your session's claim lease on a task (--force-claim: another session's)"
+  },
+  args: {
+    taskId: { type: "positional", description: "Task ID to unclaim", required: true },
+    "force-claim": {
+      type: "boolean",
+      description: "Release another session's lease (audited)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "unclaim",
+      {
+        taskId: args.taskId,
+        ...args["force-claim"] === true ? { forceClaim: true } : {}
+      },
+      { command: "unclaim", operation: "tasks.unclaim" }
+    );
+  }
+});
+export {
+  claimCommand,
+  unclaimCommand
+};
+//# sourceMappingURL=claim-KPENYHIQ.js.map

package/dist/cli/classify-DRVMCFQU.js

@@ -0,0 +1,117 @@
+(() => {
+  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 "./chunk-C3B7C43W.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/classify.ts
+import { classifyReadinessWithDecision, classifyTask, getProjectRoot } from "@cleocode/core";
+var classifyCommand = defineCommand({
+  meta: {
+    name: "classify",
+    description: "Classify a task: readiness verdict (proceed|grill) + persona routing (agent, confidence)"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to classify (e.g. T1234)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const taskId = args.taskId;
+    const projectRoot = getProjectRoot();
+    const { getDb } = await import("@cleocode/core/store/sqlite.js");
+    const { tasks } = await import("@cleocode/core/store/tasks-schema");
+    const { eq } = await import("drizzle-orm");
+    const db = await getDb(projectRoot);
+    const row = await db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+    if (!row) {
+      cliOutput(
+        {
+          success: false,
+          error: { code: "E_NOT_FOUND", message: `Task ${taskId} not found` }
+        },
+        { command: "classify", operation: "classify.show" }
+      );
+      return;
+    }
+    const labels = (() => {
+      try {
+        const parsed = JSON.parse(row.labelsJson ?? "[]");
+        return Array.isArray(parsed) ? parsed : [];
+      } catch {
+        return [];
+      }
+    })();
+    const acceptance = (() => {
+      try {
+        const parsed = JSON.parse(row.acceptanceJson ?? "[]");
+        return Array.isArray(parsed) ? parsed : [];
+      } catch {
+        return [];
+      }
+    })();
+    const task = {
+      id: row.id,
+      title: row.title,
+      description: row.description ?? "",
+      status: row.status,
+      priority: row.priority ?? "medium",
+      type: row.type ?? void 0,
+      kind: row.kind ?? void 0,
+      size: row.size ?? void 0,
+      pipelineStage: row.pipelineStage ?? void 0,
+      blockedBy: row.blockedBy ?? void 0,
+      phase: row.phase ?? void 0,
+      scope: row.scope ?? void 0,
+      labels,
+      acceptance,
+      createdAt: row.createdAt
+    };
+    const readiness = await classifyReadinessWithDecision(task, {}, { projectRoot });
+    const routing = classifyTask(task);
+    cliOutput(
+      {
+        taskId: row.id,
+        title: row.title,
+        readiness: {
+          verdict: readiness.verdict,
+          reason: readiness.reason,
+          triggers: readiness.triggers
+        },
+        routing: {
+          agentId: routing.agentId,
+          role: routing.role,
+          confidence: routing.confidence,
+          reason: routing.reason,
+          usedFallback: routing.usedFallback,
+          warning: routing.warning
+        }
+      },
+      { command: "classify", operation: "classify.show" }
+    );
+  }
+});
+export {
+  classifyCommand
+};
+//# sourceMappingURL=classify-DRVMCFQU.js.map

package/dist/cli/cli-T3CR7J57.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 {
+  createCliDispatcher,
+  createCliGatewayHandler,
+  dispatchFromCli,
+  dispatchRaw,
+  getCliDispatcher,
+  handleRawError,
+  heartbeatCliSession,
+  lookupCliSession,
+  maybeEmitDescribe,
+  resetCliDispatcher,
+  warnUnboundMutation
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+export {
+  createCliDispatcher,
+  createCliGatewayHandler,
+  dispatchFromCli,
+  dispatchRaw,
+  getCliDispatcher,
+  handleRawError,
+  heartbeatCliSession,
+  lookupCliSession,
+  maybeEmitDescribe,
+  resetCliDispatcher,
+  warnUnboundMutation
+};
+//# sourceMappingURL=cli-T3CR7J57.js.map