@dadado/agent-kit-cli 6.1.0 → 6.2.0

package/dist/{chunk-TPCCSWK6.js → chunk-YRFSTHR5.js}

@@ -1,30 +1,29 @@
+import {
+  classifyGateExit,
+  landGateExit
+} from "./chunk-KVY425NM.js";
 import {
   InputLine,
   ScrollRegion,
   renderMcLive,
   runMcTuiLoop
-} from "./chunk-PCCQUWE5.js";
+} from "./chunk-3LLXDHIU.js";
 import {
   extractHandoffNamedPlans,
   namedPlanCandidatePaths,
   parsePlanFrontmatter
-} from "./chunk-WUWRGOUV.js";
+} from "./chunk-L5V3W3DY.js";
 import {
   LineSplitter,
   RedactingStreamBuffer,
   claudeRedactions,
-  findHitlGateInText,
   formatHitlGateLine,
   formatHitlSummary,
   operatorQuitStop,
   parseStreamLine,
   redactSecrets,
-  renderStreamEvent,
-  whichBinary
-} from "./chunk-ESNAFDYT.js";
-import {
-  findOnPath
-} from "./chunk-WGLPZXNU.js";
+  renderStreamEvent
+} from "./chunk-JEI6HACW.js";
 import {
   TtySpinner,
   shouldUseVisualMotion,
@@ -39,7 +38,7 @@ import {
   STATE_ROOT_ENV,
   ensureLoopLogsDir,
   runnerStatePaths
-} from "./chunk-C26I6HTO.js";
+} from "./chunk-C4Q77GGJ.js";
 import {
   fileExists,
   readJson
@@ -492,496 +491,6 @@ async function withLiveTui(opts, run) {
   }
 }
 
