@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/context-XUUVFVTP.js

@@ -0,0 +1,141 @@
+(() => {
+  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,
+  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/context.ts
+import { ExitCode } from "@cleocode/contracts";
+var STATUS_EXIT_CODE = {
+  ok: ExitCode.SUCCESS,
+  warning: ExitCode.CONTEXT_WARNING,
+  caution: ExitCode.CONTEXT_CAUTION,
+  critical: ExitCode.CONTEXT_CRITICAL,
+  emergency: ExitCode.CONTEXT_EMERGENCY,
+  stale: ExitCode.CONTEXT_STALE
+};
+var statusCommand = defineCommand({
+  meta: { name: "status", description: "Show current context state (default)" },
+  args: {
+    session: {
+      type: "string",
+      description: "Check specific CLEO session"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "context",
+      {
+        action: "status",
+        session: args.session
+      },
+      { command: "context" }
+    );
+  }
+});
+var checkCommand = defineCommand({
+  meta: {
+    name: "check",
+    description: "Check context window state \u2014 exits non-zero when threshold exceeded (for scripting)"
+  },
+  args: {
+    session: {
+      type: "string",
+      description: "Check specific CLEO session"
+    }
+  },
+  async run({ args }) {
+    const response = await dispatchRaw("query", "admin", "context", {
+      action: "check",
+      session: args.session
+    });
+    handleRawError(response, { command: "context", operation: "admin.context" });
+    const data = response.data;
+    cliOutput(data, { command: "context", operation: "admin.context" });
+    const exitCode = STATUS_EXIT_CODE[data.status ?? ""] ?? ExitCode.SUCCESS;
+    if (exitCode !== ExitCode.SUCCESS) {
+      process.exit(exitCode);
+    }
+  }
+});
+var pullCommand = defineCommand({
+  meta: {
+    name: "pull",
+    description: "JIT context bundle: task details + top-3 relevant brain memories + last handoff note (~400 tokens)"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to pull context for",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "context.pull",
+      { taskId: args.taskId },
+      { command: "context" }
+    );
+  }
+});
+var contextCommand = defineCommand({
+  meta: {
+    name: "context",
+    description: "Monitor context window usage for agent safeguard system"
+  },
+  subCommands: {
+    status: statusCommand,
+    check: checkCommand,
+    pull: pullCommand
+  },
+  async run({ rawArgs }) {
+    const hasSubcommand = rawArgs.some((a) => ["status", "check", "pull"].includes(a));
+    if (!hasSubcommand) {
+      await dispatchFromCli(
+        "query",
+        "admin",
+        "context",
+        { action: "status" },
+        { command: "context" }
+      );
+    }
+  }
+});
+export {
+  contextCommand
+};
+//# sourceMappingURL=context-XUUVFVTP.js.map

package/dist/cli/contribution-37NQ4N5R.js

@@ -0,0 +1,111 @@
+(() => {
+  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/contribution.ts
+var validateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate contribution protocol compliance for task"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to validate",
+      required: true
+    },
+    strict: {
+      type: "boolean",
+      description: "Exit with error code on violations"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "protocol",
+      {
+        protocolType: "contribution",
+        mode: "task",
+        taskId: args.taskId,
+        strict: args.strict
+      },
+      { command: "contribution" }
+    );
+  }
+});
+var checkCommand = defineCommand({
+  meta: {
+    name: "check",
+    description: "Validate manifest entry directly"
+  },
+  args: {
+    manifestFile: {
+      type: "positional",
+      description: "Path to manifest file",
+      required: true
+    },
+    strict: {
+      type: "boolean",
+      description: "Exit with error code on violations"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "protocol",
+      {
+        protocolType: "contribution",
+        mode: "manifest",
+        manifestFile: args.manifestFile,
+        strict: args.strict
+      },
+      { command: "contribution" }
+    );
+  }
+});
+var contributionCommand = defineCommand({
+  meta: {
+    name: "contribution",
+    description: "Validate contribution protocol compliance (alias for `cleo check protocol contribution`)"
+  },
+  subCommands: {
+    validate: validateCommand,
+    check: checkCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  contributionCommand
+};
+//# sourceMappingURL=contribution-37NQ4N5R.js.map

package/dist/cli/curator-TFDXU2EX.js

@@ -0,0 +1,139 @@
+(() => {
+  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 {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/curator.ts
+import { join } from "node:path";
+import { getCleoHome } from "@cleocode/paths";
+async function loadCurator() {
+  return import("@cleocode/core/sentient/curator.js");
+}
+async function loadDaemon() {
+  return import("@cleocode/core/sentient/daemon.js");
+}
+var runCommand = defineCommand({
+  meta: {
+    name: "run",
+    description: "Execute one curator tick (use --dry-run for a preview)"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Compute transitions without applying them \u2014 no disk writes"
+    }
+  },
+  async run({ args }) {
+    try {
+      const { runCuratorTick } = await loadCurator();
+      const { readCuratorConfig } = await loadDaemon();
+      const configPath = join(getCleoHome(), "config.json");
+      const cfg = await readCuratorConfig(configPath);
+      const result = await runCuratorTick({
+        dryRun: args["dry-run"] === true,
+        staleAfterDays: cfg.staleAfterDays,
+        archiveAfterDays: cfg.archiveAfterDays
+      });
+      cliOutput(
+        {
+          success: true,
+          dryRun: result.summary.dryRun,
+          checked: result.summary.checked,
+          markedStale: result.summary.markedStale,
+          reactivated: result.summary.reactivated,
+          archived: result.summary.archived,
+          skipped: result.summary.skipped,
+          startedAt: result.summary.startedAt,
+          completedAt: result.summary.completedAt,
+          transitions: result.transitions
+        },
+        {
+          command: "curator run",
+          operation: "curator.run",
+          message: result.summary.dryRun ? `dry-run: ${result.transitions.length} transition(s) planned` : `applied ${result.summary.archived} archive(s), ${result.summary.markedStale} stale, ${result.summary.reactivated} reactivated`
+        }
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      cliError(message, "E_INTERNAL_ERROR", void 0, { operation: "curator.run" });
+      process.exit(1);
+    }
+  }
+});
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show curator configuration and last-run summary (pure read)"
+  },
+  async run() {
+    try {
+      const { readCuratorConfig, curatorCronExpression } = await loadDaemon();
+      const configPath = join(getCleoHome(), "config.json");
+      const cfg = await readCuratorConfig(configPath);
+      cliOutput(
+        {
+          enabled: cfg.enabled,
+          runEveryHours: cfg.runEveryHours,
+          staleAfterDays: cfg.staleAfterDays,
+          archiveAfterDays: cfg.archiveAfterDays,
+          cronExpression: curatorCronExpression(cfg.runEveryHours),
+          configPath
+        },
+        {
+          command: "curator status",
+          operation: "curator.status",
+          message: cfg.enabled ? `curator enabled (interval=${cfg.runEveryHours}h)` : "curator disabled \u2014 set daemon.curator.enabled=true in ~/.cleo/config.json to schedule ticks"
+        }
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      cliError(message, "E_INTERNAL_ERROR", void 0, { operation: "curator.status" });
+      process.exit(1);
+    }
+  }
+});
+var curatorCommand = defineCommand({
+  meta: {
+    name: "curator",
+    description: "Skill curator: lifecycle transitions for agent-created skills"
+  },
+  subCommands: {
+    run: runCommand,
+    status: statusCommand
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    await statusCommand.run?.({
+      args: {},
+      cmd: statusCommand,
+      rawArgs: [],
+      data: void 0
+    });
+  }
+});
+export {
+  curatorCommand
+};
+//# sourceMappingURL=curator-TFDXU2EX.js.map

package/dist/cli/current-C4SN5BWV.js

@@ -0,0 +1,42 @@
+(() => {
+  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/current.ts
+var currentCommand = defineCommand({
+  meta: {
+    name: "current",
+    description: "Show the current task being worked on. Returns: {currentTask: string|null, currentPhase: string|null}"
+  },
+  async run() {
+    await dispatchFromCli("query", "tasks", "current", {}, { command: "current" });
+  }
+});
+export {
+  currentCommand
+};
+//# sourceMappingURL=current-C4SN5BWV.js.map