@dadado/agent-kit-cli 6.0.0 → 6.1.1

package/dist/{chunk-PCCQUWE5.js → chunk-3LLXDHIU.js}

@@ -2,7 +2,7 @@ import {
   REPO_ROOT_ENV,
   bundledDashboardCandidates,
   findDashboardStart
-} from "./chunk-HFUH3HVS.js";
+} from "./chunk-XDCCYBCJ.js";
 import {
   HELMET_ACCENT,
   HELMET_FILL,

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

@@ -11,7 +11,7 @@ import {
   redactSecrets,
   resolveHitlRunOptions,
   spawnLogged
-} from "./chunk-B5CH47OS.js";
+} from "./chunk-ESNAFDYT.js";
 import {
   ensureLoopLogsDir,
   runnerStatePaths

package/dist/{chunk-B5CH47OS.js → chunk-ESNAFDYT.js}

@@ -2071,6 +2071,7 @@ export {
   RESERVED_GATE_IDS,
   HITL_UNANSWERED_EXIT_CODE,
   formatHitlGateLine,
+  findHitlGateInText,
   operatorQuitStop,
   formatHitlSummary,
   hitlExitCode,

package/dist/{chunk-PAB35H27.js → chunk-OZYJUNAQ.js}

@@ -3,7 +3,7 @@ import {
   ScrollRegion,
   renderMcLive,
   runMcTuiLoop
-} from "./chunk-PCCQUWE5.js";
+} from "./chunk-3LLXDHIU.js";
 import {
   extractHandoffNamedPlans,
   namedPlanCandidatePaths,
@@ -13,6 +13,7 @@ import {
   LineSplitter,
   RedactingStreamBuffer,
   claudeRedactions,
+  findHitlGateInText,
   formatHitlGateLine,
   formatHitlSummary,
   operatorQuitStop,
@@ -20,7 +21,10 @@ import {
   redactSecrets,
   renderStreamEvent,
   whichBinary
-} from "./chunk-B5CH47OS.js";
+} from "./chunk-ESNAFDYT.js";
+import {
+  findOnPath
+} from "./chunk-WGLPZXNU.js";
 import {
   TtySpinner,
   shouldUseVisualMotion,
@@ -541,6 +545,443 @@ async function detectAgentBackend(requested, whichFn = whichBinary) {
   return { ok: true, id, bin };
 }
 
+// src/plan-loop/gate-exit.ts
+import { execFile } from "child_process";
+import { mkdir, mkdtemp, readFile as readFile3, rename, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import path3 from "path";
+var GATE_EXIT_BRANCH_PREFIX = "gate-exit/";
+var GATE_EXIT_MARKER_RELPATH = ".cursor/context/gate-exit.json";
+var GATE_EXIT_NOTE_DIR = ".cursor/gate-exit";
+var GATE_EXIT_DEFAULT_BASE = "staging";
+var GATE_EXIT_MARKER_SCHEMA = 1;
+var GATE_EXIT_STAMP_RE = /^\d{8}T\d{6}Z$/;
+var GATE_EXIT_SUMMARY_MAX_CHARS = 8 * 1024;
+var SAFE_REF_RE = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+var FALLBACK_GIT_IDENTITY = [
+  "-c",
+  "user.name=agent-kit",
+  "-c",
+  "user.email=agent-kit@noreply.invalid"
+];
+var LAND_ON_GATE_DESCRIPTION = "Gate exit: when the run stops at an unanswered gate, is stopped by the operator, or fails, push the outcome note to a gate-exit/<UTC stamp> branch from a temporary worktree and open a PR/MR when gh/glab is authenticated (root tree untouched; off by default)";
+function gateExitStamp(now = /* @__PURE__ */ new Date()) {
+  return now.toISOString().replace(/\.\d{3}Z$/, "Z").replace(/[-:]/g, "");
+}
+function isGateExitStamp(value) {
+  return GATE_EXIT_STAMP_RE.test(value);
+}
+function gateExitBranch(stamp2) {
+  if (!isGateExitStamp(stamp2)) throw new Error(`invalid gate-exit stamp: ${stamp2}`);
+  return `${GATE_EXIT_BRANCH_PREFIX}${stamp2}`;
+}
+function isSafeBaseRef(ref) {
+  return SAFE_REF_RE.test(ref) && !ref.includes("..") && !ref.endsWith("/") && !ref.endsWith(".lock");
+}
+function classifyGateExit(input) {
+  if (input.stop) {
+    return input.stop.message.startsWith("stopped-by-operator") ? "stopped-by-operator" : "gate";
+  }
+  return input.failed ? "failure" : null;
+}
+function gateExitMarkerPath(root) {
+  return path3.join(root, GATE_EXIT_MARKER_RELPATH);
+}
+async function readGateExitMarker(root) {
+  let raw;
+  try {
+    raw = await readFile3(gateExitMarkerPath(root), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return { kind: "absent" };
+    return { kind: "invalid", detail: String(err) };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.schema !== GATE_EXIT_MARKER_SCHEMA || !Array.isArray(parsed.pending) || !Array.isArray(parsed.skipped)) {
+      return { kind: "invalid", detail: "unexpected marker shape" };
+    }
+    const pending = parsed.pending.filter(
+      (e) => typeof e?.stamp === "string" && isGateExitStamp(e.stamp)
+    );
+    return {
+      kind: "ok",
+      marker: { schema: GATE_EXIT_MARKER_SCHEMA, pending, skipped: parsed.skipped.map(String) }
+    };
+  } catch (err) {
+    return { kind: "invalid", detail: String(err) };
+  }
+}
+async function writeGateExitMarker(root, marker) {
+  const file = gateExitMarkerPath(root);
+  await mkdir(path3.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  await writeFile(tmp, `${JSON.stringify(marker, null, 2)}
+`, "utf8");
+  await rename(tmp, file);
+}
+function gateExitRedactions(env) {
+  const entries = claudeRedactions(env);
+  const seen = new Set(entries.map((e) => e.value));
+  for (const key of ["GH_TOKEN", "GITHUB_TOKEN", "GITLAB_TOKEN", "GLAB_TOKEN"]) {
+    const value = env[key];
+    if (value && !seen.has(value)) {
+      seen.add(value);
+      entries.push({ label: key, value });
+    }
+  }
+  return entries;
+}
+function gateExitHeadline(stamp2, outcome) {
+  const what = outcome.trigger === "failure" ? "run failed" : outcome.trigger === "stopped-by-operator" ? `stopped by operator at gate \`${outcome.askId ?? "none"}\`` : `unanswered gate \`${outcome.askId ?? "none"}\``;
+  return `# Gate exit ${stamp2}: ${what}`;
+}
+function buildGateExitNote(input) {
+  const { outcome } = input;
+  const gateLine = outcome.askId && input.labels.length > 0 ? `\`HITL_GATE: ${outcome.askId} | ${input.labels.join(" | ")}\`` : "(no `HITL_GATE:` line recorded)";
+  const plan = outcome.plan !== void 0 ? `${outcome.plan} (ticks: ${outcome.ticks ?? 0}, pending to-dos: ${outcome.pending ?? "unknown"})` : "(none)";
+  const lines = [
+    gateExitHeadline(input.stamp, outcome),
+    "",
+    "- **Provenance:** agent-inferred. Written by `agent-kit` at the end of a headless run; no operator reply exists for this gate and none was inferred.",
+    `- **Trigger:** ${outcome.trigger}`,
+    `- **Ask id:** ${outcome.askId ? `\`${outcome.askId}\`` : "(none)"}`,
+    `- **Gate:** ${gateLine}`,
+    `- **Stop:** ${outcome.reason}`,
+    `- **Exit code:** ${outcome.exitCode}`,
+    `- **Command:** \`agent-kit ${outcome.command}\` (backend ${outcome.backend})`,
+    `- **Plan:** ${plan}`,
+    `- **Log:** ${input.logRel ? `\`${input.logRel}\` (on the machine that ran; not pushed)` : "(none)"}`,
+    `- **Root tree:** ${input.dirtyPaths > 0 ? `dirty (${input.dirtyPaths} path(s)), reported and not cleaned` : "clean"}`,
+    `- **Base:** \`${input.base}\``,
+    "",
+    "Next: answer the gate in a live session (`/continue-plan` or `/run-plan`), then accept or discard this ticket (`agent-kit ground-control`). Never `/git-prod` from a headless run."
+  ];
+  const summary = outcome.summary?.trim();
+  if (summary) {
+    const capped = summary.length > GATE_EXIT_SUMMARY_MAX_CHARS ? `${summary.slice(0, GATE_EXIT_SUMMARY_MAX_CHARS)}
+
+(summary truncated at ${GATE_EXIT_SUMMARY_MAX_CHARS} characters)` : summary;
+    lines.push("", "## Run summary", "", "```text", capped.replaceAll("```", "'''"), "```");
+  }
+  return `${lines.join("\n")}
+`;
+}
+function collectStrings(value, out, depth) {
+  if (depth > 8) return;
+  if (typeof value === "string") out.push(value);
+  else if (Array.isArray(value)) for (const v of value) collectStrings(v, out, depth + 1);
+  else if (value && typeof value === "object") {
+    for (const v of Object.values(value)) collectStrings(v, out, depth + 1);
+  }
+}
+function decodeRunLog(raw) {
+  const out = [];
+  for (const line of raw.split(/\r?\n/)) {
+    out.push(line);
+    if (!line.startsWith("{")) continue;
+    try {
+      collectStrings(JSON.parse(line), out, 0);
+    } catch {
+    }
+  }
+  return out.join("\n");
+}
+async function findGateLabels(askId, sources) {
+  const fromText = sources.gateText ? findHitlGateInText(sources.gateText) : null;
+  if (fromText?.askId === askId) return fromText.labels;
+  if (!sources.logPath) return [];
+  try {
+    const gate = findHitlGateInText(decodeRunLog(await readFile3(sources.logPath, "utf8")));
+    return gate?.askId === askId ? gate.labels : [];
+  } catch {
+    return [];
+  }
+}
+var defaultExec = (bin, args, opts) => new Promise((resolve) => {
+  execFile(
+    bin,
+    [...args],
+    {
+      cwd: opts.cwd,
+      env: { ...opts.env ?? process.env, GIT_TERMINAL_PROMPT: "0" },
+      encoding: "utf8",
+      maxBuffer: 4 * 1024 * 1024,
+      timeout: 12e4
+    },
+    (err, stdout, stderr) => {
+      const code = err ? typeof err.code === "number" ? err.code : 1 : 0;
+      resolve({
+        code,
+        stdout: String(stdout ?? ""),
+        stderr: String(stderr ?? err?.message ?? "")
+      });
+    }
+  );
+});
+function isOutside(parent, child) {
+  const rel = path3.relative(parent, child);
+  return rel.startsWith("..") || path3.isAbsolute(rel);
+}
+async function landGateExit(opts) {
+  const env = opts.env ?? process.env;
+  const exec = opts.exec ?? defaultExec;
+  const which = opts.which ?? ((bin) => findOnPath(bin, { env }));
+  const redactions = gateExitRedactions(env);
+  const red2 = (text) => redactSecrets(text, redactions);
+  const log = (line) => opts.log?.(red2(`gate-exit: ${line}`));
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const stamp2 = gateExitStamp(now);
+  const branch = gateExitBranch(stamp2);
+  const outcome = opts.outcome;
+  const requestedBase = opts.base ?? GATE_EXIT_DEFAULT_BASE;
+  const result = {
+    stamp: stamp2,
+    branch: null,
+    committed: false,
+    pushed: false,
+    url: null,
+    markerWritten: false,
+    note: ""
+  };
+  const git = (args, cwd) => exec("git", args, { cwd, env });
+  const labels = outcome.askId ? await findGateLabels(outcome.askId, { gateText: outcome.gateText, logPath: outcome.logPath }) : [];
+  const top = await git(["rev-parse", "--show-toplevel"], opts.root);
+  const repo = top.code === 0 ? top.stdout.trim() : null;
+  let dirtyPaths = 0;
+  if (repo) {
+    const status = await git(["status", "--porcelain"], repo);
+    dirtyPaths = status.stdout.split("\n").filter((l) => l.trim()).length;
+    if (dirtyPaths > 0) {
+      log(`root tree is dirty (${dirtyPaths} path(s)); reported, not cleaned`);
+    }
+  }
+  let base = isSafeBaseRef(requestedBase) ? requestedBase : GATE_EXIT_DEFAULT_BASE;
+  const logRel = outcome.logPath ? path3.relative(opts.root, outcome.logPath) : null;
+  const buildNote = () => red2(buildGateExitNote({ stamp: stamp2, outcome, labels, base, logRel, dirtyPaths }));
+  const writeMarker = async () => {
+    const entry = {
+      stamp: stamp2,
+      openedAt: now.toISOString(),
+      trigger: outcome.trigger,
+      askId: outcome.askId ?? null,
+      labels: labels.map(red2),
+      base,
+      branch: result.branch,
+      pushed: result.pushed,
+      url: result.url
+    };
+    const current = await readGateExitMarker(opts.root);
+    if (current.kind === "invalid") {
+      log(
+        `${GATE_EXIT_MARKER_RELPATH} is unreadable (${current.detail}); left as is, entry ${stamp2} not recorded`
+      );
+      return;
+    }
+    const marker = current.kind === "ok" ? { ...current.marker, pending: [...current.marker.pending, entry] } : { schema: GATE_EXIT_MARKER_SCHEMA, pending: [entry], skipped: [] };
+    try {
+      await writeGateExitMarker(opts.root, marker);
+      result.markerWritten = true;
+    } catch (err) {
+      log(`could not write ${GATE_EXIT_MARKER_RELPATH}: ${String(err)}`);
+      return;
+    }
+    if (repo) {
+      const ignored = await git(["check-ignore", "-q", "--", GATE_EXIT_MARKER_RELPATH], opts.root);
+      if (ignored.code !== 0) {
+        log(
+          `${GATE_EXIT_MARKER_RELPATH} is not gitignored here; add it to .gitignore (agent-kit update adds it)`
+        );
+      }
+    }
+  };
+  if (!repo) {
+    log("not a git repository; no branch landed");
+    result.note = buildNote();
+    await writeMarker();
+    return result;
+  }
+  const origin = await git(["remote", "get-url", "origin"], repo);
+  const hasOrigin = origin.code === 0 && origin.stdout.trim().length > 0;
+  const originUrl = hasOrigin ? origin.stdout.trim() : "";
+  let startRef = null;
+  if (hasOrigin) {
+    const fetched = await git(["fetch", "--quiet", "origin", base], repo);
+    if (fetched.code !== 0)
+      log(`fetch origin ${base} failed: ${fetched.stderr.trim().split("\n")[0] ?? ""}`);
+    const verify = await git(
+      ["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${base}^{commit}`],
+      repo
+    );
+    if (verify.code === 0) {
+      startRef = `refs/remotes/origin/${base}`;
+    } else {
+      const head = await git(
+        ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"],
+        repo
+      );
+      const fallback = head.stdout.trim().replace(/^origin\//, "");
+      if (head.code === 0 && isSafeBaseRef(fallback)) {
+        log(`origin/${base} not found; using the remote default branch ${fallback}`);
+        base = fallback;
+        startRef = `refs/remotes/origin/${fallback}`;
+      }
+    }
+  } else {
+    log("no `origin` remote: the branch stays local, nothing is pushed");
+    const local = await git(
+      ["rev-parse", "--verify", "--quiet", `refs/heads/${base}^{commit}`],
+      repo
+    );
+    startRef = local.code === 0 ? `refs/heads/${base}` : "HEAD";
+  }
+  result.note = buildNote();
+  if (!startRef) {
+    log(`no base to branch from (origin/${base} missing); note not landed`);
+    await writeMarker();
+    return result;
+  }
+  let tmp = null;
+  let wt = null;
+  try {
+    tmp = await mkdtemp(path3.join(opts.tmpRoot ?? tmpdir(), "agent-kit-gate-exit-"));
+    if (!isOutside(repo, tmp)) {
+      log("temporary directory resolves inside the repository; refusing to land there");
+      return result;
+    }
+    wt = path3.join(tmp, "wt");
+    const added = await git(["worktree", "add", "--detach", "--quiet", wt, startRef], repo);
+    if (added.code !== 0) {
+      wt = null;
+      log(`worktree add failed: ${added.stderr.trim().split("\n")[0] ?? ""}`);
+      return result;
+    }
+    const noteRel = `${GATE_EXIT_NOTE_DIR}/${stamp2}.md`;
+    await mkdir(path3.join(wt, GATE_EXIT_NOTE_DIR), { recursive: true });
+    await writeFile(path3.join(wt, noteRel), result.note, "utf8");
+    const add = await git(["add", "-f", "--", noteRel], wt);
+    if (add.code !== 0) {
+      log(`git add failed: ${add.stderr.trim().split("\n")[0] ?? ""}`);
+      return result;
+    }
+    const email = await git(["config", "user.email"], wt);
+    const identity = email.code === 0 && email.stdout.trim() ? [] : FALLBACK_GIT_IDENTITY;
+    const subject = `docs(gate-exit): record the ${outcome.trigger} of ${stamp2}`;
+    const body = `Ask id: ${outcome.askId ?? "none"}. Provenance: agent-inferred.`;
+    const commit = await git([...identity, "commit", "--quiet", "-m", subject, "-m", body], wt);
+    if (commit.code !== 0) {
+      log(`commit failed: ${commit.stderr.trim().split("\n")[0] ?? ""}`);
+      return result;
+    }
+    result.committed = true;
+    if (hasOrigin) {
+      const push = await git(["push", "--quiet", "origin", `HEAD:refs/heads/${branch}`], wt);
+      if (push.code === 0) {
+        result.pushed = true;
+        result.branch = branch;
+        log(`pushed ${branch}`);
+      } else {
+        log(`push failed: ${push.stderr.trim().split("\n")[0] ?? ""}`);
+      }
+    }
+    if (!result.pushed) {
+      const keep = await git(["branch", branch, "HEAD"], wt);
+      if (keep.code === 0) {
+        result.branch = branch;
+        log(`branch ${branch} kept locally; push it with: git push origin ${branch}`);
+      }
+    }
+    if (result.pushed) {
+      result.url = await openReview({
+        branch,
+        base,
+        title: `${outcome.trigger === "failure" ? "Gate exit: run failed" : `Gate exit: ${outcome.askId ?? "gate"}`} (${stamp2})`,
+        body: result.note,
+        cwd: wt,
+        tmp,
+        originUrl,
+        exec,
+        which,
+        env,
+        log
+      });
+    }
+  } catch (err) {
+    log(`landing failed: ${String(err)}`);
+  } finally {
+    if (wt) await git(["worktree", "remove", "--force", wt], repo);
+    if (tmp) await rm(tmp, { recursive: true, force: true }).catch(() => void 0);
+    await git(["worktree", "prune"], repo);
+    await writeMarker();
+  }
+  return result;
+}
+function lastUrl(text) {
+  const urls = text.match(/https?:\/\/\S+/g);
+  return urls?.at(-1) ?? null;
+}
+async function openReview(input) {
+  const forges = /gitlab/i.test(input.originUrl) ? ["glab", "gh"] : ["gh", "glab"];
+  for (const forge of forges) {
+    const bin = await input.which(forge);
+    if (!bin) continue;
+    const auth = await input.exec(bin, ["auth", "status"], { cwd: input.cwd, env: input.env });
+    if (auth.code !== 0) {
+      input.log(`${forge} is not authenticated; skipping the ${forge === "gh" ? "PR" : "MR"}`);
+      continue;
+    }
+    let created;
+    if (forge === "gh") {
+      const bodyFile = path3.join(input.tmp, "pr-body.md");
+      await writeFile(bodyFile, input.body, "utf8");
+      created = await input.exec(
+        bin,
+        [
+          "pr",
+          "create",
+          "--base",
+          input.base,
+          "--head",
+          input.branch,
+          "--title",
+          input.title,
+          "--body-file",
+          bodyFile
+        ],
+        { cwd: input.cwd, env: input.env }
+      );
+    } else {
+      created = await input.exec(
+        bin,
+        [
+          "mr",
+          "create",
+          "--source-branch",
+          input.branch,
+          "--target-branch",
+          input.base,
+          "--title",
+          input.title,
+          "--description",
+          input.body,
+          "--yes"
+        ],
+        { cwd: input.cwd, env: input.env }
+      );
+    }
+    if (created.code === 0) {
+      const url = lastUrl(created.stdout);
+      input.log(`${forge === "gh" ? "PR" : "MR"} opened${url ? `: ${url}` : ""}`);
+      return url;
+    }
+    input.log(`${forge} could not open the review: ${created.stderr.trim().split("\n")[0] ?? ""}`);
+    return null;
+  }
+  input.log(
+    `no authenticated gh/glab; open the review by hand: gh pr create --base ${input.base} --head ${input.branch} (or glab mr create --source-branch ${input.branch} --target-branch ${input.base})`
+  );
+  return null;
+}
+
 // src/plan-loop/driver-events.ts
 import { createInterface } from "readline";
 import { StringDecoder as StringDecoder2 } from "string_decoder";
@@ -754,14 +1195,14 @@ var DriverAgentSink = class {
 };
 
 // src/plan-loop/run-loop.ts
-import { readFile as readFile4, rm, unlink } from "fs/promises";
-import path5 from "path";
+import { readFile as readFile5, rm as rm2, unlink } from "fs/promises";
+import path6 from "path";
 
 // src/plan-loop/external-review.ts
 import { spawn } from "child_process";
-import path3 from "path";
-var CANONICAL_REL = path3.join(".cursor", "scripts", "plan-external-review.sh");
-var FALLBACK_REL = path3.join("scripts", "plan-external-review.sh");
+import path4 from "path";
+var CANONICAL_REL = path4.join(".cursor", "scripts", "plan-external-review.sh");
+var FALLBACK_REL = path4.join("scripts", "plan-external-review.sh");
 function isPlanExhaustedReason(reason) {
   const r = reason.trim().toLowerCase();
   if (!r) return false;
@@ -783,8 +1224,8 @@ async function armExternalPlanReview(root, options = {}) {
   const existsFn = options.existsFn ?? fileExists;
   const log = options.log ?? ((line) => console.log(line));
   const force = options.force === true;
-  const canonicalPath = path3.join(root, CANONICAL_REL);
-  const fallbackPath = path3.join(root, FALLBACK_REL);
+  const canonicalPath = path4.join(root, CANONICAL_REL);
+  const fallbackPath = path4.join(root, FALLBACK_REL);
   let scriptPath = null;
   let scriptRel = CANONICAL_REL;
   if (await existsFn(canonicalPath)) {
@@ -851,7 +1292,7 @@ async function armExternalPlanReview(root, options = {}) {
 }
 
 // src/plan-loop/persona-banners.ts
-import path4 from "path";
+import path5 from "path";
 import {
   blue,
   cyan,
@@ -887,7 +1328,7 @@ function resolveColor(name, fallback) {
 async function resolveCliPersonaId(root) {
   try {
     const cfg = await readJson(
-      path4.join(root, ".cursor", "context", "config.json")
+      path5.join(root, ".cursor", "context", "config.json")
     );
     const modes = cfg?.agentPersona?.modes ?? cfg?.workspaceSkin?.modes;
     const id = modes?.[CLI_RUN_PLAN_MODE];
@@ -898,7 +1339,7 @@ async function resolveCliPersonaId(root) {
 }
 async function loadPersonaPack(root, personaId) {
   try {
-    const personaPath = path4.join(root, "registry", "personas", "core", personaId, "persona.json");
+    const personaPath = path5.join(root, "registry", "personas", "core", personaId, "persona.json");
     const pack = await readJson(personaPath);
     if (!pack || typeof pack.id !== "string") return null;
     return pack;
@@ -947,7 +1388,7 @@ function createPersonaBannerPrinter(persona) {
 }
 
 // src/plan-loop/sentinel.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 var SENTINEL_RE = /LOOP_TICK_RESULT:\s*(continue|stop(?:\s*[—-].*)?)/i;
 function takeFromText(text) {
   if (!text) return null;
@@ -1016,14 +1457,14 @@ function parseTickResultStatus(content) {
 }
 async function parseTickResultStatusFromLogFile(logPath) {
   try {
-    return parseTickResultStatus(await readFile3(logPath, "utf8"));
+    return parseTickResultStatus(await readFile4(logPath, "utf8"));
   } catch {
     return null;
   }
 }
 async function parseSentinelFromLogFile(logPath) {
   try {
-    const content = await readFile3(logPath, "utf8");
+    const content = await readFile4(logPath, "utf8");
     return parseSentinelFromLog(content);
   } catch {
     return { kind: "missing" };
@@ -1208,6 +1649,42 @@ async function runPlanLoop(opts) {
     else console.log(message);
   };
   const emit = (event) => driver?.emitter.emit(event);
+  let landStop;
+  let landFailed = false;
+  let landLogPath;
+  let landSummary;
+  let landGateText;
+  let landBackend = opts.backend.id;
+  let landPlan;
+  const landIfNeeded = async (exitCode, reason, pendingNow) => {
+    if (!opts.landOnGate || opts.dryRun) return;
+    const trigger = classifyGateExit({ stop: landStop, failed: landFailed });
+    if (!trigger) return;
+    const outcome = {
+      trigger,
+      exitCode,
+      reason,
+      command: "run-plan",
+      backend: landBackend,
+      ticks: ticksRun,
+      pending: pendingNow,
+      ...landPlan ? { plan: landPlan } : {},
+      ...landStop ? { askId: landStop.askId } : {},
+      ...landLogPath ? { logPath: landLogPath } : {},
+      ...landSummary ? { summary: landSummary } : {},
+      ...landGateText ? { gateText: landGateText } : {}
+    };
+    try {
+      await landGateExit({
+        ...opts.gateExit,
+        root: opts.root,
+        outcome,
+        log: (line) => say(line, "warn")
+      });
+    } catch (err) {
+      say(`gate-exit: landing failed: ${String(err)}`, "warn");
+    }
+  };
   const finishRun = (exitCode, reason, pending2, planExhausted = false) => {
     emit({ type: "run_end", exitCode, ticks: ticksRun, pending: pending2, reason, planExhausted });
     driver?.reader.close();
@@ -1219,6 +1696,7 @@ async function runPlanLoop(opts) {
     return finishRun(1, "no active plan", null);
   }
   const pending = async () => countPendingTodos(await readPlan(planPath));
+  landPlan = path6.basename(planPath);
   if (statePaths.invalid !== void 0) {
     say(
       `${STATE_ROOT_ENV}=${statePaths.invalid} is not supported (use .cursor or .agent-kit); using .cursor.`,
@@ -1255,12 +1733,12 @@ async function runPlanLoop(opts) {
       type: "run_start",
       protocol: DRIVER_PROTOCOL_VERSION,
       backend: opts.backend.id,
-      plan: path5.basename(planPath),
+      plan: path6.basename(planPath),
       pending: pendingAtStart,
       maxTicks: opts.maxTicks,
       hitl: opts.noHitl ? "off" : "driver"
     });
-    say(`Active plan: ${path5.basename(planPath)}`);
+    say(`Active plan: ${path6.basename(planPath)}`);
     say(`Pending to-dos: ${pendingAtStart} | max ticks: ${opts.maxTicks}`);
     say(`Backend: ${opts.backend.id}`);
     if (persona) {
@@ -1297,7 +1775,7 @@ async function runPlanLoop(opts) {
         else say(msg);
         endReason = "stop file found";
         try {
-          await rm(stopFile, { force: true });
+          await rm2(stopFile, { force: true });
         } catch {
         }
         break;
@@ -1309,8 +1787,10 @@ async function runPlanLoop(opts) {
         endReason = "plan exhausted";
         break;
       }
-      const logPath = path5.join(logDir, `tick-${stamp()}.log`);
-      const relLog = path5.relative(opts.root, logPath);
+      const logPath = path6.join(logDir, `tick-${stamp()}.log`);
+      landLogPath = logPath;
+      landBackend = backend.id;
+      const relLog = path6.relative(opts.root, logPath);
       if (!driver) console.log("");
       const tickLine = `=== tick ${tick}/${opts.maxTicks} - pending: ${before} - log: ${relLog} ===`;
       if (banners) banners.tickStart(tickLine);
@@ -1376,11 +1856,17 @@ async function runPlanLoop(opts) {
         hitlStop = result.hitl?.stop;
         replies = result.hitl?.replies ?? [];
         lastResult = result.lastResult;
+        landSummary = lastResult?.resultText.trim() || lastResult?.assistantTexts.at(-1)?.trim() || void 0;
+        landGateText = lastResult ? [lastResult.resultText, ...lastResult.assistantTexts].join("\n") : void 0;
       } catch (err) {
         say(String(err), "error");
         agentExit = 1;
         endTick(null, null);
-        return finishRun(1, `tick ${tick} failed to start: ${String(err)}`, await pending());
+        const reason = `tick ${tick} failed to start: ${String(err)}`;
+        const pendingNow2 = await pending();
+        landFailed = true;
+        await landIfNeeded(1, reason, pendingNow2);
+        return finishRun(1, reason, pendingNow2);
       }
       if (hitlStop) {
         const msg = `${backend.id} tick ended at a HITL gate without a reply - stopping. See log: ${relLog}`;
@@ -1393,11 +1879,12 @@ async function runPlanLoop(opts) {
         endTick(await pending(), null);
         exitCode = hitlStop.exitCode;
         endReason = hitlStop.message;
+        landStop = hitlStop;
         break;
       }
       let logText = "";
       try {
-        logText = await readFile4(logPath, "utf8");
+        logText = await readFile5(logPath, "utf8");
       } catch {
       }
       limit = detectUsageLimit(logText);
@@ -1431,6 +1918,7 @@ async function runPlanLoop(opts) {
         else say(msg);
         endTick(await pending(), null);
         endReason = "too many MCP tools";
+        landFailed = true;
         break;
       }
       const status = await resolveTickResultStatus(lastResult, logPath);
@@ -1445,6 +1933,7 @@ async function runPlanLoop(opts) {
         }
         endTick(await pending(), null);
         endReason = `tick failed (${status.subtype ?? "is_error"})`;
+        landFailed = true;
         break;
       }
       if (agentExit !== 0) {
@@ -1457,6 +1946,7 @@ async function runPlanLoop(opts) {
         }
         endTick(await pending(), null);
         endReason = `${backend.id} exited with code ${agentExit}`;
+        landFailed = true;
         break;
       }
       const sentinel = await resolveTickSentinel(lastResult, logPath);
@@ -1484,6 +1974,7 @@ async function runPlanLoop(opts) {
         if (banners) banners.stop(msg);
         else say(msg);
         endReason = "tick without sentinel and no progress";
+        landFailed = true;
         break;
       }
       if (after === 0) {
@@ -1507,7 +1998,7 @@ async function runPlanLoop(opts) {
     const finishDetail = `after ${tick} tick(s); pending: ${pendingNow}`;
     if (banners) banners.phaseComplete(finishDetail);
     say(
-      `Loop finished after ${tick} tick(s). Pending now: ${pendingNow}. Logs in ${path5.relative(opts.root, logDir)}/`
+      `Loop finished after ${tick} tick(s). Pending now: ${pendingNow}. Logs in ${path6.relative(opts.root, logDir)}/`
     );
     if (planExhausted || shouldArmExternalPlanReview({ pending: pendingNow, stopReason })) {
       await armExternalPlanReview(
@@ -1515,6 +2006,7 @@ async function runPlanLoop(opts) {
         driver ? { log: (line) => say(line), writeOut: driver.writeErr } : {}
       );
     }
+    await landIfNeeded(exitCode, endReason || "stopped", pendingNow);
     return finishRun(exitCode, endReason || "stopped", pendingNow, planExhausted);
   } finally {
     process.off("SIGINT", onSigInt);
@@ -1526,6 +2018,9 @@ export {
   withLiveTui,
   listDetectBackendIds,
   detectAgentBackend,
+  LAND_ON_GATE_DESCRIPTION,
+  classifyGateExit,
+  landGateExit,
   DRIVER_EVENTS_FORMATS,
   runPlanLoop
 };

package/dist/{chunk-WFXHMP47.js → chunk-TMFOLRU2.js}

@@ -15,7 +15,7 @@ import {
 import {
   assessClaudeCommandAdapters,
   executeSafeReadinessFixes
-} from "./chunk-4U7DLAQH.js";
+} from "./chunk-YP4OOK4T.js";
 import {
   writeReadinessSnapshot
 } from "./chunk-HAFRAXGV.js";
@@ -35,7 +35,7 @@ import {
   REPOSITORY_PROFILE_REL,
   detectIde,
   runScanner
-} from "./chunk-T6P5ZMG2.js";
+} from "./chunk-U5F6RJN4.js";
 import {
   GIT_PLATFORM_META
 } from "./chunk-F6C3GFKV.js";

package/dist/{chunk-T6P5ZMG2.js → chunk-U5F6RJN4.js}

@@ -436,7 +436,8 @@ var KIT_OWNED_IGNORE_PATTERNS = [
   ".cursor/dogfood/",
   ".cursor/context/readiness.json",
   ".cursor/context/flight-log.json",
-  ".cursor/context/mission-timing.json"
+  ".cursor/context/mission-timing.json",
+  ".cursor/context/gate-exit.json"
 ];
 function globToRegExp(glob) {
   const body = glob.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*");

package/dist/{chunk-HFUH3HVS.js → chunk-XDCCYBCJ.js}

@@ -93,6 +93,11 @@ function readPreferredBrowserFromConfig(configPath, fsHooks = {}) {
   }
 }
 
+// src/commands/negated-flag.ts
+function negatedFlag(args, name) {
+  return args[`no-${name}`] === true || args[name] === false;
+}
+
 // src/commands/dashboard.ts
 function readPreferredBrowserFromWorkspace(cwd, readFile = readFileSync2) {
   const resolved = resolveContextConfigPath(path.resolve(cwd), {
@@ -260,7 +265,7 @@ var dashboardCommand = defineCommand({
       return;
     }
     const env = dashboardSpawnEnv({ ...process.env }, snapshotRoot, {
-      noOpen: Boolean(args["no-open"]),
+      noOpen: negatedFlag(args, "open"),
       browser: args.browser
     });
     process.title = dashboardProcessTitle(snapshotRoot);
@@ -271,6 +276,7 @@ var dashboardCommand = defineCommand({
 
 export {
   REPO_ROOT_ENV,
+  negatedFlag,
   readPreferredBrowserFromWorkspace,
   applyDashboardOpenEnv,
   dashboardSpawnEnv,

package/dist/{chunk-4U7DLAQH.js → chunk-YP4OOK4T.js}

@@ -18,7 +18,7 @@ import {
   REQUIRED_SECRET_PATTERNS,
   detectGitDirty,
   runScanner
-} from "./chunk-T6P5ZMG2.js";
+} from "./chunk-U5F6RJN4.js";
 import {
   CONTEXT_CONFIG_REL,
   contextConfigPath

package/dist/{dashboard-YSNUGBFY.js → dashboard-YNCFISNO.js}

@@ -7,7 +7,7 @@ import {
   findDashboardStart,
   readPreferredBrowserFromWorkspace,
   resolveDashboardSnapshotRoot
-} from "./chunk-HFUH3HVS.js";
+} from "./chunk-XDCCYBCJ.js";
 import "./chunk-ZB43YMHW.js";
 export {
   applyDashboardOpenEnv,

package/dist/{dashboard-broadcast-M4CMW7RX.js → dashboard-broadcast-NK7PU72L.js}

@@ -3,8 +3,9 @@ import {
   dashboardProcessTitle,
   dashboardSpawnEnv,
   findDashboardStart,
+  negatedFlag,
   resolveDashboardSnapshotRoot
-} from "./chunk-HFUH3HVS.js";
+} from "./chunk-XDCCYBCJ.js";
 import {
   logger
 } from "./chunk-ZB43YMHW.js";
@@ -105,7 +106,7 @@ var dashboardBroadcastCommand = defineCommand({
     }
     const snapshotRoot = resolveDashboardSnapshotRoot(args.cwd);
     const env = dashboardSpawnEnv({ ...process.env }, snapshotRoot, {
-      noOpen: Boolean(args["no-open"]),
+      noOpen: negatedFlag(args, "open"),
       browser: args.browser
     });
     process.title = dashboardProcessTitle(snapshotRoot);

package/dist/{doctor-MQAXOFKM.js → doctor-SS6Y2T6H.js}

@@ -2,7 +2,7 @@ import {
   assessHooksHealth,
   executeSafeReadinessFixes,
   refreshRepositoryProfile
-} from "./chunk-4U7DLAQH.js";
+} from "./chunk-YP4OOK4T.js";
 import {
   writeReadinessSnapshot
 } from "./chunk-HAFRAXGV.js";
@@ -21,7 +21,7 @@ import {
 } from "./chunk-PNFF6OU3.js";
 import {
   runScanner
-} from "./chunk-T6P5ZMG2.js";
+} from "./chunk-U5F6RJN4.js";
 import "./chunk-F6C3GFKV.js";
 import {
   logger

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   rewriteRootArgvToRun
-} from "./chunk-NDIGZXFF.js";
-import "./chunk-B5CH47OS.js";
+} from "./chunk-3XKVQS2K.js";
+import "./chunk-ESNAFDYT.js";
 import "./chunk-WGLPZXNU.js";
 import "./chunk-MAPOQEA2.js";
 import {
@@ -213,13 +213,13 @@ var main = defineCommand({
     version: KIT_VERSION
   },
   subCommands: {
-    init: () => import("./init-7T6KNDFE.js").then((m) => m.initCommand),
-    install: () => import("./install-6G3D7J4U.js").then((m) => m.installCommand),
-    scan: () => import("./scan-3MIUE7OR.js").then((m) => m.scanCommand),
+    init: () => import("./init-GVVBA2BM.js").then((m) => m.initCommand),
+    install: () => import("./install-R4HPI7VK.js").then((m) => m.installCommand),
+    scan: () => import("./scan-K6TQGV4S.js").then((m) => m.scanCommand),
     add: () => import("./add-YTCDLPUS.js").then((m) => m.addCommand),
-    doctor: () => import("./doctor-MQAXOFKM.js").then((m) => m.doctorCommand),
+    doctor: () => import("./doctor-SS6Y2T6H.js").then((m) => m.doctorCommand),
     "setup-global": () => import("./setup-global-AT4DD3MG.js").then((m) => m.setupGlobalCommand),
-    status: () => import("./status-MXNTBKPL.js").then((m) => m.statusCommand),
+    status: () => import("./status-MPJHI5RP.js").then((m) => m.statusCommand),
     update: () => import("./update-P62637ZI.js").then((m) => m.updateCommand),
     "cursor-awareness": () => import("./cursor-awareness-TN5JXD2C.js").then((m) => m.cursorAwarenessCommand),
     "public-inbound-radar": () => import("./public-inbound-radar-5U4JMBRU.js").then((m) => m.publicInboundRadarCommand),
@@ -229,12 +229,12 @@ var main = defineCommand({
     contribute: () => import("./contribute-A7NCWTUM.js").then((m) => m.contributeCommand),
     handoff: () => import("./handoff-MK5JG3J5.js").then((m) => m.handoffCommand),
     "plan-index": () => import("./plan-index-V7T5MKL6.js").then((m) => m.planIndexCommand),
-    run: () => import("./run-MWOI7UW5.js").then((m) => m.runCommand),
-    "run-plan": () => import("./run-plan-UWQD3BIJ.js").then((m) => m.runPlanCommand),
-    "run-plan-all": () => import("./run-MWOI7UW5.js").then((m) => m.runPlanAllCommand),
-    dashboard: () => import("./dashboard-YSNUGBFY.js").then((m) => m.dashboardCommand),
-    "dashboard-broadcast": () => import("./dashboard-broadcast-M4CMW7RX.js").then((m) => m.dashboardBroadcastCommand),
-    "mission-control": () => import("./mission-control-LJACEVVN.js").then((m) => m.missionControlCommand),
+    run: () => import("./run-3B26CVIL.js").then((m) => m.runCommand),
+    "run-plan": () => import("./run-plan-APTBO2OT.js").then((m) => m.runPlanCommand),
+    "run-plan-all": () => import("./run-3B26CVIL.js").then((m) => m.runPlanAllCommand),
+    dashboard: () => import("./dashboard-YNCFISNO.js").then((m) => m.dashboardCommand),
+    "dashboard-broadcast": () => import("./dashboard-broadcast-NK7PU72L.js").then((m) => m.dashboardBroadcastCommand),
+    "mission-control": () => import("./mission-control-MHQU73XC.js").then((m) => m.missionControlCommand),
     hook: () => import("./hook-D2WHBKRN.js").then((m) => m.hookCommand),
     guard: () => import("./guard-EHXF76ID.js").then((m) => m.guardCommand),
     monitors: () => import("./monitors-PDXBLB3U.js").then((m) => m.monitorsCommand),

package/dist/{init-7T6KNDFE.js → init-GVVBA2BM.js}

@@ -2,7 +2,7 @@ import {
   nextStepAfterInstall,
   performInstall,
   printInstallEpilogue
-} from "./chunk-WFXHMP47.js";
+} from "./chunk-TMFOLRU2.js";
 import {
   NON_INTERACTIVE_ROOT_ARGS
 } from "./chunk-DBXDV5O7.js";
@@ -11,7 +11,7 @@ import {
   logApplyStats
 } from "./chunk-HS7LVVLO.js";
 import "./chunk-3DGTPONS.js";
-import "./chunk-4U7DLAQH.js";
+import "./chunk-YP4OOK4T.js";
 import "./chunk-HAFRAXGV.js";
 import "./chunk-PPKX55GI.js";
 import "./chunk-WGLPZXNU.js";
@@ -20,7 +20,7 @@ import {
   withCliProgress
 } from "./chunk-QTON2GQX.js";
 import "./chunk-PNFF6OU3.js";
-import "./chunk-T6P5ZMG2.js";
+import "./chunk-U5F6RJN4.js";
 import "./chunk-F6C3GFKV.js";
 import {
   logger

package/dist/{install-6G3D7J4U.js → install-R4HPI7VK.js}

@@ -3,18 +3,18 @@ import {
   nextStepAfterInstall,
   performInstall,
   printInstallEpilogue
-} from "./chunk-WFXHMP47.js";
+} from "./chunk-TMFOLRU2.js";
 import "./chunk-DBXDV5O7.js";
 import "./chunk-HS7LVVLO.js";
 import "./chunk-3DGTPONS.js";
-import "./chunk-4U7DLAQH.js";
+import "./chunk-YP4OOK4T.js";
 import "./chunk-HAFRAXGV.js";
 import "./chunk-PPKX55GI.js";
 import "./chunk-WGLPZXNU.js";
 import "./chunk-MAPOQEA2.js";
 import "./chunk-QTON2GQX.js";
 import "./chunk-PNFF6OU3.js";
-import "./chunk-T6P5ZMG2.js";
+import "./chunk-U5F6RJN4.js";
 import "./chunk-F6C3GFKV.js";
 import "./chunk-ZB43YMHW.js";
 import "./chunk-GN4SAZF2.js";

package/dist/{mission-control-LJACEVVN.js → mission-control-MHQU73XC.js}

@@ -3,10 +3,10 @@ import {
   findDashboardDataScript,
   loadDashboardSnapshot,
   runMcTuiLoop
-} from "./chunk-PCCQUWE5.js";
+} from "./chunk-3LLXDHIU.js";
 import {
   resolveDashboardSnapshotRoot
-} from "./chunk-HFUH3HVS.js";
+} from "./chunk-XDCCYBCJ.js";
 import "./chunk-QTON2GQX.js";
 import {
   logger

package/dist/{run-MWOI7UW5.js → run-3B26CVIL.js}

@@ -1,12 +1,17 @@
 import {
+  LAND_ON_GATE_DESCRIPTION,
+  classifyGateExit,
   detectAgentBackend,
+  landGateExit,
   listDetectBackendIds,
   runPlanLoop,
   shouldUseLiveTui,
   withLiveTui
-} from "./chunk-PAB35H27.js";
-import "./chunk-PCCQUWE5.js";
-import "./chunk-HFUH3HVS.js";
+} from "./chunk-OZYJUNAQ.js";
+import "./chunk-3LLXDHIU.js";
+import {
+  negatedFlag
+} from "./chunk-XDCCYBCJ.js";
 import "./chunk-WUWRGOUV.js";
 import {
   buildDispatchPrompt,
@@ -17,13 +22,13 @@ import {
   readCommandFile,
   runHeadlessDispatch,
   unknownSlashMessage
-} from "./chunk-NDIGZXFF.js";
+} from "./chunk-3XKVQS2K.js";
 import {
   HITL_UNANSWERED_EXIT_CODE,
   formatHitlSummary,
   getBackend,
   hitlExitCode
-} from "./chunk-B5CH47OS.js";
+} from "./chunk-ESNAFDYT.js";
 import "./chunk-WGLPZXNU.js";
 import "./chunk-MAPOQEA2.js";
 import "./chunk-QTON2GQX.js";
@@ -82,7 +87,8 @@ async function executeRun(input) {
       dryRun: false,
       backend,
       noHitl: input.noHitl === true,
-      plain: input.plain === true
+      plain: input.plain === true,
+      landOnGate: input.landOnGate === true
     });
     return { exitCode: code };
   }
@@ -129,7 +135,37 @@ async function executeRun(input) {
       hitl: { policy: input.noHitl ? "off" : "prompt" }
     });
     for (const line of formatHitlSummary(result.hitl)) console.log(line);
-    return { exitCode: hitlExitCode(result.exitCode, result.hitl) };
+    const exitCode = hitlExitCode(result.exitCode, result.hitl);
+    const trigger = input.landOnGate ? classifyGateExit({ stop: result.hitl?.stop, failed: exitCode !== 0 }) : null;
+    if (trigger) {
+      const stop = result.hitl?.stop;
+      const summary = result.lastResult?.resultText.trim() || result.lastResult?.assistantTexts.at(-1)?.trim() || void 0;
+      try {
+        await landGateExit({
+          root,
+          outcome: {
+            trigger,
+            exitCode,
+            reason: stop?.message ?? `${detected.id} exited with code ${exitCode}`,
+            command: `run ${slash}`,
+            backend: detected.id,
+            logPath,
+            ...stop ? { askId: stop.askId } : {},
+            ...summary ? { summary } : {},
+            ...result.lastResult ? {
+              gateText: [
+                result.lastResult.resultText,
+                ...result.lastResult.assistantTexts
+              ].join("\n")
+            } : {}
+          },
+          log: (line) => console.log(line)
+        });
+      } catch (err) {
+        console.log(`gate-exit: landing failed: ${String(err)}`);
+      }
+    }
+    return { exitCode };
   } catch (err) {
     return { exitCode: 1, error: String(err) };
   }
@@ -174,6 +210,11 @@ var runDispatchArgs = {
     type: "boolean",
     description: "Status lines instead of the Mission Control live view (the default on a TTY; non-TTY, NO_COLOR and CI are always plain)",
     default: false
+  },
+  "land-on-gate": {
+    type: "boolean",
+    description: LAND_ON_GATE_DESCRIPTION,
+    default: false
   }
 };
 async function runSlashCli(slash, args) {
@@ -197,8 +238,9 @@ async function runSlashCli(slash, args) {
     dryRun: Boolean(args["dry-run"]),
     maxTicks,
     sleepSeconds,
-    noHitl: Boolean(args["no-hitl"]),
-    plain: Boolean(args.plain)
+    noHitl: negatedFlag(args, "hitl"),
+    plain: Boolean(args.plain),
+    landOnGate: Boolean(args["land-on-gate"])
   });
   if (result.stdout) {
     console.log(result.stdout);

package/dist/{run-plan-UWQD3BIJ.js → run-plan-APTBO2OT.js}

@@ -1,16 +1,19 @@
 import {
   DRIVER_EVENTS_FORMATS,
+  LAND_ON_GATE_DESCRIPTION,
   detectAgentBackend,
   listDetectBackendIds,
   runPlanLoop
-} from "./chunk-PAB35H27.js";
-import "./chunk-PCCQUWE5.js";
-import "./chunk-HFUH3HVS.js";
+} from "./chunk-OZYJUNAQ.js";
+import "./chunk-3LLXDHIU.js";
+import {
+  negatedFlag
+} from "./chunk-XDCCYBCJ.js";
 import "./chunk-WUWRGOUV.js";
 import {
   HITL_UNANSWERED_EXIT_CODE,
   getBackend
-} from "./chunk-B5CH47OS.js";
+} from "./chunk-ESNAFDYT.js";
 import "./chunk-WGLPZXNU.js";
 import "./chunk-MAPOQEA2.js";
 import "./chunk-QTON2GQX.js";
@@ -74,6 +77,11 @@ var runPlanCommand = defineCommand({
       description: "Driver mode for apps: `ndjson` writes only NDJSON events to stdout and reads HITL answers as JSON lines on stdin (no TTY needed; see docs/driver-events-protocol.md)",
       default: ""
     },
+    "land-on-gate": {
+      type: "boolean",
+      description: LAND_ON_GATE_DESCRIPTION,
+      default: false
+    },
     plain: {
       type: "boolean",
       description: "Status lines instead of the Mission Control live view (the default on a TTY; non-TTY, NO_COLOR and CI are always plain)",
@@ -136,8 +144,9 @@ var runPlanCommand = defineCommand({
       model: args.model ? String(args.model) : void 0,
       dryRun: Boolean(args["dry-run"]),
       backend,
-      noHitl: Boolean(args["no-hitl"]),
+      noHitl: negatedFlag(args, "hitl"),
       plain: Boolean(args.plain),
+      landOnGate: Boolean(args["land-on-gate"]),
       ...events ? { events: {} } : {},
       ...onLimit ? { onLimit } : {}
     });

package/dist/{scan-3MIUE7OR.js → scan-K6TQGV4S.js}

@@ -1,6 +1,6 @@
 import {
   runScanner
-} from "./chunk-T6P5ZMG2.js";
+} from "./chunk-U5F6RJN4.js";
 import "./chunk-F6C3GFKV.js";
 import {
   logger

package/dist/{status-MXNTBKPL.js → status-MPJHI5RP.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-PNFF6OU3.js";
 import {
   runScanner
-} from "./chunk-T6P5ZMG2.js";
+} from "./chunk-U5F6RJN4.js";
 import "./chunk-F6C3GFKV.js";
 import {
   logger

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dadado/agent-kit-cli",
-  "version": "6.0.0",
+  "version": "6.1.1",
   "description": "Agent Kit CLI: HITL framework install and tooling for AI-assisted IDEs (rules, skills, plan/handoff, context).",
   "license": "Apache-2.0",
   "type": "module",