@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/agent-outputs-BJIYLVTU.js

@@ -0,0 +1,84 @@
+(() => {
+  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 {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/agent-outputs.ts
+import { ExitCode } from "@cleocode/contracts";
+import { searchDocs } from "@cleocode/core/internal";
+var findCommand = defineCommand({
+  meta: {
+    name: "find",
+    description: "Search agent output documents by query (routed via DocsAccessor.searchDocs)"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Free-text search query to match against agent output documents",
+      required: true
+    },
+    limit: {
+      type: "string",
+      description: "Maximum number of results to return (default: 10)",
+      default: "10"
+    },
+    json: {
+      type: "boolean",
+      description: "Emit raw JSON envelope instead of human-readable table",
+      default: false
+    }
+  },
+  async run({ args }) {
+    try {
+      const limit = parseInt(String(args.limit), 10);
+      const query = String(args.query);
+      const result = await searchDocs(query, { limit: Number.isNaN(limit) ? 10 : limit });
+      cliOutput(result, {
+        command: "agent-outputs find",
+        operation: "docs.agent-outputs.find"
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(`agent-outputs find failed: ${message}`, ExitCode.GENERAL_ERROR);
+    }
+  }
+});
+var agentOutputsCommand = defineCommand({
+  meta: {
+    name: "agent-outputs",
+    description: "Agent output document management \u2014 find/search via DocsAccessor (find subcommand)"
+  },
+  subCommands: {
+    find: findCommand
+  },
+  run({ rawArgs }) {
+    const sub = rawArgs?.find((a) => !a.startsWith("-"));
+    if (!sub) {
+      showUsage(agentOutputsCommand);
+    }
+  }
+});
+export {
+  agentOutputsCommand
+};
+//# sourceMappingURL=agent-outputs-BJIYLVTU.js.map

package/dist/cli/analyze-PGQZWGOC.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 {
+  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/analyze.ts
+var analyzeCommand = defineCommand({
+  meta: {
+    name: "analyze",
+    description: "Task triage with leverage scoring and bottleneck detection"
+  },
+  args: {
+    "auto-start": {
+      type: "boolean",
+      description: "Automatically start working on recommended task"
+    }
+  },
+  async run() {
+    await dispatchFromCli("query", "tasks", "analyze", {}, { command: "analyze" });
+  }
+});
+export {
+  analyzeCommand
+};
+//# sourceMappingURL=analyze-PGQZWGOC.js.map

package/dist/cli/archive-5LZPF7C3.js

@@ -0,0 +1,64 @@
+(() => {
+  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/archive.ts
+var archiveCommand = defineCommand({
+  meta: { name: "archive", description: "Archive completed tasks" },
+  args: {
+    before: {
+      type: "string",
+      description: "Archive tasks completed before date (ISO format)"
+    },
+    tasks: {
+      type: "string",
+      description: "Specific task IDs to archive (comma-separated)"
+    },
+    cancelled: {
+      type: "boolean",
+      description: "Include cancelled tasks (use --no-cancelled to exclude)",
+      default: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would be archived without making changes",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const params = {};
+    if (args.before !== void 0) params["before"] = args.before;
+    if (args.tasks) params["taskIds"] = args.tasks.split(",").map((s) => s.trim());
+    if (args.cancelled === false) params["includeCancelled"] = false;
+    if (args["dry-run"]) params["dryRun"] = args["dry-run"];
+    await dispatchFromCli("mutate", "tasks", "archive", params, { command: "archive" });
+  }
+});
+export {
+  archiveCommand
+};
+//# sourceMappingURL=archive-5LZPF7C3.js.map

package/dist/cli/archive-stats-U6CYC6JM.js

@@ -0,0 +1,100 @@
+(() => {
+  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/archive-stats.ts
+import { analyzeArchive } from "@cleocode/core/internal";
+var archiveStatsCommand = defineCommand({
+  meta: {
+    name: "archive-stats",
+    description: "Generate analytics and insights from archived tasks"
+  },
+  args: {
+    summary: {
+      type: "boolean",
+      description: "Overview statistics (default)",
+      default: false
+    },
+    "by-phase": {
+      type: "boolean",
+      description: "Breakdown by project phase",
+      default: false
+    },
+    "by-label": {
+      type: "boolean",
+      description: "Breakdown by label",
+      default: false
+    },
+    "by-priority": {
+      type: "boolean",
+      description: "Breakdown by priority",
+      default: false
+    },
+    "cycle-times": {
+      type: "boolean",
+      description: "Analyze task completion cycle times",
+      default: false
+    },
+    trends: {
+      type: "boolean",
+      description: "Show archiving trends over time",
+      default: false
+    },
+    since: {
+      type: "string",
+      description: "Only include tasks archived since DATE (YYYY-MM-DD)"
+    },
+    until: {
+      type: "string",
+      description: "Only include tasks archived until DATE (YYYY-MM-DD)"
+    }
+  },
+  async run({ args }) {
+    let report = "summary";
+    if (args["by-phase"]) report = "by-phase";
+    else if (args["by-label"]) report = "by-label";
+    else if (args["by-priority"]) report = "by-priority";
+    else if (args["cycle-times"]) report = "cycle-times";
+    else if (args.trends) report = "trends";
+    await dispatchFromCli(
+      "query",
+      "check",
+      "archive.stats",
+      {
+        report,
+        since: args.since,
+        until: args.until
+      },
+      { command: "archive-stats" }
+    );
+  }
+});
+export {
+  archiveStatsCommand,
+  analyzeArchive as getArchiveStats
+};
+//# sourceMappingURL=archive-stats-U6CYC6JM.js.map

package/dist/cli/attention-SOURWCNI.js

@@ -0,0 +1,167 @@
+(() => {
+  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,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli,
+  dispatchRaw,
+  handleRawError
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/attention.ts
+import { ExitCode } from "@cleocode/contracts";
+import { CleoError } from "@cleocode/core";
+function parseTags(rawTag) {
+  if (!rawTag) return void 0;
+  const tags = rawTag.split(",").map((t) => t.trim()).filter(Boolean);
+  return tags.length > 0 ? [...new Set(tags)] : void 0;
+}
+var addCommand = defineCommand({
+  meta: { name: "add", description: "Record a scope-keyed working-memory jot" },
+  args: {
+    content: {
+      type: "positional",
+      description: "The jot content",
+      required: true
+    },
+    tag: {
+      type: "string",
+      description: 'Comma-separated tags (e.g. "bug,wal")'
+    },
+    scope: {
+      type: "string",
+      description: "Escalate scope: agent|task|epic|saga|session|global (default: narrowest)"
+    },
+    ttl: {
+      type: "string",
+      description: "Time-to-live in seconds (optional)"
+    }
+  },
+  async run({ args }) {
+    try {
+      const ttlRaw = args.ttl;
+      const ttlSeconds = ttlRaw ? Number.parseInt(ttlRaw, 10) : void 0;
+      await dispatchFromCli(
+        "mutate",
+        "attention",
+        "add",
+        {
+          content: args.content,
+          tags: parseTags(args.tag),
+          scope: args.scope,
+          ...ttlSeconds !== void 0 && !Number.isNaN(ttlSeconds) ? { ttlSeconds } : {}
+        },
+        { command: "attention", operation: "attention.add" }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var showCommand = defineCommand({
+  meta: { name: "show", description: "Show open working-memory jots for the resolved scope" },
+  args: {
+    scope: {
+      type: "string",
+      description: "Restrict to one scope: agent|task|epic|saga|session|global"
+    },
+    tag: {
+      type: "string",
+      description: "Filter by tags (contains-ALL, comma-separated)"
+    },
+    all: {
+      type: "boolean",
+      description: "Include non-open (consolidated/discarded) items too"
+    },
+    limit: {
+      type: "string",
+      description: "Max results",
+      default: "50"
+    }
+  },
+  async run({ args }) {
+    try {
+      const response = await dispatchRaw("query", "attention", "show", {
+        scope: args.scope,
+        tags: parseTags(args.tag),
+        includeAll: args.all === true,
+        limit: Number.parseInt(args.limit, 10)
+      });
+      if (!response.success) {
+        handleRawError(response, { command: "attention show", operation: "attention.show" });
+        return;
+      }
+      const data = response.data;
+      if (!data?.items || data.items.length === 0) {
+        cliOutput(
+          { items: [], total: 0 },
+          {
+            command: "attention show",
+            message: "No open attention items",
+            operation: "attention.show"
+          }
+        );
+        process.exit(ExitCode.NO_DATA);
+        return;
+      }
+      cliOutput(data, { command: "attention show", operation: "attention.show" });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(err.message, err.code, { name: "CleoError", fix: err.fix });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var attentionCommand = defineCommand({
+  meta: {
+    name: "attention",
+    description: "Tier-2 scope-keyed working memory \u2014 quick decaying jots (alias: jot)"
+  },
+  subCommands: {
+    add: addCommand,
+    jot: addCommand,
+    show: showCommand,
+    list: showCommand,
+    ls: showCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  attentionCommand
+};
+//# sourceMappingURL=attention-SOURWCNI.js.map

package/dist/cli/audit-FO2Y4LH2.js

@@ -0,0 +1,122 @@
+(() => {
+  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 {
+  isSubCommandDispatch
+} from "./chunk-YY66LFZF.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/audit.ts
+import { reconstructLineage } from "@cleocode/core/audit/reconstruct";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+import { renderAuditReconstruct } from "@cleocode/core/render/orchestration/audit-reconstruct";
+var reconstructCommand = defineCommand({
+  meta: {
+    name: "reconstruct",
+    description: "Reconstruct git-backed lineage (commits + release tags) for a task"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to reconstruct (e.g. T991)",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Emit raw JSON output instead of formatted summary",
+      default: false
+    },
+    "budget-ms": {
+      type: "string",
+      description: "Shared bounded assessment deadline in milliseconds",
+      default: "2000"
+    },
+    "max-output-bytes": {
+      type: "string",
+      description: "Combined Git capture byte ceiling",
+      default: "8388608"
+    },
+    "repo-root": {
+      type: "string",
+      description: "Path to the git repository root (defaults to current project root)"
+    }
+  },
+  async run({ args }) {
+    const taskId = args.taskId.toUpperCase();
+    const budgetMs = Number(args["budget-ms"]);
+    const maxOutputBytes = Number(args["max-output-bytes"]);
+    const deadlineAt = Date.now() + budgetMs;
+    if (!/^T\d+$/.test(taskId) || !/^\d+$/.test(args["budget-ms"]) || !/^\d+$/.test(args["max-output-bytes"]) || !Number.isSafeInteger(budgetMs) || !Number.isSafeInteger(maxOutputBytes) || !Number.isSafeInteger(deadlineAt)) {
+      cliError(
+        "Task ID must be T followed by digits; budget-ms and max-output-bytes must be nonnegative safe integers.",
+        1,
+        { name: "E_VALIDATION" },
+        { operation: "audit.reconstruct" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const repoRoot = args["repo-root"] ?? getProjectRoot(process.cwd()) ?? process.cwd();
+    const result = await reconstructLineage(taskId, repoRoot, {
+      execution: { deadlineAt },
+      maxOutputBytes
+    });
+    if (result.assessment?.coverage !== "current") {
+      process.exitCode = 1;
+      cliError(
+        renderAuditReconstruct({ ...result }, false),
+        1,
+        {
+          name: "E_AUDIT_INCOMPLETE",
+          details: result,
+          fix: "Inspect assessment diagnostics; request an explicit larger budget or restore missing evidence before retrying."
+        },
+        { operation: "audit.reconstruct" }
+      );
+      return;
+    }
+    cliOutput(result, {
+      command: "audit-reconstruct",
+      operation: "audit.reconstruct",
+      message: `Lineage for ${result.taskId}`
+    });
+  }
+});
+var auditCommand = defineCommand({
+  meta: {
+    name: "audit",
+    description: "Git-backed audit tooling (lineage reconstruction, integrity checks). Independent re-verification of task completion claims is handled by `cleo verify <taskId> --explain` which re-validates ADR-051 evidence atoms."
+  },
+  subCommands: {
+    reconstruct: reconstructCommand
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  auditCommand
+};
+//# sourceMappingURL=audit-FO2Y4LH2.js.map