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

package/dist/cli/focus-ANKAIRO5.js

@@ -0,0 +1,56 @@
+(() => {
+  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/focus.ts
+var focusCommand = defineCommand({
+  meta: {
+    name: "focus",
+    description: "Single-envelope orientation for a task, epic, or saga \u2014 replaces 8 separate calls with one"
+  },
+  args: {
+    id: {
+      type: "positional",
+      description: "Task, Epic, or Saga ID to orient on (e.g. T9973, T9831)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "focus",
+      "show",
+      { id: args["id"] },
+      { command: "focus" }
+    );
+  }
+});
+export {
+  focusCommand
+};
+//# sourceMappingURL=focus-ANKAIRO5.js.map

package/dist/cli/gateway-2GW2KTK3.js

@@ -0,0 +1,77 @@
+(() => {
+  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
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/gateway.ts
+import { resolve } from "node:path";
+import { generateOpenApi, getProjectRoot } from "@cleocode/core";
+var gatewayOpenapiSubCommand = defineCommand({
+  meta: {
+    name: "openapi",
+    description: "Emit the OpenAPI 3.1 spec projected from the OPERATIONS registry"
+  },
+  args: {
+    out: {
+      type: "string",
+      description: "Write the spec to this file (JSON). When omitted, prints the spec.",
+      alias: "o"
+    },
+    version: {
+      type: "string",
+      description: "API-surface version stamped into info.version (default '1.0.0')"
+    }
+  },
+  async run({ args }) {
+    const doc = generateOpenApi(
+      typeof args.version === "string" && args.version.length > 0 ? { version: args.version } : void 0
+    );
+    const json = `${JSON.stringify(doc, null, 2)}
+`;
+    const pathCount = Object.keys(doc.paths).length;
+    if (typeof args.out === "string" && args.out.length > 0) {
+      const { writeFileSync } = await import("node:fs");
+      const target = resolve(getProjectRoot(), args.out);
+      writeFileSync(target, json, "utf8");
+      cliOutput(
+        { out: target, pathCount, version: doc.info.version, openapi: doc.openapi },
+        { command: "gateway", operation: "gateway.openapi" }
+      );
+      return;
+    }
+    cliOutput(doc, { command: "gateway", operation: "gateway.openapi" });
+  }
+});
+var gatewayCommand = defineCommand({
+  meta: {
+    name: "gateway",
+    description: "REST gateway introspection (openapi spec projection)"
+  },
+  subCommands: {
+    openapi: gatewayOpenapiSubCommand
+  }
+});
+export {
+  gatewayCommand,
+  gatewayOpenapiSubCommand
+};
+//# sourceMappingURL=gateway-2GW2KTK3.js.map

package/dist/cli/gateway-auto-start-EDK7XI6E.js

@@ -0,0 +1,36 @@
+(() => {
+  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 {
+  GATEWAY_DEFAULT_HOST,
+  GATEWAY_DEFAULT_PORT,
+  GATEWAY_WAIT_TIMEOUT_MS,
+  pollPort,
+  probePort,
+  resolveCliEntryPath,
+  shouldAutoStartGateway,
+  spawnGatewayIfDown
+} from "./chunk-LVGIFMCV.js";
+export {
+  GATEWAY_DEFAULT_HOST,
+  GATEWAY_DEFAULT_PORT,
+  GATEWAY_WAIT_TIMEOUT_MS,
+  pollPort,
+  probePort,
+  resolveCliEntryPath,
+  shouldAutoStartGateway,
+  spawnGatewayIfDown
+};
+//# sourceMappingURL=gateway-auto-start-EDK7XI6E.js.map

package/dist/cli/gc-CTOQLUSA.js

@@ -0,0 +1,291 @@
+(() => {
+  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/gc.ts
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pruneOrphanTempDirs, pruneOrphanWorktrees } from "@cleocode/core/gc/cleanup.js";
+import { runGC } from "@cleocode/core/gc/runner.js";
+import { readGCState } from "@cleocode/core/gc/state.js";
+import { getCleoWorktreesRoot, resolveLegacyCleoDir } from "@cleocode/paths";
+
+// packages/utils/src/format-bytes.ts
+var UNITS = ["B", "KB", "MB", "GB", "TB"];
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  const exp = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), UNITS.length - 1);
+  const value = bytes / 1024 ** exp;
+  return `${value.toFixed(exp === 0 ? 0 : 1)} ${UNITS[exp]}`;
+}
+
+// packages/utils/src/redact.ts
+var ANTHROPIC_KEY_RE = /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g;
+var OPENAI_KEY_RE = /\bsk-(?:proj|svcacct|admin)-[A-Za-z0-9_-]{20,}\b|\bsk-[A-Za-z0-9]{32,}\b/g;
+var GENERIC_SK_RE = /\bsk-[A-Za-z0-9_-]{20,}\b/g;
+var SLACK_BOT_RE = /\bxoxb-[A-Za-z0-9_-]+\b/g;
+var GITHUB_TOKEN_RE = /\bgh[pousr]_[A-Za-z0-9]{36,}\b|\bgithub_pat_[A-Za-z0-9]{22}_[A-Za-z0-9]{59}\b/g;
+var JWT_RE = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
+var BEARER_RE = /\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi;
+var HEX_SECRET_RE = /\b(?:key|token|secret|password|passwd|pwd)=([0-9a-f]{32,})\b/gi;
+var JSON_PASSWORD_RE = /"(?:password|passwd|secret|token|apiKey|api_key|authToken|auth_token)"\s*:\s*"[^"]{4,}"/gi;
+var ENV_ASSIGNMENT_RE = /\b(ANTHROPIC_API_KEY|OPENAI_API_KEY|GITHUB_TOKEN|NPM_TOKEN|AWS_(?:SECRET_)?ACCESS_KEY(?:_ID)?|GCP_(?:SERVICE_ACCOUNT_)?KEY|AZURE_(?:CLIENT_SECRET|ACCESS_KEY)|DATABASE_URL|REDIS_URL|SECRET(?:_KEY)?|API_(?:KEY|TOKEN|SECRET)|AUTH_(?:TOKEN|SECRET)|PRIVATE_KEY|ACCESS_(?:TOKEN|KEY)|BEARER_TOKEN|JWT_SECRET|ENCRYPTION_KEY|SIGNING_KEY|WEBHOOK_SECRET)(\s*=\s*)['"]?[^\s'"]{8,}['"]?/gi;
+var SECRET_PATH_RE = /(?:(?:~|\/)[^\s'"]*\/)?(?:\.env(?:\.[A-Za-z0-9._-]+)?|id_rsa(?:_[A-Za-z0-9_-]*)?|[A-Za-z0-9_-]+\.(?:pem|key|p8|p12|pfx|jks|keystore))(?=[\s'"$]|$)/gi;
+var SIMPLE_PATTERNS = [
+  ANTHROPIC_KEY_RE,
+  OPENAI_KEY_RE,
+  GENERIC_SK_RE,
+  SLACK_BOT_RE,
+  GITHUB_TOKEN_RE,
+  JWT_RE,
+  BEARER_RE,
+  HEX_SECRET_RE,
+  JSON_PASSWORD_RE
+];
+var ALL_PATTERNS = [...SIMPLE_PATTERNS, ENV_ASSIGNMENT_RE, SECRET_PATH_RE];
+
+// packages/cleo/src/cli/commands/gc.ts
+var runCommand = defineCommand({
+  meta: {
+    name: "run",
+    description: "Run GC immediately (blocking). Prunes old transcripts based on disk pressure."
+  },
+  args: {
+    "cleo-dir": {
+      type: "string",
+      description: "Override .cleo/ directory path"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Report what would be pruned without deleting anything",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const cleoDir = resolveLegacyCleoDir(args["cleo-dir"]);
+    const dryRun = args["dry-run"];
+    try {
+      const gcResult = await runGC({ cleoDir, dryRun });
+      const dryLabel = dryRun ? " (dry run)" : "";
+      const humanMsg = `GC run complete${dryLabel} \u2014 Disk: ${gcResult.diskUsedPct.toFixed(1)}% (${gcResult.threshold.toUpperCase()}), Pruned: ${gcResult.pruned.length} paths, ${formatBytes(gcResult.bytesFreed)} freed` + (gcResult.escalationSet && gcResult.escalationReason ? ` \u2014 WARNING: ${gcResult.escalationReason}` : "");
+      cliOutput(gcResult, {
+        command: "gc",
+        operation: "gc.run",
+        message: humanMsg
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `GC run failed: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        {
+          operation: "gc.run"
+        }
+      );
+      process.exit(1);
+    }
+  }
+});
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show last GC run stats, disk usage, and escalation state"
+  },
+  args: {
+    "cleo-dir": {
+      type: "string",
+      description: "Override .cleo/ directory path"
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const cleoDir = resolveLegacyCleoDir(args["cleo-dir"]);
+    const statePath = join(cleoDir, "gc-state.json");
+    try {
+      const state = await readGCState(statePath);
+      const diskStr = state.lastDiskUsedPct !== null ? `${state.lastDiskUsedPct.toFixed(1)}%` : "unknown";
+      cliOutput(state, {
+        command: "gc",
+        operation: "gc.status",
+        message: `Last run: ${state.lastRunAt ?? "never"}, Disk: ${diskStr}, Escalation: ${state.escalationNeeded ? "YES \u2014 run cleo gc run" : "no"}`
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `Error reading GC status: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        {
+          operation: "gc.status"
+        }
+      );
+      process.exit(1);
+    }
+  }
+});
+var worktreesCommand = defineCommand({
+  meta: {
+    name: "worktrees",
+    description: "Prune orphaned agent worktree directories (task IDs no longer active)"
+  },
+  args: {
+    "worktrees-root": {
+      type: "string",
+      description: "Override the worktrees root directory"
+    },
+    "project-hash": {
+      type: "string",
+      description: "Scope pruning to a single project hash"
+    },
+    "preserve-tasks": {
+      type: "string",
+      description: "Comma-separated list of task IDs to preserve (default: none)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Report what would be pruned without deleting anything",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const worktreesRoot = args["worktrees-root"] ?? getCleoWorktreesRoot();
+    const projectHash = args["project-hash"];
+    const dryRun = args["dry-run"];
+    const preserveRaw = args["preserve-tasks"];
+    const activeTaskIds = new Set(
+      preserveRaw ? preserveRaw.split(",").map((s) => s.trim()).filter(Boolean) : []
+    );
+    try {
+      const result = pruneOrphanWorktrees({
+        worktreesRoot,
+        projectHash,
+        activeTaskIds,
+        dryRun
+      });
+      const dryLabel = dryRun ? " (dry run)" : "";
+      const humanMsg = `GC worktrees${dryLabel} \u2014 ${dryRun ? "Would remove" : "Removed"}: ${result.removed} director${result.removed === 1 ? "y" : "ies"}` + (result.quarantined > 0 ? `, ${result.quarantined} quarantined (dirty/unpushed)` : "") + (result.errors.length > 0 ? `, ${result.errors.length} error(s)` : "");
+      cliOutput(result, {
+        command: "gc",
+        operation: "gc.worktrees",
+        message: humanMsg
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `GC worktrees failed: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        { operation: "gc.worktrees" }
+      );
+      process.exit(1);
+    }
+  }
+});
+var tempCommand = defineCommand({
+  meta: {
+    name: "temp",
+    description: "Prune orphaned CLEO-generated temp directories from os.tmpdir()"
+  },
+  args: {
+    "max-age-hours": {
+      type: "string",
+      description: "Maximum age (hours) before a temp dir is eligible for pruning (default: 2)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Report what would be pruned without deleting anything",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const maxAgeHoursRaw = args["max-age-hours"];
+    const maxAgeHours = maxAgeHoursRaw !== void 0 ? Number(maxAgeHoursRaw) : 2;
+    const maxAgeMs = maxAgeHours * 60 * 60 * 1e3;
+    const dryRun = args["dry-run"];
+    try {
+      const result = pruneOrphanTempDirs({
+        maxAgeMs,
+        tempDir: tmpdir(),
+        dryRun
+      });
+      const dryLabel = dryRun ? " (dry run)" : "";
+      const humanMsg = `GC temp${dryLabel} \u2014 ${dryRun ? "Would remove" : "Removed"}: ${result.removed} director${result.removed === 1 ? "y" : "ies"}, skipped: ${result.skipped}` + (result.errors.length > 0 ? `, ${result.errors.length} error(s)` : "");
+      cliOutput(result, {
+        command: "gc",
+        operation: "gc.temp",
+        message: humanMsg
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `GC temp failed: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        { operation: "gc.temp" }
+      );
+      process.exit(1);
+    }
+  }
+});
+var gcCommand = defineCommand({
+  meta: {
+    name: "gc",
+    description: "Transcript garbage collection: manual trigger and status"
+  },
+  subCommands: {
+    run: runCommand,
+    status: statusCommand,
+    worktrees: worktreesCommand,
+    temp: tempCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  gcCommand
+};
+//# sourceMappingURL=gc-CTOQLUSA.js.map

package/dist/cli/go-YJPNHHYT.js

@@ -0,0 +1,206 @@
+(() => {
+  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 {
+  executePlaybook,
+  parsePlaybook
+} from "./chunk-NU6CQQVB.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/go.ts
+import { getProjectRoot, go } from "@cleocode/core";
+
+// packages/cleo/src/cli/commands/go-ivtr-runner.ts
+import { resolvePlaybook } from "@cleocode/core";
+function buildGoIvtrRunner() {
+  return runIvtrPlaybookTurn;
+}
+var runIvtrPlaybookTurn = async (taskId, options) => {
+  const { projectRoot } = options;
+  const resolved = resolvePlaybook("ivtr", { projectRoot });
+  const parsed = parsePlaybook(resolved.source);
+  const { seedIvtrForPlaybook, finalizeIvtrFromPlaybook, getDb, getNativeDb } = await import("@cleocode/core/internal");
+  await seedIvtrForPlaybook(taskId, { cwd: projectRoot });
+  await getDb(projectRoot);
+  const db = getNativeDb(projectRoot);
+  if (!db) {
+    throw new Error("cleo go IVTR runner: tasks.db singleton was not initialized by getDb()");
+  }
+  const dispatcher = await buildGoDispatcher(projectRoot);
+  const opts = {
+    db,
+    playbook: parsed.definition,
+    playbookHash: parsed.sourceHash,
+    initialContext: { taskId },
+    dispatcher,
+    projectRoot
+  };
+  if (options.epicId !== void 0) opts.epicId = options.epicId;
+  if (options.sessionId !== void 0) opts.sessionId = options.sessionId;
+  const result = await executePlaybook(opts);
+  const finalizeOptions = {
+    cwd: projectRoot,
+    runId: result.runId,
+    finalContext: result.finalContext
+  };
+  if (result.errorContext !== void 0) finalizeOptions.error = result.errorContext;
+  await finalizeIvtrFromPlaybook(taskId, result.terminalStatus, finalizeOptions);
+  const runResult = {
+    taskId,
+    runId: result.runId,
+    terminalStatus: result.terminalStatus
+  };
+  return runResult;
+};
+var buildGoDispatcher = async (projectRoot) => {
+  const { orchestrateSpawnExecute } = await import("@cleocode/runtime/gateway");
+  const {
+    createToolGuard,
+    runSkillNodeOrSpawn,
+    maybeCreatePiRunner,
+    resolveCantbookNodeProfile,
+    hasCantbookProfilePin
+  } = await import("@cleocode/core/internal");
+  const tools = createToolGuard({ allowedRoots: [projectRoot] });
+  const runner = await maybeCreatePiRunner({ system: "task-executor", projectRoot });
+  const resolveStageProfile = async (input) => {
+    if (!hasCantbookProfilePin({
+      profile: input.profile,
+      model: input.model,
+      provider: input.provider
+    })) {
+      return void 0;
+    }
+    const resolved = await resolveCantbookNodeProfile({
+      playbookName: input.playbookName ?? "cantbook",
+      nodeId: input.nodeId,
+      pin: { profile: input.profile, model: input.model, provider: input.provider },
+      projectRoot
+    });
+    return {
+      [`${input.nodeId}_llm`]: {
+        provider: resolved.provider,
+        model: resolved.model,
+        source: resolved.source,
+        profile: input.profile ?? null
+      }
+    };
+  };
+  const spawn = async (input) => {
+    const result = await orchestrateSpawnExecute(
+      input.taskId,
+      /* adapterId */
+      void 0,
+      /* protocolType */
+      void 0,
+      projectRoot,
+      /* tier */
+      void 0
+    );
+    if (result.success) {
+      return {
+        status: "success",
+        output: {
+          [`${input.nodeId}_spawn`]: true,
+          nodeId: input.nodeId,
+          agentId: input.agentId,
+          dispatchData: result.data ?? null
+        }
+      };
+    }
+    return {
+      status: "failure",
+      output: {},
+      error: result.error?.message ?? `spawn failed for ${input.agentId}`
+    };
+  };
+  return {
+    async dispatch(input) {
+      try {
+        const llmHint = await resolveStageProfile(input);
+        const result = await runSkillNodeOrSpawn(
+          { nodeId: input.nodeId, agentId: input.agentId, context: input.context },
+          {
+            tools,
+            cwd: projectRoot,
+            subprocessSpawn: () => spawn(input),
+            ...runner !== void 0 ? { runner } : {}
+          }
+        );
+        if (llmHint !== void 0 && result.status === "success") {
+          return { ...result, output: { ...result.output, ...llmHint } };
+        }
+        return result;
+      } catch (err) {
+        return {
+          status: "failure",
+          output: {},
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+  };
+};
+
+// packages/cleo/src/cli/commands/go.ts
+var goCommand = defineCommand({
+  meta: {
+    name: "go",
+    description: "SG-AUTOPILOT: run one turn of briefing\u2192sagaNext\u2192ready\u2192stage-branch\u2192ivtr loop"
+  },
+  args: {
+    saga: {
+      type: "string",
+      description: "Optional saga task ID to scope the autopilot run (default: auto-select)",
+      required: false
+    },
+    headless: {
+      type: "boolean",
+      description: "Suppress interactive annotations; suitable for daemon / unattended use",
+      required: false
+    }
+  },
+  async run({ args }) {
+    const projectRoot = getProjectRoot();
+    const { getCurrentSessionId, resolveBoundSessionId } = await import("@cleocode/core/internal");
+    let sessionId = getCurrentSessionId(projectRoot) ?? void 0;
+    if (sessionId === void 0) {
+      try {
+        sessionId = await resolveBoundSessionId(projectRoot) ?? void 0;
+      } catch {
+      }
+    }
+    const params = {
+      headless: args.headless === true,
+      projectRoot,
+      ivtrRunner: buildGoIvtrRunner()
+    };
+    if (typeof args.saga === "string" && args.saga.length > 0) params.sagaId = args.saga;
+    if (sessionId !== void 0) params.sessionId = sessionId;
+    const result = await go.cleoGo(params);
+    cliOutput(result.success ? result.data : result, { command: "go", operation: "go.run" });
+  }
+});
+export {
+  goCommand
+};
+//# sourceMappingURL=go-YJPNHHYT.js.map