@dadado/agent-kit-cli 6.1.1 → 6.3.0

package/dist/{chunk-3XKVQS2K.js → chunk-Z7ABX5QI.js}

@@ -4,18 +4,20 @@ import {
   claudeChildEnv,
   claudeHeadlessArgs,
   claudeRedactions,
+  claudeReviewArgs,
   claudeRunCaps,
   codexBackend,
   cursorAcpBackend,
   cursorAgentHeadlessArgs,
+  cursorAgentReviewArgs,
   redactSecrets,
   resolveHitlRunOptions,
   spawnLogged
-} from "./chunk-ESNAFDYT.js";
+} from "./chunk-JEI6HACW.js";
 import {
   ensureLoopLogsDir,
   runnerStatePaths
-} from "./chunk-C26I6HTO.js";
+} from "./chunk-C4Q77GGJ.js";
 import {
   fileExists
 } from "./chunk-5B4DVO6C.js";
@@ -32,7 +34,8 @@ var RUN_CATALOG = [
   "backlog-edit",
   "backlog-delete",
   "backlog-cancel",
-  "git-staging"
+  "git-staging",
+  "review-pack"
 ];
 var FIRST_CLASS_SLASH_COMMANDS = ["run-plan", "run-plan-all"];
 var RUN_PROMOTE_BLOCKED = RESERVED_GATE_IDS;
