@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/gc-5R2TUY5T.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-3ZO3M37V.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-5R2TUY5T.js.map

package/dist/cli/go-PRQFK5YG.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 {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import {
+  executePlaybook,
+  parsePlaybook
+} from "./chunk-QFFQSKRC.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-PRQFK5YG.js.map

package/dist/cli/goal-7CZRMLHC.js

@@ -0,0 +1,212 @@
+(() => {
+  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 {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/goal.ts
+import { ExitCode, isValidGoalTargetTaskId } from "@cleocode/contracts";
+import { getProjectRoot, goal } from "@cleocode/core";
+var DEFAULT_TURN_BUDGET = 10;
+function resolveGoalKind(task) {
+  if (typeof task === "string" && task.length > 0) {
+    if (!isValidGoalTargetTaskId(task)) {
+      return { error: `--task must be a valid task id (T + 1-7 digits) \u2014 got '${task}'` };
+    }
+    return { kind: { kind: "task-completion", targetTaskId: task } };
+  }
+  return { kind: { kind: "fuzzy" } };
+}
+function resolveTurnBudget(turns) {
+  const n = typeof turns === "string" ? Number.parseInt(turns, 10) : Number(turns);
+  return Number.isInteger(n) && n > 0 ? n : DEFAULT_TURN_BUDGET;
+}
+var setCommand = defineCommand({
+  meta: {
+    name: "set",
+    description: "Set the current agent's goal (evidence-judged when --task given)."
+  },
+  args: {
+    intent: { type: "positional", description: "What the agent is trying to achieve" },
+    task: { type: "string", description: "Target task id (T###) \u2014 makes it evidence-judged" },
+    turns: { type: "string", description: "Turn budget (default 10)" }
+  },
+  async run({ args }) {
+    const intent = String(args.intent ?? "").trim();
+    if (intent.length === 0) {
+      cliError("goal set requires an <intent>", ExitCode.VALIDATION_ERROR, {
+        name: "E_VALIDATION"
+      });
+      return;
+    }
+    const kindResult = resolveGoalKind(args.task);
+    if ("error" in kindResult) {
+      cliError(kindResult.error, ExitCode.VALIDATION_ERROR, { name: "E_VALIDATION" });
+      return;
+    }
+    const record = await goal.createGoal(
+      { goalKind: kindResult.kind, intent, turnBudget: resolveTurnBudget(args.turns) },
+      getProjectRoot()
+    );
+    cliOutput(record, { command: "goal set", operation: "goal.set" });
+  }
+});
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show the current agent's active goal (per-agent scoped)."
+  },
+  async run() {
+    const record = await goal.getActiveGoal(getProjectRoot());
+    cliOutput(record ?? { active: null }, { command: "goal status", operation: "goal.status" });
+  }
+});
+var subgoalCommand = defineCommand({
+  meta: {
+    name: "subgoal",
+    description: "Create a sub-goal linked to the active goal via parentGoalId."
+  },
+  args: {
+    intent: { type: "positional", description: "The sub-goal intent" },
+    task: { type: "string", description: "Target task id (T###) \u2014 makes it evidence-judged" },
+    turns: { type: "string", description: "Turn budget (default 10)" }
+  },
+  async run({ args }) {
+    const intent = String(args.intent ?? "").trim();
+    if (intent.length === 0) {
+      cliError("goal subgoal requires an <intent>", ExitCode.VALIDATION_ERROR, {
+        name: "E_VALIDATION"
+      });
+      return;
+    }
+    const cwd = getProjectRoot();
+    const parent = await goal.getActiveGoal(cwd);
+    if (!parent) {
+      cliError(
+        "No active goal to attach a sub-goal to. Run `cleo goal set` first.",
+        ExitCode.NOT_FOUND,
+        {
+          name: "E_NOT_FOUND"
+        }
+      );
+      return;
+    }
+    const kindResult = resolveGoalKind(args.task);
+    if ("error" in kindResult) {
+      cliError(kindResult.error, ExitCode.VALIDATION_ERROR, { name: "E_VALIDATION" });
+      return;
+    }
+    const record = await goal.createGoal(
+      {
+        goalKind: kindResult.kind,
+        intent,
+        turnBudget: resolveTurnBudget(args.turns),
+        parentGoalId: parent.id
+      },
+      cwd
+    );
+    cliOutput(record, { command: "goal subgoal", operation: "goal.subgoal" });
+  }
+});
+var advanceCommand = defineCommand({
+  meta: {
+    name: "advance",
+    description: "Advance a goal one turn (load \u2192 judge \u2192 persist \u2192 continuation). Entry point for the Stop-hook loop."
+  },
+  args: {
+    goalId: {
+      type: "positional",
+      description: "The goal id (idempotency key) to advance"
+    }
+  },
+  async run({ args }) {
+    const goalId = String(args.goalId ?? "").trim();
+    if (goalId.length === 0) {
+      cliError("goal advance requires a <goalId>", ExitCode.VALIDATION_ERROR, {
+        name: "E_VALIDATION"
+      });
+      return;
+    }
+    const cwd = getProjectRoot();
+    const result = await goal.advanceGoalWithPersist(goalId, { cwd });
+    if (!result) {
+      cliError(`Goal '${goalId}' not found.`, ExitCode.NOT_FOUND, { name: "E_NOT_FOUND" });
+      return;
+    }
+    cliOutput(result, { command: "goal advance", operation: "goal.advance" });
+  }
+});
+var appendCommand = defineCommand({
+  meta: {
+    name: "append",
+    description: "Append an acceptance criterion to the active goal."
+  },
+  args: {
+    criterion: { type: "positional", description: "The criterion text to append" }
+  },
+  async run({ args }) {
+    const criterion = String(args.criterion ?? "").trim();
+    if (criterion.length === 0) {
+      cliError("goal append requires a <criterion>", ExitCode.VALIDATION_ERROR, {
+        name: "E_VALIDATION"
+      });
+      return;
+    }
+    const cwd = getProjectRoot();
+    const active = await goal.getActiveGoal(cwd);
+    if (!active) {
+      cliError(
+        "No active goal to append a criterion to. Run `cleo goal set` first.",
+        ExitCode.NOT_FOUND,
+        {
+          name: "E_NOT_FOUND"
+        }
+      );
+      return;
+    }
+    const record = await goal.appendCriteria(active.id, criterion, cwd);
+    cliOutput(record ?? { active: null }, { command: "goal append", operation: "goal.append" });
+  }
+});
+var goalCommand = defineCommand({
+  meta: {
+    name: "goal",
+    description: "DB-persisted, per-agent, evidence-gate-aware goal loop (set/status/advance/subgoal/append)."
+  },
+  subCommands: {
+    set: setCommand,
+    status: statusCommand,
+    advance: advanceCommand,
+    subgoal: subgoalCommand,
+    append: appendCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  goalCommand
+};
+//# sourceMappingURL=goal-7CZRMLHC.js.map