@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/otel-U7IIRBCT.js

@@ -0,0 +1,188 @@
+(() => {
+  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/otel.ts
+import {
+  CleoError,
+  clearOtelData,
+  formatError,
+  getOtelSessions,
+  getOtelSpawns,
+  getOtelStatus,
+  getOtelSummary,
+  getRealTokenUsage
+} from "@cleocode/core/internal";
+var statusCommand = defineCommand({
+  meta: { name: "status", description: "Show token tracking status and recent activity" },
+  async run() {
+    try {
+      const result = await getOtelStatus();
+      cliOutput(result, { command: "otel" });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(formatError(err), err.code, { name: "E_INTERNAL" });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var summaryCommand = defineCommand({
+  meta: { name: "summary", description: "Show combined token usage summary" },
+  async run() {
+    try {
+      const result = await getOtelSummary();
+      cliOutput(result, { command: "otel" });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(formatError(err), err.code, { name: "E_INTERNAL" });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var sessionsCommand = defineCommand({
+  meta: { name: "sessions", description: "Show session-level token data" },
+  args: {
+    session: {
+      type: "string",
+      description: "Filter by session ID"
+    },
+    task: {
+      type: "string",
+      description: "Filter by task ID"
+    }
+  },
+  async run({ args }) {
+    try {
+      const result = await getOtelSessions({
+        session: args.session,
+        task: args.task
+      });
+      cliOutput(result, { command: "otel" });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(formatError(err), err.code, { name: "E_INTERNAL" });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var spawnsCommand = defineCommand({
+  meta: { name: "spawns", description: "Show spawn-level token data" },
+  args: {
+    task: {
+      type: "string",
+      description: "Filter by task ID"
+    },
+    epic: {
+      type: "string",
+      description: "Filter by epic ID"
+    }
+  },
+  async run({ args }) {
+    try {
+      const result = await getOtelSpawns({
+        task: args.task,
+        epic: args.epic
+      });
+      cliOutput(result, { command: "otel" });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(formatError(err), err.code, { name: "E_INTERNAL" });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var realCommand = defineCommand({
+  meta: { name: "real", description: "Show REAL token usage from Claude Code API" },
+  args: {
+    session: {
+      type: "string",
+      description: "Filter by session ID"
+    },
+    since: {
+      type: "string",
+      description: "Filter events since timestamp"
+    }
+  },
+  async run({ args }) {
+    try {
+      const result = await getRealTokenUsage({
+        session: args.session,
+        since: args.since
+      });
+      cliOutput(result, { command: "otel" });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(formatError(err), err.code, { name: "E_INTERNAL" });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var clearCommand = defineCommand({
+  meta: { name: "clear", description: "Clear token tracking data (with backup)" },
+  async run() {
+    try {
+      const result = await clearOtelData();
+      cliOutput(result, { command: "otel" });
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(formatError(err), err.code, { name: "E_INTERNAL" });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var otelCommand = defineCommand({
+  meta: {
+    name: "otel",
+    description: "Lightweight token metrics from .cleo/metrics/TOKEN_USAGE.jsonl (session-level, spawn-level events)"
+  },
+  subCommands: {
+    status: statusCommand,
+    summary: summaryCommand,
+    sessions: sessionsCommand,
+    spawns: spawnsCommand,
+    real: realCommand,
+    clear: clearCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  otelCommand
+};
+//# sourceMappingURL=otel-U7IIRBCT.js.map

package/dist/cli/phase-NYZFHUE5.js

@@ -0,0 +1,220 @@
+(() => {
+  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/phase.ts
+var showCommand = defineCommand({
+  meta: { name: "show", description: "Show phase details (current phase if no slug given)" },
+  args: {
+    slug: {
+      type: "positional",
+      description: "Phase slug (defaults to current phase)",
+      required: false
+    }
+  },
+  async run({ args }) {
+    const params = args.slug ? { phaseId: args.slug } : {};
+    await dispatchFromCli("query", "pipeline", "phase.show", params, { command: "phase" });
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List all phases with status" },
+  async run() {
+    await dispatchFromCli("query", "pipeline", "phase.list", {}, { command: "phase" });
+  }
+});
+var setCommand = defineCommand({
+  meta: { name: "set", description: "Set current phase" },
+  args: {
+    slug: {
+      type: "positional",
+      description: "Phase slug to set as current",
+      required: true
+    },
+    rollback: {
+      type: "boolean",
+      description: "Allow backward phase movement"
+    },
+    force: {
+      type: "boolean",
+      description: "Skip confirmation prompt"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview changes without modifying files"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "phase.set",
+      {
+        phaseId: args.slug,
+        rollback: args.rollback,
+        force: args.force,
+        dryRun: args["dry-run"]
+      },
+      { command: "phase" }
+    );
+  }
+});
+var startCommand = defineCommand({
+  meta: { name: "start", description: "Start a phase (pending -> active)" },
+  args: {
+    slug: {
+      type: "positional",
+      description: "Phase slug to start",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "phase.set",
+      { phaseId: args.slug, action: "start" },
+      { command: "phase" }
+    );
+  }
+});
+var completeCommand = defineCommand({
+  meta: { name: "complete", description: "Complete a phase (active -> completed)" },
+  args: {
+    slug: {
+      type: "positional",
+      description: "Phase slug to complete",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "phase.set",
+      { phaseId: args.slug, action: "complete" },
+      { command: "phase" }
+    );
+  }
+});
+var advanceCommand = defineCommand({
+  meta: { name: "advance", description: "Complete current phase and start next" },
+  args: {
+    force: {
+      type: "boolean",
+      description: "Skip validation and interactive prompt",
+      alias: "f"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "phase.advance",
+      { force: args.force },
+      { command: "phase" }
+    );
+  }
+});
+var renameCommand = defineCommand({
+  meta: { name: "rename", description: "Rename a phase and update all task references" },
+  args: {
+    oldName: {
+      type: "positional",
+      description: "Current phase name",
+      required: true
+    },
+    newName: {
+      type: "positional",
+      description: "New phase name",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "phase.rename",
+      { oldName: args.oldName, newName: args.newName },
+      { command: "phase" }
+    );
+  }
+});
+var deleteCommand = defineCommand({
+  meta: { name: "delete", description: "Delete a phase with task reassignment protection" },
+  args: {
+    slug: {
+      type: "positional",
+      description: "Phase slug to delete",
+      required: true
+    },
+    "reassign-to": {
+      type: "string",
+      description: "Reassign tasks to another phase"
+    },
+    force: {
+      type: "boolean",
+      description: "Required safety flag"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "phase.delete",
+      {
+        phaseId: args.slug,
+        reassignTo: args["reassign-to"],
+        force: args.force
+      },
+      { command: "phase" }
+    );
+  }
+});
+var phaseCommand = defineCommand({
+  meta: { name: "phase", description: "Project-level phase lifecycle management" },
+  subCommands: {
+    show: showCommand,
+    list: listCommand,
+    set: setCommand,
+    start: startCommand,
+    complete: completeCommand,
+    advance: advanceCommand,
+    rename: renameCommand,
+    delete: deleteCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  phaseCommand
+};
+//# sourceMappingURL=phase-NYZFHUE5.js.map

package/dist/cli/pivot-FF2CVUZL.js

@@ -0,0 +1,87 @@
+(() => {
+  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 {
+  negatedFlag
+} from "./chunk-47JYZAMS.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/pivot.ts
+var pivotCommand = defineCommand({
+  meta: {
+    name: "pivot",
+    description: "Record an audited context switch from one task to another (replaces silent reframes)"
+  },
+  args: {
+    fromTaskId: {
+      type: "positional",
+      description: "Currently-active task ID being paused",
+      required: true
+    },
+    toTaskId: {
+      type: "positional",
+      description: "Task ID becoming active in the current session",
+      required: true
+    },
+    reason: {
+      type: "string",
+      description: "Free-form rationale for the pivot (REQUIRED \u2014 no silent pivots)",
+      required: true
+    },
+    "no-blocks-from": {
+      type: "boolean",
+      description: "Skip adding toTaskId as a dependency on fromTaskId (advisory pivot \u2014 default is to block)"
+    },
+    "take-over": {
+      type: "boolean",
+      description: "Take over another session's EXPIRED claim on toTaskId (audited)"
+    },
+    "force-claim": {
+      type: "boolean",
+      description: "Take over another session's LIVE claim on toTaskId (audited)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "pivot",
+      {
+        fromTaskId: args.fromTaskId,
+        toTaskId: args.toTaskId,
+        reason: args.reason,
+        blocksFrom: !negatedFlag(args, "blocks-from"),
+        ...args["take-over"] === true ? { takeOver: true } : {},
+        ...args["force-claim"] === true ? { forceClaim: true } : {}
+      },
+      { command: "pivot" }
+    );
+  }
+});
+export {
+  pivotCommand
+};
+//# sourceMappingURL=pivot-FF2CVUZL.js.map

package/dist/cli/plan-3SL2NTRV.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/plan.ts
+var planCommand = defineCommand({
+  meta: {
+    name: "plan",
+    description: "Task prioritization view: in-progress epics, ready tasks, blocked tasks, open bugs with scoring. Use when deciding what to work on next."
+  },
+  async run() {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "plan",
+      {},
+      { command: "plan", operation: "tasks.plan" }
+    );
+  }
+});
+export {
+  planCommand
+};
+//# sourceMappingURL=plan-3SL2NTRV.js.map