-// src/plan-loop/detect.ts
-var DETECT_ORDER = ["cursor-agent", "claude"];
-var EXPLICIT_ONLY_BACKENDS = ["codex", "cursor-acp"];
-var INSTALL_HINTS = {
-  "cursor-agent": "Install the Cursor Agent CLI and ensure `cursor-agent` is on PATH (https://cursor.com/docs/cli).",
-  claude: "Install Claude Code and ensure `claude` is on PATH (https://code.claude.com/docs/en/quickstart).",
-  "cursor-acp": "Install the Cursor Agent CLI and ensure `cursor-agent` is on PATH (https://cursor.com/docs/cli/acp); sign in with `cursor-agent login`.",
-  codex: "Install the Codex CLI and ensure `codex` is on PATH (https://developers.openai.com/codex/cli)."
-};
-function isBackendId(id) {
-  return id === "cursor-agent" || id === "claude" || id === "codex" || id === "cursor-acp";
-}
-function isRequestedBackend(id) {
-  return id === "auto" || isBackendId(id);
-}
-function listDetectBackendIds() {
-  return ["auto", ...DETECT_ORDER, ...EXPLICIT_ONLY_BACKENDS];
-}
-async function detectAgentBackend(requested, whichFn = whichBinary) {
-  const id = requested.trim().toLowerCase();
-  if (id === "glm" || id.startsWith("glm-") || id === "glm4") {
-    return {
-      ok: false,
-      message: "No documented GLM CLI binary is registered. Refusing a stub that would claim to work. Use --backend auto, cursor-agent, or claude."
-    };
-  }
-  if (!isRequestedBackend(id)) {
-    return {
-      ok: false,
-      message: `Unknown backend '${requested}'. Supported: ${listDetectBackendIds().join(", ")}.`
-    };
-  }
-  if (id === "auto") {
-    for (const candidate of DETECT_ORDER) {
-      const bin2 = await whichFn(candidate);
-      if (bin2) return { ok: true, id: candidate, bin: bin2 };
-    }
-    return {
-      ok: false,
-      message: [
-        "No agent CLI found on PATH (tried: cursor-agent, claude).",
-        INSTALL_HINTS["cursor-agent"],
-        INSTALL_HINTS.claude
-      ].join(" ")
-    };
-  }
-  const bin = await whichFn(id);
-  if (!bin) {
-    return { ok: false, message: `${id} not found on PATH. ${INSTALL_HINTS[id]}` };
-  }
-  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";
@@ -1195,14 +704,14 @@ var DriverAgentSink = class {
 };
 
 // src/plan-loop/run-loop.ts
-import { readFile as readFile5, rm as rm2, unlink } from "fs/promises";
-import path6 from "path";
+import { readFile as readFile4, rm, unlink } from "fs/promises";
+import path5 from "path";
 
 // src/plan-loop/external-review.ts
 import { spawn } from "child_process";
-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");
+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");
 function isPlanExhaustedReason(reason) {
   const r = reason.trim().toLowerCase();
   if (!r) return false;
@@ -1224,8 +733,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 = path4.join(root, CANONICAL_REL);
-  const fallbackPath = path4.join(root, FALLBACK_REL);
+  const canonicalPath = path3.join(root, CANONICAL_REL);
+  const fallbackPath = path3.join(root, FALLBACK_REL);
   let scriptPath = null;
   let scriptRel = CANONICAL_REL;
   if (await existsFn(canonicalPath)) {
@@ -1292,7 +801,7 @@ async function armExternalPlanReview(root, options = {}) {
 }
 
 // src/plan-loop/persona-banners.ts
-import path5 from "path";
+import path4 from "path";
 import {
   blue,
   cyan,
@@ -1328,7 +837,7 @@ function resolveColor(name, fallback) {
 async function resolveCliPersonaId(root) {
   try {
     const cfg = await readJson(
-      path5.join(root, ".cursor", "context", "config.json")
+      path4.join(root, ".cursor", "context", "config.json")
     );
     const modes = cfg?.agentPersona?.modes ?? cfg?.workspaceSkin?.modes;
     const id = modes?.[CLI_RUN_PLAN_MODE];
@@ -1339,7 +848,7 @@ async function resolveCliPersonaId(root) {
 }
 async function loadPersonaPack(root, personaId) {
   try {
-    const personaPath = path5.join(root, "registry", "personas", "core", personaId, "persona.json");
+    const personaPath = path4.join(root, "registry", "personas", "core", personaId, "persona.json");
     const pack = await readJson(personaPath);
     if (!pack || typeof pack.id !== "string") return null;
     return pack;
@@ -1388,7 +897,7 @@ function createPersonaBannerPrinter(persona) {
 }
 
 // src/plan-loop/sentinel.ts
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 var SENTINEL_RE = /LOOP_TICK_RESULT:\s*(continue|stop(?:\s*[—-].*)?)/i;
 function takeFromText(text) {
   if (!text) return null;
@@ -1457,14 +966,14 @@ function parseTickResultStatus(content) {
 }
 async function parseTickResultStatusFromLogFile(logPath) {
   try {
-    return parseTickResultStatus(await readFile4(logPath, "utf8"));
+    return parseTickResultStatus(await readFile3(logPath, "utf8"));
   } catch {
     return null;
   }
 }
 async function parseSentinelFromLogFile(logPath) {
   try {
-    const content = await readFile4(logPath, "utf8");
+    const content = await readFile3(logPath, "utf8");
     return parseSentinelFromLog(content);
   } catch {
     return { kind: "missing" };
@@ -1696,7 +1205,7 @@ async function runPlanLoop(opts) {
     return finishRun(1, "no active plan", null);
   }
   const pending = async () => countPendingTodos(await readPlan(planPath));
-  landPlan = path6.basename(planPath);
+  landPlan = path5.basename(planPath);
   if (statePaths.invalid !== void 0) {
     say(
       `${STATE_ROOT_ENV}=${statePaths.invalid} is not supported (use .cursor or .agent-kit); using .cursor.`,
@@ -1733,12 +1242,12 @@ async function runPlanLoop(opts) {
       type: "run_start",
       protocol: DRIVER_PROTOCOL_VERSION,
       backend: opts.backend.id,
-      plan: path6.basename(planPath),
+      plan: path5.basename(planPath),
       pending: pendingAtStart,
       maxTicks: opts.maxTicks,
       hitl: opts.noHitl ? "off" : "driver"
     });
-    say(`Active plan: ${path6.basename(planPath)}`);
+    say(`Active plan: ${path5.basename(planPath)}`);
     say(`Pending to-dos: ${pendingAtStart} | max ticks: ${opts.maxTicks}`);
     say(`Backend: ${opts.backend.id}`);
     if (persona) {
@@ -1775,7 +1284,7 @@ async function runPlanLoop(opts) {
         else say(msg);
         endReason = "stop file found";
         try {
-          await rm2(stopFile, { force: true });
+          await rm(stopFile, { force: true });
         } catch {
         }
         break;
@@ -1787,10 +1296,10 @@ async function runPlanLoop(opts) {
         endReason = "plan exhausted";
         break;
       }
-      const logPath = path6.join(logDir, `tick-${stamp()}.log`);
+      const logPath = path5.join(logDir, `tick-${stamp()}.log`);
       landLogPath = logPath;
       landBackend = backend.id;
-      const relLog = path6.relative(opts.root, logPath);
+      const relLog = path5.relative(opts.root, logPath);
       if (!driver) console.log("");
       const tickLine = `=== tick ${tick}/${opts.maxTicks} - pending: ${before} - log: ${relLog} ===`;
       if (banners) banners.tickStart(tickLine);
@@ -1884,7 +1393,7 @@ async function runPlanLoop(opts) {
       }
       let logText = "";
       try {
-        logText = await readFile5(logPath, "utf8");
+        logText = await readFile4(logPath, "utf8");
       } catch {
       }
       limit = detectUsageLimit(logText);
@@ -1998,7 +1507,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 ${path6.relative(opts.root, logDir)}/`
+      `Loop finished after ${tick} tick(s). Pending now: ${pendingNow}. Logs in ${path5.relative(opts.root, logDir)}/`
     );
     if (planExhausted || shouldArmExternalPlanReview({ pending: pendingNow, stopReason })) {
       await armExternalPlanReview(
@@ -2016,11 +1525,6 @@ async function runPlanLoop(opts) {
 export {
   shouldUseLiveTui,
   withLiveTui,
-  listDetectBackendIds,
-  detectAgentBackend,
-  LAND_ON_GATE_DESCRIPTION,
-  classifyGateExit,
-  landGateExit,
   DRIVER_EVENTS_FORMATS,
   runPlanLoop
 };