@@ -105,6 +108,9 @@ function claudeDispatchArgs(opts = {}) {
   return claudeHeadlessArgs(opts);
 }
 async function runHeadlessDispatch(opts) {
+  if (opts.readOnly && opts.backendId !== "claude" && opts.backendId !== "cursor-agent") {
+    throw new Error(`${opts.backendId}: a review-only session runs on claude or cursor-agent only`);
+  }
   if (opts.backendId === "codex" || opts.backendId === "cursor-acp") {
     const backend = opts.backendId === "codex" ? codexBackend : cursorAcpBackend;
     return backend.run({
@@ -132,7 +138,7 @@ async function runHeadlessDispatch(opts) {
     try {
       return await spawnLogged(
         opts.bin,
-        claudeDispatchArgs({ model: opts.model, ...caps }),
+        opts.readOnly ? claudeReviewArgs({ model: opts.model, ...caps }) : claudeDispatchArgs({ model: opts.model, ...caps }),
         opts.logPath,
         {
           cwd: opts.workspace,
@@ -152,13 +158,11 @@ async function runHeadlessDispatch(opts) {
       throw new Error(`claude dispatch failed to start: ${redactSecrets(String(err), redact)}`);
     }
   }
-  const args = cursorAgentDispatchArgs({
-    workspace: opts.workspace,
-    prompt: opts.prompt,
-    model: opts.model
-  });
+  const argvInput = { workspace: opts.workspace, prompt: opts.prompt, model: opts.model };
+  const args = opts.readOnly ? cursorAgentReviewArgs(argvInput) : cursorAgentDispatchArgs(argvInput);
   return spawnLogged(opts.bin, args, opts.logPath, {
     spawnFn: opts.spawnFn,
+    ...opts.readOnly ? { cwd: opts.workspace } : {},
     redact: claudeRedactions(process.env),
     hitl: resolveHitlRunOptions(opts.hitl, { kind: "none", backend: "cursor-agent" }),
     render: opts.render,

package/dist/{chunk-DBXDV5O7.js → chunk-Z7RYIHHX.js}

@@ -1,6 +1,11 @@
+import {
+  compareSemver,
+  normalizeSemver,
+  readLocalKitVersion
+} from "./chunk-6GYKOHIL.js";
 import {
   L0_ARTIFACTS
-} from "./chunk-VTOUQAVR.js";
+} from "./chunk-25J2SMJQ.js";
 import {
   copyRegistryFile,
   emptyStats,
@@ -12,24 +17,100 @@ import {
   recordOutcome,
   resolveProtectedGlobs,
   saveManagedHashLedger
-} from "./chunk-DBPNGZNH.js";
+} from "./chunk-6KUSG7BJ.js";
+import {
+  KIT_PACKAGE_SPEC,
+  KIT_VERSION
+} from "./chunk-7HDQEK6T.js";
 import {
   fileExists
 } from "./chunk-5B4DVO6C.js";
 
+// src/lifecycle/stale-cli.ts
+import path from "path";
+async function detectStaleCli(registryRoot, options) {
+  const registryVersionRaw = await readLocalKitVersion(registryRoot);
+  const registryVersion = registryVersionRaw ? normalizeSemver(registryVersionRaw) : null;
+  const cliVersion = normalizeSemver(options.cliVersion ?? KIT_VERSION);
+  if (!registryVersion) {
+    options.warn(
+      "Could not read a version from the registry checkout - skipping the CLI freshness check."
+    );
+    return null;
+  }
+  if (cliVersion && compareSemver(cliVersion, registryVersion) < 0) {
+    return { cliVersion, registryVersion };
+  }
+  return null;
+}
+var SHELL_SAFE = /^[A-Za-z0-9_./:@=+,-]+$/;
+function shellQuote(value) {
+  return SHELL_SAFE.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function formatRerunFlags(args, flags, currentDir = process.cwd()) {
+  const out = [];
+  for (const flag of flags) {
+    const value = args[flag];
+    if (value === true) {
+      out.push(flag === "yes" ? "-y" : `--${flag}`);
+    } else if (typeof value === "string" && value.length > 0) {
+      if (flag === "cwd" && path.resolve(value) === path.resolve(currentDir)) continue;
+      out.push(`--${flag}`, shellQuote(value));
+    }
+  }
+  return out.join(" ");
+}
+function formatStaleCliRefusal(input) {
+  const { command, stale, rerun } = input;
+  const { cliVersion, registryVersion } = stale;
+  const tail = rerun ? ` ${rerun}` : "";
+  return {
+    error: `This CLI is v${cliVersion}, older than the registry it would apply (v${registryVersion}).`,
+    recovery: [
+      "",
+      `\`agent-kit ${command}\` syncs registry content but stamps .cursor/agent-kit.json with the`,
+      `version of the CLI running it, so applying now would write v${cliVersion} again, not v${registryVersion}.`,
+      "",
+      "Upgrade the binary first, then re-run:",
+      `  npm i -g ${KIT_PACKAGE_SPEC}@${registryVersion}`,
+      `  agent-kit ${command}${tail}`,
+      "",
+      "Or run that version once without a global install:",
+      `  npx -y ${KIT_PACKAGE_SPEC}@${registryVersion} ${command}${tail}`,
+      "",
+      `If npm has no ${registryVersion} yet, the release is still mid-publish`,
+      "(content sync and npm publish run in parallel) - retry shortly.",
+      "",
+      "Factory/dev checkouts that intend to apply newer content with an older",
+      "binary can pass --allow-stale-cli.",
+      ""
+    ].join("\n")
+  };
+}
+var StaleCliError = class extends Error {
+  constructor(stale) {
+    super(
+      `This CLI is v${stale.cliVersion}, older than the registry it would apply (v${stale.registryVersion}).`
+    );
+    this.stale = stale;
+    this.name = "StaleCliError";
+  }
+  stale;
+};
+
 // src/lifecycle/onboard-migration.ts
 import { createHash } from "crypto";
 import { readFile, unlink } from "fs/promises";
-import path from "path";
+import path2 from "path";
 var LEGACY_ONBOARD_PATH = ".cursor/commands/onboard.md";
 var NAMESPACED_ONBOARD_PATH = ".cursor/commands/agent-kit-onboard.md";
 var MANAGED_LEGACY_HASHES = /* @__PURE__ */ new Set([
   "b274a68941813f19b185893cb7c5561dff027f53270890029992f208e24992fe"
 ]);
 async function migrateLegacyOnboardCommand(projectRoot, managedHashes = MANAGED_LEGACY_HASHES) {
-  const legacyPath = path.join(projectRoot, LEGACY_ONBOARD_PATH);
+  const legacyPath = path2.join(projectRoot, LEGACY_ONBOARD_PATH);
   if (!await fileExists(legacyPath)) return "absent";
-  const namespacedPath = path.join(projectRoot, NAMESPACED_ONBOARD_PATH);
+  const namespacedPath = path2.join(projectRoot, NAMESPACED_ONBOARD_PATH);
   if (!await fileExists(namespacedPath)) return "preserved-customized";
   const content = await readFile(legacyPath);
   const hash = createHash("sha256").update(content).digest("hex");
@@ -100,6 +181,10 @@ var NON_INTERACTIVE_ROOT_ARGS = {
 };
 
 export {
+  detectStaleCli,
+  formatRerunFlags,
+  formatStaleCliRefusal,
+  StaleCliError,
   installL0,
   syncFromManifest,
   NON_INTERACTIVE_ROOT_ARGS

package/dist/{contribute-A7NCWTUM.js → contribute-NLM2BN6Z.js}

@@ -1,19 +1,19 @@
 import {
   REGISTRY_CLI_ARGS,
   resolveRegistryFromCli
-} from "./chunk-3DGTPONS.js";
+} from "./chunk-U26MRIWN.js";
 import {
   logger
 } from "./chunk-ZB43YMHW.js";
 import {
   managedPairs
-} from "./chunk-VTOUQAVR.js";
+} from "./chunk-25J2SMJQ.js";
 import {
   loadAgentKitManifest,
   normalizeRelPath,
   resolveContained
-} from "./chunk-DBPNGZNH.js";
-import "./chunk-C26I6HTO.js";
+} from "./chunk-6KUSG7BJ.js";
+import "./chunk-C4Q77GGJ.js";
 import "./chunk-5B4DVO6C.js";
 
 // src/commands/contribute.ts

package/dist/countdown-QXJD6TDB.js

@@ -0,0 +1,479 @@
+import {
+  REVIEW_BACKENDS,
+  REVIEW_PACK_DEFAULT_MAX_BYTES,
+  REVIEW_PACK_SLASH,
+  parseReviewPackMaxBytes,
+  reviewBackendMessage
+} from "./chunk-MO63KZBP.js";
+import {
+  detectAgentBackend,
+  listDetectBackendIds
+} from "./chunk-GUQYNUV4.js";
+import "./chunk-QTBTKEXK.js";
+import {
+  GATE_EXIT_MARKER_RELPATH,
+  defaultExec,
+  gateExitRedactions,
+  gateExitStamp,
+  landGateExit,
+  listGateExitBranches,
+  readGateExitMarker,
+  resolveGateExitRefs,
+  writeGateExitMarker
+} from "./chunk-KVY425NM.js";
+import "./chunk-MUTTNRX4.js";
+import {
+  classifySlash,
+  normalizeSlashName,
+  promoteBlockedMessage,
+  unknownSlashMessage
+} from "./chunk-Z7ABX5QI.js";
+import {
+  CLAUDE_MAX_BUDGET_USD_ENV,
+  CLAUDE_MAX_TURNS_ENV,
+  HITL_UNANSWERED_EXIT_CODE,
+  RedactingStreamBuffer,
+  redactSecrets
+} from "./chunk-JEI6HACW.js";
+import "./chunk-WGLPZXNU.js";
+import "./chunk-MAPOQEA2.js";
+import "./chunk-QTON2GQX.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import {
+  ensureLoopLogsDir,
+  runnerStatePaths
+} from "./chunk-C4Q77GGJ.js";
+import "./chunk-5B4DVO6C.js";
+
+// src/commands/countdown.ts
+import { spawn } from "child_process";
+import { appendFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+var COUNTDOWN_EXIT = {
+  completed: 0,
+  usage: 1,
+  /** A gate exit is pending, or the run reached a gate. */
+  pending: 2,
+  /** Circuit's Dead: failed, stalled, over the window, dirty tree, fetch failed. */
+  circuitsDead: 3
+};
+var COUNTDOWN_JOBS = ["tick", "dispatch", "review"];
+var COUNTDOWN_DEFAULT_MAX_TICKS = 1;
+var COUNTDOWN_DEFAULT_WINDOW_MIN = 120;
+var COUNTDOWN_DEFAULT_STALL_MIN = 20;
+var COUNTDOWN_KILL_GRACE_MS = 3e4;
+var defaultSpawnJob = (args, opts) => {
+  const entry = process.argv[1] ?? "";
+  const group = process.platform !== "win32";
+  const child = spawn(process.execPath, [entry, ...args], {
+    cwd: opts.cwd,
+    env: opts.env,
+    detached: group,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const listeners = [];
+  const emit = (text) => {
+    for (const l of listeners) l(text);
+  };
+  child.stdout?.setEncoding("utf8");
+  child.stderr?.setEncoding("utf8");
+  child.stdout?.on("data", (t) => emit(t));
+  child.stderr?.on("data", (t) => emit(t));
+  const exited = new Promise((resolve) => {
+    child.once("error", (err) => {
+      emit(`countdown: could not start the job: ${String(err)}
+`);
+      resolve({ code: 1, signal: null });
+    });
+    child.once("close", (code, signal) => resolve({ code, signal }));
+  });
+  return {
+    onData: (listener) => listeners.push(listener),
+    kill: (signal) => {
+      try {
+        if (group && child.pid) process.kill(-child.pid, signal);
+        else child.kill(signal);
+      } catch {
+        child.kill(signal);
+      }
+    },
+    exited
+  };
+};
+async function superviseJob(handle, opts) {
+  let dead = null;
+  let killTimer;
+  const stop = (cause) => {
+    if (dead) return;
+    dead = cause;
+    opts.onCircuitsDead?.(cause);
+    handle.kill("SIGTERM");
+    killTimer = setTimeout(() => handle.kill("SIGKILL"), opts.killGraceMs);
+  };
+  const windowTimer = setTimeout(() => stop("window"), opts.windowMs);
+  let stallTimer = setTimeout(() => stop("stall"), opts.stallMs);
+  handle.onData((text) => {
+    opts.onData?.(text);
+    if (dead) return;
+    clearTimeout(stallTimer);
+    stallTimer = setTimeout(() => stop("stall"), opts.stallMs);
+  });
+  try {
+    const exit = await handle.exited;
+    return { ...exit, circuitsDead: dead };
+  } finally {
+    clearTimeout(windowTimer);
+    clearTimeout(stallTimer);
+    if (killTimer) clearTimeout(killTimer);
+  }
+}
+function countdownExitCode(input) {
+  if (input.circuitsDead) return COUNTDOWN_EXIT.circuitsDead;
+  if (input.code === 0) return input.pendingGrew ? COUNTDOWN_EXIT.pending : 0;
+  if (input.code === HITL_UNANSWERED_EXIT_CODE) return COUNTDOWN_EXIT.pending;
+  return COUNTDOWN_EXIT.circuitsDead;
+}
+function countdownChildArgs(input) {
+  const head = input.job === "tick" ? ["run-plan"] : input.job === "review" ? ["run", REVIEW_PACK_SLASH] : ["run", normalizeSlashName(input.slash ?? "")];
+  return [
+    ...head,
+    "--backend",
+    input.backend,
+    ...input.job === "review" ? [
+      "--max-pack-bytes",
+      String(input.maxPackBytes ?? REVIEW_PACK_DEFAULT_MAX_BYTES),
+      ...input.includeReviewed ? ["--include-reviewed"] : []
+    ] : ["--max-ticks", String(input.maxTicks)],
+    "--no-hitl",
+    "--land-on-gate",
+    "--plain",
+    ...input.model ? ["--model", input.model] : []
+  ];
+}
+async function countdownPreflight(opts) {
+  const git = (args) => opts.exec("git", args, { cwd: opts.root, env: opts.env });
+  const first = (text) => text.trim().split("\n")[0] ?? "";
+  const top = await git(["rev-parse", "--show-toplevel"]);
+  if (top.code !== 0) {
+    return { ok: false, exitCode: COUNTDOWN_EXIT.usage, reason: "not a git repository" };
+  }
+  const origin = await git(["remote", "get-url", "origin"]);
+  const hasOrigin = origin.code === 0 && origin.stdout.trim().length > 0;
+  if (hasOrigin) {
+    const fetched = await git(["fetch", "--prune", "--quiet", "origin"]);
+    if (fetched.code !== 0) {
+      return {
+        ok: false,
+        exitCode: COUNTDOWN_EXIT.circuitsDead,
+        reason: `Circuit's Dead: git fetch --prune failed (${first(fetched.stderr)}); pending gate-exit branches cannot be checked`
+      };
+    }
+    opts.log("fetched origin (--prune)");
+  } else {
+    opts.log("no `origin` remote: nothing fetched; checking local gate-exit branches");
+  }
+  const marker = await readGateExitMarker(opts.root);
+  if (marker.kind === "invalid") {
+    return {
+      ok: false,
+      exitCode: COUNTDOWN_EXIT.pending,
+      reason: `${GATE_EXIT_MARKER_RELPATH} is unreadable (${marker.detail}); not starting into an unknown gate state`
+    };
+  }
+  const pending = marker.kind === "ok" ? marker.marker.pending : [];
+  if (marker.kind === "ok" && pending.length > 0) {
+    const skipped = `skipped ${gateExitStamp(opts.now)}`;
+    try {
+      await writeGateExitMarker(opts.root, {
+        ...marker.marker,
+        skipped: [...marker.marker.skipped, skipped]
+      });
+      opts.log(`recorded \`${skipped}\` in ${GATE_EXIT_MARKER_RELPATH}`);
+    } catch (err) {
+      opts.log(`could not record the skipped run in ${GATE_EXIT_MARKER_RELPATH}: ${String(err)}`);
+    }
+    const stamps = pending.map((e) => e.stamp).join(", ");
+    return {
+      ok: false,
+      exitCode: COUNTDOWN_EXIT.pending,
+      reason: `gate exit pending (${stamps}); triage it before the next run`
+    };
+  }
+  const status = await git(["status", "--porcelain"]);
+  const dirty = status.stdout.split("\n").filter((l) => l.trim()).length;
+  if (status.code !== 0 || dirty > 0) {
+    return {
+      ok: false,
+      exitCode: COUNTDOWN_EXIT.circuitsDead,
+      reason: status.code !== 0 ? `Circuit's Dead: git status failed (${first(status.stderr)})` : `Circuit's Dead: the working tree is dirty (${dirty} path(s)); reported, not cleaned`
+    };
+  }
+  const refs = await resolveGateExitRefs(git, hasOrigin);
+  const unmerged = await listGateExitBranches(git, refs, { unmergedOnly: true });
+  if (unmerged.ok && unmerged.branches.length > 0) {
+    return {
+      ok: false,
+      exitCode: COUNTDOWN_EXIT.pending,
+      reason: `unmerged gate-exit branch(es) with no marker entry: ${unmerged.branches.join(", ")}; merge or discard them first`
+    };
+  }
+  return { ok: true, pendingBefore: pending.length, base: refs.base };
+}
+function positive(raw, flag, integer) {
+  const value = integer ? Number.parseInt(String(raw), 10) : Number.parseFloat(String(raw));
+  if (!Number.isFinite(value) || value <= 0 || integer && String(value) !== String(raw).trim()) {
+    return `${flag} must be a positive ${integer ? "integer" : "number"}`;
+  }
+  return value;
+}
+async function executeCountdown(input) {
+  const root = path.resolve(input.cwd);
+  const env = input.env ?? process.env;
+  const exec = input.exec ?? defaultExec;
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const write = input.write ?? ((text) => process.stdout.write(text));
+  const usage = (error) => ({
+    exitCode: COUNTDOWN_EXIT.usage,
+    error
+  });
+  const slash = normalizeSlashName(input.slash ?? "");
+  const job = String(input.job).trim();
+  for (const name of [slash, job]) {
+    if (name && classifySlash(name) === "promote-blocked")
+      return usage(promoteBlockedMessage(name));
+  }
+  if (!COUNTDOWN_JOBS.includes(job)) {
+    return usage(`--job must be one of: ${COUNTDOWN_JOBS.join(", ")}`);
+  }
+  if (job === "dispatch") {
+    if (!slash) return usage("--job dispatch needs --slash <name> (e.g. --slash backlog-add)");
+    if (classifySlash(slash) === "unknown") return usage(unknownSlashMessage(slash));
+  } else if (slash) {
+    return usage("--slash only applies to --job dispatch");
+  }
+  const maxTicks = positive(input.maxTicks, "--max-ticks", true);
+  const windowMin = positive(input.windowMin, "--window-min", false);
+  const stallMin = positive(input.stallMin, "--stall-min", false);
+  for (const v of [maxTicks, windowMin, stallMin]) if (typeof v === "string") return usage(v);
+  const packRaw = input.maxPackBytes === void 0 ? "" : String(input.maxPackBytes).trim();
+  if (job !== "review" && packRaw) return usage("--max-pack-bytes only applies to --job review");
+  if (job !== "review" && input.includeReviewed) {
+    return usage("--include-reviewed only applies to --job review");
+  }
+  const detected = await detectAgentBackend(input.backend, input.whichFn);
+  if (!detected.ok) return usage(detected.message);
+  let maxPackBytes;
+  if (job === "review") {
+    if (!REVIEW_BACKENDS.includes(detected.id)) {
+      return usage(reviewBackendMessage(detected.id));
+    }
+    const parsed = parseReviewPackMaxBytes(packRaw, detected.id);
+    if (typeof parsed === "string") return usage(parsed);
+    maxPackBytes = parsed;
+  }
+  const statePaths = runnerStatePaths(root, env);
+  await ensureLoopLogsDir(statePaths).catch(() => void 0);
+  const redactions = gateExitRedactions(env);
+  const red = (text) => redactSecrets(text, redactions);
+  const buffered = [];
+  let logPath = null;
+  let logChain = Promise.resolve();
+  const toLog = (text) => {
+    if (!logPath) {
+      buffered.push(text);
+      return;
+    }
+    const file = logPath;
+    logChain = logChain.then(() => appendFile(file, text, "utf8").catch(() => void 0));
+  };
+  const say = (line) => {
+    const text = `${red(`countdown: ${line}`)}
+`;
+    write(text);
+    toLog(text);
+  };
+  const openLog = async () => {
+    await ensureLoopLogsDir(statePaths);
+    const file = path.join(statePaths.loopLogsDir, `countdown-${gateExitStamp(now)}.log`);
+    await appendFile(file, buffered.join(""), "utf8");
+    buffered.length = 0;
+    logPath = file;
+  };
+  const jobLabel = job === "tick" ? "run-plan" : job === "review" ? `run ${REVIEW_PACK_SLASH}` : `run ${slash}`;
+  say(`fire ${gateExitStamp(now)}: job ${job} (${jobLabel}) on ${detected.id}`);
+  const preflight = await countdownPreflight({ root, env, exec, now, log: say });
+  if (!preflight.ok) {
+    say(`refused: ${preflight.reason} (exit ${preflight.exitCode})`);
+    await openLog().catch(() => void 0);
+    return { exitCode: preflight.exitCode, ...logPath ? { logPath } : {} };
+  }
+  await openLog();
+  const capLines = [CLAUDE_MAX_TURNS_ENV, CLAUDE_MAX_BUDGET_USD_ENV].filter((k) => env[k]).map((k) => `${k}=${env[k]}`);
+  const sizeCap = job === "review" ? `pack ceiling ${maxPackBytes} bytes${input.includeReviewed ? ", including branches already reviewed" : ""}` : `max ticks ${maxTicks}`;
+  say(
+    `caps: window ${windowMin} min, stall ${stallMin} min, ${sizeCap}${capLines.length ? `, ${capLines.join(", ")}` : ""}`
+  );
+  const args = countdownChildArgs({
+    job,
+    slash,
+    backend: detected.id,
+    maxTicks,
+    ...input.model ? { model: input.model } : {},
+    ...maxPackBytes !== void 0 ? { maxPackBytes } : {},
+    ...job === "review" && input.includeReviewed ? { includeReviewed: true } : {}
+  });
+  say(`starting: agent-kit ${args.join(" ")}`);
+  const handle = (input.spawnJob ?? defaultSpawnJob)(args, { cwd: root, env });
+  const forward = (signal) => handle.kill(signal);
+  const onSigint = () => forward("SIGINT");
+  const onSigterm = () => forward("SIGTERM");
+  if (input.forwardSignals) {
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+  }
+  const jobOut = new RedactingStreamBuffer(redactions);
+  const emitJob = (out) => {
+    if (!out) return;
+    write(out);
+    toLog(out);
+  };
+  let end;
+  try {
+    end = await superviseJob(handle, {
+      windowMs: windowMin * 6e4,
+      stallMs: stallMin * 6e4,
+      killGraceMs: input.killGraceMs ?? COUNTDOWN_KILL_GRACE_MS,
+      onData: (text) => emitJob(jobOut.push(text)),
+      onCircuitsDead: (cause) => say(
+        cause === "window" ? `Circuit's Dead: the ${windowMin} min window is over; stopping the job (SIGTERM, then SIGKILL)` : `Circuit's Dead: no stream event for ${stallMin} min; stopping the job (SIGTERM, then SIGKILL)`
+      )
+    });
+  } finally {
+    if (input.forwardSignals) {
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+    }
+    emitJob(jobOut.flush());
+  }
+  const after = await readGateExitMarker(root);
+  const pendingAfter = after.kind === "ok" ? after.marker.pending.length : preflight.pendingBefore;
+  const pendingGrew = pendingAfter > preflight.pendingBefore;
+  const exitCode = countdownExitCode({
+    code: end.code,
+    circuitsDead: end.circuitsDead,
+    pendingGrew
+  });
+  if (exitCode === COUNTDOWN_EXIT.circuitsDead && !pendingGrew) {
+    const reason = end.circuitsDead ? `Circuit's Dead: ${end.circuitsDead === "window" ? `window of ${windowMin} min exceeded` : `no stream event for ${stallMin} min`}` : `Circuit's Dead: job exited with ${end.code === null ? `signal ${end.signal ?? "unknown"}` : `code ${end.code}`}`;
+    const outcome = {
+      trigger: "failure",
+      exitCode,
+      reason,
+      command: `countdown --job ${job}${job === "dispatch" ? ` --slash ${slash}` : ""}`,
+      backend: detected.id,
+      ...logPath ? { logPath } : {}
+    };
+    try {
+      await (input.land ?? landGateExit)({ root, outcome, env, log: (line) => say(line) });
+    } catch (err) {
+      say(`gate-exit: landing failed: ${String(err)}`);
+    }
+  }
+  const meaning = exitCode === 0 ? "completed" : exitCode === COUNTDOWN_EXIT.pending ? job === "review" && end.code === 0 ? "review findings landed; gate exit pending" : "gate reached; gate exit pending" : "Circuit's Dead";
+  say(`exit ${exitCode} (${meaning})`);
+  await logChain;
+  return { exitCode, ...logPath ? { logPath } : {} };
+}
+var countdownCommand = defineCommand({
+  meta: {
+    name: "countdown",
+    description: "Countdown: one-shot launcher for a cron/systemd timer. Runs one headless job (tick, dispatch or review) with --no-hitl --land-on-gate; refused while a gate exit is pending. Exit 0 done, 2 gate or findings pending, 3 Circuit's Dead. Never git-prod."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      description: "Project root (default: current directory)",
+      default: process.cwd()
+    },
+    job: {
+      type: "string",
+      description: "tick (one run-plan tick, default) | dispatch (agent-kit run --slash <name>) | review (review-only pass over a bounded diff pack of unmerged branches; findings land as a gate exit)",
+      default: "tick"
+    },
+    slash: {
+      type: "string",
+      description: "For --job dispatch: the L0 slash to run (git-prod and kit-prod are refused)",
+      default: ""
+    },
+    backend: {
+      type: "string",
+      description: `Agent backend (${listDetectBackendIds().join(" | ")}; default: auto)`,
+      default: "auto"
+    },
+    model: {
+      type: "string",
+      description: "Optional model id passed to the agent backend",
+      default: ""
+    },
+    "max-ticks": {
+      type: "string",
+      description: `Maximum ticks for this fire (default: ${COUNTDOWN_DEFAULT_MAX_TICKS})`,
+      default: String(COUNTDOWN_DEFAULT_MAX_TICKS)
+    },
+    "max-pack-bytes": {
+      type: "string",
+      description: `For --job review: diff pack ceiling in bytes (default: ${REVIEW_PACK_DEFAULT_MAX_BYTES}; a branch whose section does not fit is listed as not reviewed, never cut)`,
+      default: ""
+    },
+    "include-reviewed": {
+      type: "boolean",
+      description: "For --job review: also review branches whose tip is unchanged since the last completed review",
+      default: false
+    },
+    "window-min": {
+      type: "string",
+      description: `Wall-clock cap in minutes; past it the job is stopped as Circuit's Dead (default: ${COUNTDOWN_DEFAULT_WINDOW_MIN})`,
+      default: String(COUNTDOWN_DEFAULT_WINDOW_MIN)
+    },
+    "stall-min": {
+      type: "string",
+      description: `Minutes with no stream event before the job is stopped as Circuit's Dead (default: ${COUNTDOWN_DEFAULT_STALL_MIN})`,
+      default: String(COUNTDOWN_DEFAULT_STALL_MIN)
+    }
+  },
+  async run({ args }) {
+    const result = await executeCountdown({
+      cwd: String(args.cwd),
+      job: String(args.job),
+      slash: String(args.slash ?? ""),
+      backend: String(args.backend),
+      ...args.model ? { model: String(args.model) } : {},
+      maxTicks: String(args["max-ticks"]),
+      ...args["max-pack-bytes"] ? { maxPackBytes: String(args["max-pack-bytes"]) } : {},
+      ...args["include-reviewed"] ? { includeReviewed: true } : {},
+      windowMin: String(args["window-min"]),
+      stallMin: String(args["stall-min"]),
+      forwardSignals: true
+    });
+    if (result.error) logger.error(result.error);
+    process.exitCode = result.exitCode;
+  }
+});
+export {
+  COUNTDOWN_DEFAULT_MAX_TICKS,
+  COUNTDOWN_DEFAULT_STALL_MIN,
+  COUNTDOWN_DEFAULT_WINDOW_MIN,
+  COUNTDOWN_EXIT,
+  COUNTDOWN_JOBS,
+  COUNTDOWN_KILL_GRACE_MS,
+  countdownChildArgs,
+  countdownCommand,
+  countdownExitCode,
+  countdownPreflight,
+  defaultSpawnJob,
+  executeCountdown,
+  superviseJob
+};