@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/provenance-C7AYD7WG.js

@@ -0,0 +1,128 @@
+(() => {
+  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,
+  showUsage
+} 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/provenance.ts
+var backfillCommand = defineCommand({
+  meta: {
+    name: "backfill",
+    description: "Walk historical git tags from --since and populate the 11 provenance tables"
+  },
+  args: {
+    since: {
+      type: "string",
+      description: "Lower-bound version (exclusive). Tags newer than this are reconciled. Empty string = all tags.",
+      required: true
+    },
+    "force-overwrite": {
+      type: "boolean",
+      description: "UPDATE existing rows on conflict (audit-logged). Default: UPSERT-on-insert only."
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Enumerate the tag set + return the plan without writing to the DB"
+    },
+    "reset-checkpoint": {
+      type: "boolean",
+      description: "Clear the existing .cleo/release/backfill-state.json before starting (do NOT resume)"
+    },
+    json: { type: "boolean", description: "Emit LAFS envelope" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "provenance",
+      "backfill",
+      {
+        since: args.since,
+        forceOverwrite: args["force-overwrite"] === true,
+        dryRun: args["dry-run"] === true,
+        resetCheckpoint: args["reset-checkpoint"] === true
+      },
+      { command: "provenance" }
+    );
+  }
+});
+var verifyCommand = defineCommand({
+  meta: {
+    name: "verify",
+    description: "Audit the 11 provenance tables for a release (FK integrity, orphans, evidence staleness)"
+  },
+  args: {
+    version: {
+      type: "positional",
+      description: "Release version to verify (e.g. v2026.6.0). Optional when --all is set.",
+      required: false
+    },
+    all: {
+      type: "boolean",
+      description: "Verify the most-recent N releases instead of a single version"
+    },
+    limit: {
+      type: "string",
+      description: "How many releases to verify in --all mode (default 5)"
+    },
+    json: { type: "boolean", description: "Emit LAFS envelope" }
+  },
+  async run({ args }) {
+    const version = typeof args.version === "string" ? args.version : void 0;
+    const all = args.all === true;
+    const limitArg = typeof args.limit === "string" ? args.limit : void 0;
+    const limit = limitArg ? Number.parseInt(limitArg, 10) : void 0;
+    await dispatchFromCli(
+      "query",
+      "provenance",
+      "verify",
+      {
+        ...version ? { version } : {},
+        all,
+        ...limit && Number.isFinite(limit) ? { limit } : {}
+      },
+      { command: "provenance" }
+    );
+  }
+});
+var provenanceCommand = defineCommand({
+  meta: {
+    name: "provenance",
+    description: "Provenance-graph maintenance: backfill, verify, repair"
+  },
+  subCommands: {
+    backfill: backfillCommand,
+    verify: verifyCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  provenanceCommand
+};
+//# sourceMappingURL=provenance-C7AYD7WG.js.map

package/dist/cli/provider-QLJEDQBR.js

@@ -0,0 +1,212 @@
+(() => {
+  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 {
+  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/provider.ts
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List all registered CAAMP providers" },
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum providers to return"
+    },
+    offset: {
+      type: "string",
+      description: "Offset for pagination"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "provider.list",
+      {
+        limit: args.limit ? Number.parseInt(args.limit, 10) : void 0,
+        offset: args.offset ? Number.parseInt(args.offset, 10) : void 0
+      },
+      { command: "provider", operation: "tools.provider.list" }
+    );
+  }
+});
+var detectCommand = defineCommand({
+  meta: {
+    name: "detect",
+    description: "Detect which provider is active in the current environment"
+  },
+  async run() {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "provider.detect",
+      {},
+      { command: "provider", operation: "tools.provider.detect" }
+    );
+  }
+});
+var injectStatusCommand = defineCommand({
+  meta: {
+    name: "inject-status",
+    description: "Show provider injection status for project or global scope"
+  },
+  args: {
+    scope: {
+      type: "string",
+      description: "Scope: project or global (default: project)",
+      default: "project"
+    },
+    content: {
+      type: "string",
+      description: "Content string to check against"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "provider.inject.status",
+      {
+        scope: args.scope,
+        content: args.content
+      },
+      { command: "provider", operation: "tools.provider.inject.status" }
+    );
+  }
+});
+var supportsCommand = defineCommand({
+  meta: {
+    name: "supports",
+    description: "Check if a provider supports a capability (e.g., spawn.supportsSubagents)"
+  },
+  args: {
+    providerId: {
+      type: "positional",
+      description: "Provider ID to check",
+      required: true
+    },
+    capability: {
+      type: "positional",
+      description: "Capability to check (e.g., spawn.supportsSubagents)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "provider.supports",
+      { providerId: args.providerId, capability: args.capability },
+      { command: "provider", operation: "tools.provider.supports" }
+    );
+  }
+});
+var hooksCommand = defineCommand({
+  meta: {
+    name: "hooks",
+    description: "List providers that support a specific hook event (e.g., onSessionStart)"
+  },
+  args: {
+    event: {
+      type: "positional",
+      description: "Hook event name (e.g., onSessionStart)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "provider.hooks",
+      { event: args.event },
+      { command: "provider", operation: "tools.provider.hooks" }
+    );
+  }
+});
+var injectCommand = defineCommand({
+  meta: {
+    name: "inject",
+    description: "Inject provider references into AGENTS.md (project or global scope)"
+  },
+  args: {
+    scope: {
+      type: "string",
+      description: "Scope: project or global (default: project)",
+      default: "project"
+    },
+    references: {
+      type: "string",
+      description: "Provider reference IDs to inject (comma-separated)"
+    },
+    content: {
+      type: "string",
+      description: "Content string to inject directly"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "provider.inject",
+      {
+        scope: args.scope,
+        references: args.references,
+        content: args.content
+      },
+      { command: "provider", operation: "tools.provider.inject" }
+    );
+  }
+});
+var providerCommand = defineCommand({
+  meta: {
+    name: "provider",
+    description: "CAAMP provider registry: list, detect, supports, hooks, inject"
+  },
+  subCommands: {
+    list: listCommand,
+    detect: detectCommand,
+    "inject-status": injectStatusCommand,
+    supports: supportsCommand,
+    hooks: hooksCommand,
+    inject: injectCommand
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "provider.list",
+      {},
+      { command: "provider", operation: "tools.provider.list" }
+    );
+  }
+});
+export {
+  providerCommand
+};
+//# sourceMappingURL=provider-QLJEDQBR.js.map

