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

package/dist/cli/smoke-provider-SKUFMZXU.js

@@ -0,0 +1,218 @@
+(() => {
+  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/admin/smoke-provider.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  BRAIN_DB_FILENAME,
+  CLEO_DIR_NAME,
+  engineError,
+  engineSuccess
+} from "@cleocode/runtime/gateway";
+var VALID_PROVIDER_IDS = [
+  "claude-code",
+  "claude-sdk",
+  "codex",
+  "cursor",
+  "gemini-cli",
+  "kimi",
+  "openai-sdk",
+  "opencode",
+  "pi"
+];
+function isLocal(dbPath, projectCleoDir, cleoHome) {
+  return dbPath.startsWith(projectCleoDir) || dbPath.startsWith(cleoHome);
+}
+function classifySpawn(spawnSrcPath) {
+  if (!existsSync(spawnSrcPath)) return "no";
+  let src;
+  try {
+    src = readFileSync(spawnSrcPath, "utf-8");
+  } catch {
+    return "no";
+  }
+  const hasImpl = /\bspawn\b|\bexec\b|\bfork\b|\bchild_process\b|\bspawnSync\b/.test(src);
+  if (!hasImpl && /\bthrow\b/.test(src)) return "stub";
+  return "yes";
+}
+function countHookEvents(hooksSrcPath, canonicalEvents) {
+  if (!existsSync(hooksSrcPath)) return 0;
+  let src;
+  try {
+    src = readFileSync(hooksSrcPath, "utf-8");
+  } catch {
+    return 0;
+  }
+  let count = 0;
+  for (const event of canonicalEvents) {
+    if (src.includes(event)) count++;
+  }
+  return count;
+}
+function buildReport(partial) {
+  const sep = "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550";
+  const lines = [
+    `CLEO Smoke Probe \u2014 provider: ${partial.providerId}`,
+    sep,
+    `  Adapter loaded:       ${partial.adapterLoaded ? "yes" : "no"}`
+  ];
+  for (const db of partial.dbChecks) {
+    const label = `  ${db.name} local:`.padEnd(24);
+    lines.push(`${label}${db.local ? "yes" : "NO"} (${db.path})`);
+  }
+  lines.push(`  Hooks declared:       ${partial.hooksDeclared}`);
+  lines.push(`  Spawn implementation: ${partial.spawnStatus}`);
+  lines.push(`  Agent folder:         ${partial.agentFolder ?? "(none \u2014 unknown provider)"}`);
+  lines.push("");
+  lines.push(
+    partial.passed ? "Result: PASS" : `Result: FAIL (${partial.failureReason ?? "invariant violated"})`
+  );
+  return lines.join("\n");
+}
+async function smokeProvider(providerId) {
+  if (!VALID_PROVIDER_IDS.includes(providerId)) {
+    return engineError(
+      "E_INVALID_INPUT",
+      `Unknown provider ID: "${providerId}". Valid IDs: ${VALID_PROVIDER_IDS.join(", ")}`
+    );
+  }
+  const coreInternal = await import("@cleocode/core/internal");
+  const projectRoot = (() => {
+    try {
+      return coreInternal.getProjectRoot();
+    } catch {
+      return process.env["CLEO_ROOT"] ?? process.cwd();
+    }
+  })();
+  const monorepoRoot = projectRoot;
+  const adapterDistPath = join(
+    monorepoRoot,
+    "packages",
+    "adapters",
+    "dist",
+    "providers",
+    providerId,
+    "index.js"
+  );
+  let adapterLoaded = false;
+  if (existsSync(adapterDistPath)) {
+    try {
+      const mod = await import(adapterDistPath);
+      const defaultExport = mod["default"];
+      if (typeof defaultExport === "function") {
+        const ctor = defaultExport;
+        try {
+          const instance = new ctor();
+          adapterLoaded = typeof instance.id === "string" && typeof instance.name === "string" && typeof instance.version === "string";
+        } catch {
+          adapterLoaded = existsSync(adapterDistPath);
+        }
+      } else {
+        adapterLoaded = typeof mod["id"] === "string" && typeof mod["name"] === "string";
+      }
+    } catch {
+      adapterLoaded = false;
+    }
+  }
+  const cleoHome = coreInternal.getCleoHome();
+  const projectCleoDir = join(projectRoot, CLEO_DIR_NAME);
+  const taskDbPath = coreInternal.getTaskPath(projectRoot);
+  const brainPath = join(projectCleoDir, BRAIN_DB_FILENAME);
+  const conduitDbPath = coreInternal.getConduitDbPath(projectRoot);
+  const nexusDbPath = coreInternal.getNexusDbPath();
+  const dbChecks = [
+    { name: "brain.db", local: isLocal(brainPath, projectCleoDir, cleoHome), path: brainPath },
+    { name: "nexus.db", local: isLocal(nexusDbPath, projectCleoDir, cleoHome), path: nexusDbPath },
+    {
+      name: "conduit.db",
+      local: isLocal(conduitDbPath, projectCleoDir, cleoHome),
+      path: conduitDbPath
+    },
+    { name: "tasks.db", local: isLocal(taskDbPath, projectCleoDir, cleoHome), path: taskDbPath }
+  ];
+  let canonicalEvents = [];
+  try {
+    const caamp = await import("@cleocode/caamp");
+    canonicalEvents = caamp.CANONICAL_HOOK_EVENTS;
+  } catch {
+    canonicalEvents = [];
+  }
+  const hooksSrcPath = join(
+    monorepoRoot,
+    "packages",
+    "adapters",
+    "src",
+    "providers",
+    providerId,
+    "hooks.ts"
+  );
+  const hooksDeclared = countHookEvents(hooksSrcPath, canonicalEvents);
+  const spawnSrcPath = join(
+    monorepoRoot,
+    "packages",
+    "adapters",
+    "src",
+    "providers",
+    providerId,
+    "spawn.ts"
+  );
+  const spawnStatus = classifySpawn(spawnSrcPath);
+  let agentFolder = null;
+  try {
+    const { getProviderAgentFolder } = await import("@cleocode/caamp");
+    agentFolder = getProviderAgentFolder(providerId);
+  } catch {
+    agentFolder = null;
+  }
+  const dbsLocal = dbChecks.every((c) => c.local);
+  const failReasons = [];
+  if (!adapterLoaded) failReasons.push("adapter did not load or missing id/name/version");
+  if (!dbsLocal) {
+    const nonLocal = dbChecks.filter((c) => !c.local).map((c) => c.name).join(", ");
+    failReasons.push(`non-local DB paths: ${nonLocal}`);
+  }
+  if (agentFolder === null) failReasons.push("agent folder unresolvable (unknown provider)");
+  const passed = failReasons.length === 0;
+  const partial = {
+    providerId,
+    adapterLoaded,
+    dbChecks,
+    hooksDeclared,
+    spawnStatus,
+    agentFolder,
+    passed,
+    ...passed ? {} : { failureReason: failReasons.join("; ") }
+  };
+  const report = buildReport(partial);
+  const result = { ...partial, report };
+  if (!passed) {
+    return {
+      success: false,
+      error: {
+        code: "E_SMOKE_PROVIDER_FAIL",
+        message: `ADR-049 probe FAILED for provider "${providerId}": ${partial.failureReason}`,
+        exitCode: 1,
+        details: { result }
+      }
+    };
+  }
+  return engineSuccess(result);
+}
+export {
+  smokeProvider
+};
+//# sourceMappingURL=smoke-provider-SKUFMZXU.js.map

package/dist/cli/snapshot-EGXEQ5PR.js

@@ -0,0 +1,120 @@
+(() => {
+  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 {
+  dispatchFromCli,
+  dispatchRaw,
+  handleRawError
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/snapshot.ts
+var exportCommand = defineCommand({
+  meta: { name: "export", description: "Export current task state to a portable JSON snapshot" },
+  args: {
+    output: {
+      type: "string",
+      description: "Output file path (default: .cleo/snapshots/snapshot-<timestamp>.json)",
+      alias: "o"
+    },
+    stdout: {
+      type: "boolean",
+      description: "Write snapshot to stdout instead of file"
+    }
+  },
+  async run({ args }) {
+    if (args.stdout) {
+      const response = await dispatchRaw("query", "admin", "export", { scope: "snapshot" });
+      handleRawError(response, { command: "snapshot", operation: "admin.export" });
+      const data = response.data;
+      if (data?.outputPath) {
+        const { readFile } = await import("node:fs/promises");
+        const content = await readFile(data.outputPath, "utf-8");
+        process.stdout.write(content);
+        if (!content.endsWith("\n")) process.stdout.write("\n");
+      }
+      return;
+    }
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "export",
+      {
+        scope: "snapshot",
+        output: args.output
+      },
+      { command: "snapshot" }
+    );
+  }
+});
+var importCommand = defineCommand({
+  meta: {
+    name: "import",
+    description: "Import a task state snapshot into the local database"
+  },
+  args: {
+    file: {
+      type: "positional",
+      description: "Snapshot file to import",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview import without making changes"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "import",
+      {
+        scope: "snapshot",
+        file: args.file,
+        dryRun: args["dry-run"]
+      },
+      { command: "snapshot" }
+    );
+  }
+});
+var snapshotCommand = defineCommand({
+  meta: {
+    name: "snapshot",
+    description: "Export/import task state snapshots for multi-contributor sharing"
+  },
+  subCommands: {
+    export: exportCommand,
+    import: importCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  snapshotCommand
+};
+//# sourceMappingURL=snapshot-EGXEQ5PR.js.map

package/dist/cli/src-LYLXHXHH.js

@@ -0,0 +1,80 @@
+(() => {
+  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 {
+  DEFAULT_POLICY_RULES,
+  E_APPROVAL_ALREADY_DECIDED,
+  E_APPROVAL_NOT_FOUND,
+  E_PLAYBOOK_RESUME_BLOCKED,
+  E_PLAYBOOK_RUNTIME_INVALID,
+  PLAYBOOKS_PACKAGE_VERSION,
+  PlaybookParseError,
+  approveGate,
+  createApprovalGate,
+  createPlaybookApproval,
+  createPlaybookRun,
+  deletePlaybookRun,
+  evaluatePolicy,
+  executePlaybook,
+  generateResumeToken,
+  getPendingApprovals,
+  getPlaybookApprovalByToken,
+  getPlaybookRun,
+  getPlaybookSecret,
+  listPlaybookApprovals,
+  listPlaybookRuns,
+  migratePlaybook,
+  migratePlaybookFile,
+  parsePlaybook,
+  rejectGate,
+  resolveStepBindings,
+  resumePlaybook,
+  updatePlaybookApproval,
+  updatePlaybookRun,
+  validatePlaybookCompliance
+} from "./chunk-NU6CQQVB.js";
+export {
+  DEFAULT_POLICY_RULES,
+  E_APPROVAL_ALREADY_DECIDED,
+  E_APPROVAL_NOT_FOUND,
+  E_PLAYBOOK_RESUME_BLOCKED,
+  E_PLAYBOOK_RUNTIME_INVALID,
+  PLAYBOOKS_PACKAGE_VERSION,
+  PlaybookParseError,
+  approveGate,
+  createApprovalGate,
+  createPlaybookApproval,
+  createPlaybookRun,
+  deletePlaybookRun,
+  evaluatePolicy,
+  executePlaybook,
+  generateResumeToken,
+  getPendingApprovals,
+  getPlaybookApprovalByToken,
+  getPlaybookRun,
+  getPlaybookSecret,
+  listPlaybookApprovals,
+  listPlaybookRuns,
+  migratePlaybook,
+  migratePlaybookFile,
+  parsePlaybook,
+  rejectGate,
+  resolveStepBindings,
+  resumePlaybook,
+  updatePlaybookApproval,
+  updatePlaybookRun,
+  validatePlaybookCompliance
+};
+//# sourceMappingURL=src-LYLXHXHH.js.map

package/dist/cli/start-6DXOCCKL.js

@@ -0,0 +1,68 @@
+(() => {
+  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 {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/start.ts
+var startCommand = defineCommand({
+  meta: {
+    name: "start",
+    description: "Start working on a task (sets it as the current task and takes your session's claim lease)"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "ID of the task to start",
+      required: true
+    },
+    "take-over": {
+      type: "boolean",
+      description: "Take over another session's EXPIRED claim lease on the task (audited)"
+    },
+    "force-claim": {
+      type: "boolean",
+      description: "Take over another session's LIVE claim lease on the task (audited)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "start",
+      {
+        taskId: args.taskId,
+        ...args["take-over"] === true ? { takeOver: true } : {},
+        ...args["force-claim"] === true ? { forceClaim: true } : {}
+      },
+      { command: "start" }
+    );
+  }
+});
+export {
+  startCommand
+};
+//# sourceMappingURL=start-6DXOCCKL.js.map

package/dist/cli/stats-UVUQEGYC.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 {
+  isSubCommandDispatch
+} from "./chunk-YY66LFZF.js";
+import {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/stats.ts
+var complianceCommand = defineCommand({
+  meta: {
+    name: "compliance",
+    description: "Agent workflow compliance dashboard (WF-001 through WF-005)"
+  },
+  args: {
+    since: {
+      type: "string",
+      description: "Filter to tasks/events from this date (ISO 8601)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output raw JSON instead of formatted dashboard"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "workflow.compliance",
+      {
+        since: args.since,
+        json: args.json
+      },
+      { command: "stats compliance", operation: "check.workflow.compliance" }
+    );
+  }
+});
+var statsCommand = defineCommand({
+  meta: { name: "stats", description: "Project statistics (counts, completion rates, velocity)" },
+  args: {
+    period: {
+      type: "string",
+      description: "Analysis period: today/week/month/quarter/year or days",
+      alias: "p",
+      default: "30"
+    },
+    verbose: {
+      type: "boolean",
+      description: "Show detailed breakdowns per category",
+      alias: "v"
+    }
+  },
+  subCommands: {
+    compliance: complianceCommand
+  },
+  async run({ args, cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "stats",
+      {
+        period: args.period ?? 30
+      },
+      { command: "stats", operation: "admin.stats" }
+    );
+  }
+});
+export {
+  statsCommand
+};
+//# sourceMappingURL=stats-UVUQEGYC.js.map