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

package/dist/cli/agent-outputs-HVJJIPS4.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-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/agent-outputs.ts
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+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-HVJJIPS4.js.map

package/dist/cli/analyze-YQ22QVGW.js

@@ -0,0 +1,49 @@
+(() => {
+  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/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-YQ22QVGW.js.map

package/dist/cli/archive-W5XX6AH7.js

@@ -0,0 +1,65 @@
+(() => {
+  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/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-W5XX6AH7.js.map

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

@@ -0,0 +1,101 @@
+(() => {
+  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/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-HP2KPAJU.js.map

package/dist/cli/attention-7JBDCRZX.js

@@ -0,0 +1,124 @@
+(() => {
+  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,
+  paramBool,
+  paramNumber,
+  paramString,
+  paramStringArray,
+  paramStringRequired,
+  unsupportedOp
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/attention.ts
+import { getLogger, getProjectRoot } from "@cleocode/core";
+import { addAttention, listAttention } from "@cleocode/core/internal";
+var log = getLogger("domain:attention");
+var QUERY_OPS = /* @__PURE__ */ new Set(["list", "show"]);
+var MUTATE_OPS = /* @__PURE__ */ new Set(["add"]);
+var SCOPE_KINDS = /* @__PURE__ */ new Set([
+  "agent",
+  "task",
+  "epic",
+  "saga",
+  "session",
+  "global"
+]);
+function parseScope(params) {
+  const raw = paramString(params, "scope");
+  return raw !== void 0 && SCOPE_KINDS.has(raw) ? raw : void 0;
+}
+var AttentionHandler = class {
+  /**
+   * Read-only attention queries (`list`, `show`).
+   *
+   * @param operation - `'list'` or `'show'` (synonyms — both emit open items).
+   * @param params - Optional `scope` / `tags` / `includeAll` / `limit` filters.
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    if (!QUERY_OPS.has(operation)) {
+      return unsupportedOp("query", "attention", operation, startTime);
+    }
+    try {
+      const result = await listAttention(getProjectRoot(), {
+        scope: parseScope(params),
+        tags: paramStringArray(params, "tags"),
+        includeAll: paramBool(params, "includeAll") === true,
+        limit: paramNumber(params, "limit")
+      });
+      const data = {
+        items: result.items,
+        total: result.items.length,
+        resolvedScopes: result.resolvedScopes
+      };
+      return {
+        meta: dispatchMeta("query", "attention", operation, startTime),
+        success: true,
+        data
+      };
+    } catch (error) {
+      log.error({ gateway: "query", domain: "attention", operation, err: error }, String(error));
+      return handleErrorResult("query", "attention", operation, error, startTime);
+    }
+  }
+  /**
+   * Attention mutations (`add`).
+   *
+   * @param operation - `'add'`.
+   * @param params - `content` (required) plus optional `tags` / `scope` / `ttlSeconds`.
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    if (!MUTATE_OPS.has(operation)) {
+      return unsupportedOp("mutate", "attention", operation, startTime);
+    }
+    try {
+      const content = paramStringRequired(params, "content").trim();
+      if (!content) {
+        return {
+          meta: dispatchMeta("mutate", "attention", operation, startTime),
+          success: false,
+          error: { code: "E_INVALID_INPUT", message: "content is required" }
+        };
+      }
+      const ttlSeconds = paramNumber(params, "ttlSeconds");
+      const item = await addAttention(getProjectRoot(), {
+        content,
+        tags: paramStringArray(params, "tags"),
+        scope: parseScope(params),
+        ...ttlSeconds !== void 0 ? { ttlSeconds } : {}
+      });
+      return {
+        meta: dispatchMeta("mutate", "attention", operation, startTime),
+        success: true,
+        data: { item }
+      };
+    } catch (error) {
+      log.error({ gateway: "mutate", domain: "attention", operation, err: error }, String(error));
+      return handleErrorResult("mutate", "attention", operation, error, startTime);
+    }
+  }
+  /** Declared operations for introspection. */
+  getSupportedOperations() {
+    return { query: ["list", "show"], mutate: ["add"] };
+  }
+};
+export {
+  AttentionHandler
+};
+//# sourceMappingURL=attention-7JBDCRZX.js.map

package/dist/cli/attention-ZXZANHKC.js

@@ -0,0 +1,168 @@
+(() => {
+  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 {
+  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 {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/attention.ts
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+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-ZXZANHKC.js.map