package/dist/cli/reason-JF5BHBM5.js

@@ -0,0 +1,137 @@
+(() => {
+  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,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliError
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/reason.ts
+var impactCommand = defineCommand({
+  meta: {
+    name: "impact",
+    description: "Predict impact of a change. Use --change for free-text prediction, or pass a taskId for graph-based analysis."
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID for graph-based dependency impact analysis",
+      required: false
+    },
+    change: {
+      type: "string",
+      description: "Free-text description of the proposed change (T043)"
+    },
+    limit: {
+      type: "string",
+      description: "Maximum seed tasks to match when using --change (default: 5)",
+      default: "5"
+    },
+    depth: {
+      type: "string",
+      description: "Maximum traversal depth when using taskId (default: 10)",
+      default: "10"
+    }
+  },
+  async run({ args }) {
+    const change = args.change;
+    const taskId = args.taskId;
+    if (change) {
+      await dispatchFromCli(
+        "query",
+        "tasks",
+        "impact",
+        {
+          change,
+          matchLimit: Number.parseInt(args.limit, 10)
+        },
+        { command: "reason", operation: "tasks.impact" }
+      );
+    } else if (taskId) {
+      await dispatchFromCli(
+        "query",
+        "tasks",
+        "depends",
+        {
+          taskId,
+          action: "impact",
+          depth: Number.parseInt(args.depth, 10)
+        },
+        { command: "reason", operation: "tasks.depends" }
+      );
+    } else {
+      cliError(
+        "reason impact requires either --change <description> or a <taskId>",
+        1,
+        { name: "E_INVALID_INPUT" },
+        { operation: "tasks.impact" }
+      );
+      process.exit(1);
+    }
+  }
+});
+var timelineCommand = defineCommand({
+  meta: { name: "timeline", description: "Show history and audit trail for a task" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to fetch history for",
+      required: true
+    },
+    limit: {
+      type: "string",
+      description: "Maximum number of history entries"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "history",
+      {
+        taskId: args.taskId,
+        limit: args.limit ? Number.parseInt(args.limit, 10) : void 0
+      },
+      { command: "reason", operation: "tasks.history" }
+    );
+  }
+});
+var reasonCommand = defineCommand({
+  meta: { name: "reason", description: "Reasoning and intelligence operations (impact, timeline)" },
+  subCommands: {
+    impact: impactCommand,
+    timeline: timelineCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  reasonCommand
+};
+//# sourceMappingURL=reason-JF5BHBM5.js.map

package/dist/cli/reconcile-NMISHDGX.js

@@ -0,0 +1,127 @@
+(() => {
+  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,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchRaw,
+  handleRawError
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/reconcile.ts
+import { release } from "@cleocode/core";
+var scopeSubcommand = defineCommand({
+  meta: {
+    name: "scope",
+    description: "Find tasks with overlapping scope under a saga/epic and propose what to do"
+  },
+  args: {
+    rootId: {
+      type: "positional",
+      description: "Saga, epic or other container to sweep",
+      required: true
+    },
+    apply: {
+      type: "boolean",
+      description: "Write the proposed relates edges (read-only without it)"
+    },
+    threshold: {
+      type: "string",
+      description: "Report pairs at or above this similarity score, 0-1 (default 0.55)"
+    }
+  },
+  async run({ args }) {
+    const raw = args.threshold;
+    const threshold = raw === void 0 ? void 0 : Number(raw);
+    const response = await dispatchRaw("mutate", "tasks", "reconcile-scope", {
+      rootId: args.rootId,
+      apply: args.apply,
+      threshold
+    });
+    if (!response.success) {
+      handleRawError(response, { command: "reconcile scope", operation: "tasks.reconcile-scope" });
+    }
+    cliOutput(response.data, {
+      command: "reconcile scope",
+      operation: "tasks.reconcile-scope"
+    });
+  }
+});
+var releaseSubcommand = defineCommand({
+  meta: {
+    name: "release",
+    description: "Run post-release invariants for a release tag"
+  },
+  args: {
+    tag: {
+      type: "string",
+      description: "Release tag to reconcile (e.g. v2026.4.145)",
+      required: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview mutations without writing to tasks.db or audit log",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Emit raw JSON instead of human-readable summary",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const dryRun = args["dry-run"] === true;
+    const report = await release.runInvariants(args.tag, {
+      dryRun,
+      cwd: process.cwd()
+    });
+    cliOutput(report, { command: "reconcile", operation: "reconcile.release" });
+    if (report.errors > 0) {
+      process.exit(1);
+    }
+    if (report.unreconciled > 0) {
+      process.exit(2);
+    }
+  }
+});
+var reconcileCommand = defineCommand({
+  meta: {
+    name: "reconcile",
+    description: "Reconcile state against external sources (release tags, schema, etc.)"
+  },
+  subCommands: {
+    release: releaseSubcommand,
+    scope: scopeSubcommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  reconcileCommand
+};
+//# sourceMappingURL=reconcile-NMISHDGX.js.map

package/dist/cli/refresh-memory-EY5YNICV.js

@@ -0,0 +1,45 @@
+(() => {
+  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 {
+  humanLine
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/refresh-memory.ts
+import { getProjectRoot } from "@cleocode/core";
+var refreshMemoryCommand = defineCommand({
+  meta: {
+    name: "refresh-memory",
+    description: "Regenerate .cleo/memory-bridge.md from brain.db"
+  },
+  async run() {
+    const projectDir = getProjectRoot();
+    const { writeMemoryBridge } = await import("@cleocode/core/internal");
+    const result = await writeMemoryBridge(projectDir);
+    if (result.written) {
+      humanLine(`Memory bridge refreshed at ${result.path}`);
+    } else {
+      humanLine(`Memory bridge unchanged at ${result.path}`);
+    }
+  }
+});
+export {
+  refreshMemoryCommand
+};
+//# sourceMappingURL=refresh-memory-EY5YNICV.js.map