@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-TFZ2JUXH.js

@@ -0,0 +1,1081 @@
+import {
+  InputLine,
+  ScrollRegion,
+  renderMcLive,
+  runMcTuiLoop
+} from "./chunk-PCCQUWE5.js";
+import {
+  extractHandoffNamedPlans,
+  namedPlanCandidatePaths,
+  parsePlanFrontmatter
+} from "./chunk-KD2MYBB6.js";
+import {
+  LineSplitter,
+  RedactingStreamBuffer,
+  claudeRedactions,
+  formatHitlSummary,
+  operatorQuitStop,
+  parseStreamLine,
+  redactSecrets,
+  renderStreamEvent,
+  whichBinary
+} from "./chunk-OUQZC744.js";
+import {
+  TtySpinner,
+  shouldUseVisualMotion,
+  shouldUseWelcomeColor,
+  withCliProgress
+} from "./chunk-QTON2GQX.js";
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+import {
+  HANDOFF_REL
+} from "./chunk-5VCOWTTP.js";
+import {
+  fileExists,
+  readJson
+} from "./chunk-77V75A7O.js";
+
+// src/mission-control/live-run.ts
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+
+// src/plan-loop/plan-state.ts
+import { readFile, readdir } from "fs/promises";
+import path from "path";
+function countPendingTodos(raw) {
+  return parsePlanFrontmatter(raw).todos.filter(
+    (t) => (t.status === "pending" || t.status === "in_progress") && t.id !== "dogfood-poc"
+  ).length;
+}
+async function findActivePlanFile(plansDir) {
+  if (!await fileExists(plansDir)) return null;
+  const files = (await readdir(plansDir)).filter((f) => f.endsWith(".plan.md")).sort();
+  return files[0] ? path.join(plansDir, files[0]) : null;
+}
+async function readPlan(planPath) {
+  return readFile(planPath, "utf8");
+}
+var QUEUE_CURSOR_RE = /^- \*\*Queue cursor:\*\*\s*(.+)$/m;
+var QUEUE_STATUS_RE = /^- \*\*Queue status:\*\*\s*(.+)$/m;
+var QUEUE_DONE_STATUSES = /* @__PURE__ */ new Set(["exhausted", "completed", "done"]);
+function readRunQueueState(handoff) {
+  const queue = extractHandoffNamedPlans(handoff).runQueue;
+  let cursorIndex = null;
+  let cursorPlan = null;
+  const cursorRaw = QUEUE_CURSOR_RE.exec(handoff)?.[1]?.trim() ?? "";
+  const indexMatch = /^(\d+)\b/.exec(cursorRaw);
+  if (indexMatch?.[1]) cursorIndex = Number(indexMatch[1]);
+  const currentMatch = /current:\s*`?([^`()]+?)`?\s*\)/i.exec(cursorRaw);
+  if (currentMatch?.[1]) {
+    const base = currentMatch[1].trim().split("/").pop() ?? "";
+    if (/\.plan\.md$/i.test(base)) cursorPlan = base;
+  }
+  const status = QUEUE_STATUS_RE.exec(handoff)?.[1]?.trim().split(/\s+/)[0]?.replace(/[`*]/g, "");
+  const queueStatus = status ? status : null;
+  const finished = queueStatus !== null && QUEUE_DONE_STATUSES.has(queueStatus.toLowerCase());
+  let cursor = null;
+  if (cursorIndex !== null && cursorIndex >= 0 && cursorIndex < queue.length) {
+    cursor = cursorIndex;
+  } else if (cursorPlan && queue.includes(cursorPlan)) {
+    cursor = queue.indexOf(cursorPlan);
+  }
+  const current = cursor !== null ? queue[cursor] ?? null : cursorPlan;
+  return { queue, cursor, current, status: queueStatus, finished };
+}
+function defaultPlanStateIo() {
+  return {
+    readFile: async (file) => {
+      try {
+        return await readFile(file, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    findActivePlan: findActivePlanFile
+  };
+}
+async function resolveActivePlanFromHandoff(root, handoff, io = defaultPlanStateIo()) {
+  const queue = readRunQueueState(handoff);
+  const base = (queue.queue.length > 0 && !queue.finished ? queue.current : null) ?? extractHandoffNamedPlans(handoff).active;
+  if (!base) return io.findActivePlan(path.join(root, ".cursor", "plans"));
+  for (const candidate of namedPlanCandidatePaths(root, base)) {
+    if (await io.readFile(candidate) !== null) return candidate;
+  }
+  return null;
+}
+async function resolveActivePlanPath(root, io = defaultPlanStateIo()) {
+  const handoff = await io.readFile(path.join(root, HANDOFF_REL)) ?? "";
+  return resolveActivePlanFromHandoff(root, handoff, io);
+}
+
+// src/mission-control/live-feed.ts
+import { StringDecoder } from "string_decoder";
+var LIVE_LOG_CAPACITY = 500;
+var LiveRunFeed = class {
+  log;
+  crew;
+  gate = null;
+  hitlReplies = 0;
+  lines = new LineSplitter();
+  decoder = new StringDecoder("utf8");
+  columns;
+  version = 0;
+  constructor(opts = {}) {
+    this.columns = Math.max(40, opts.columns ?? 80);
+    this.log = new ScrollRegion(opts.capacity ?? LIVE_LOG_CAPACITY);
+    this.crew = {
+      backend: opts.backend ?? null,
+      pid: void 0,
+      phase: "starting",
+      startedAt: (opts.now ?? Date.now)(),
+      toolCalls: 0,
+      currentTool: null,
+      lastResult: null,
+      rateLimit: null,
+      logPath: opts.logPath ?? null
+    };
+  }
+  /** Bumps on every change; a paint loop can skip a frame when nothing moved. */
+  get revision() {
+    return this.version;
+  }
+  setProcess(info) {
+    this.crew.backend = info.backend;
+    this.crew.pid = info.pid;
+    if (this.crew.phase === "starting") this.crew.phase = "running";
+    this.version += 1;
+  }
+  setPhase(phase) {
+    this.crew.phase = phase;
+    this.version += 1;
+  }
+  openGate(gate) {
+    this.gate = gate;
+    this.crew.phase = "gate";
+    this.version += 1;
+  }
+  closeGate() {
+    this.gate = null;
+    if (this.crew.phase === "gate") this.crew.phase = "running";
+    this.version += 1;
+  }
+  /** Append a status line the run lane produced itself (never from the stream). */
+  note(text, kind = "note") {
+    for (const line of text.split(/\r?\n/)) {
+      const trimmed = line.trimEnd();
+      if (trimmed) this.log.push({ kind, text: trimmed });
+    }
+    this.version += 1;
+  }
+  feed(chunk) {
+    try {
+      const text = typeof chunk === "string" ? chunk : this.decoder.write(chunk);
+      if (!text) return;
+      this.lines.feed(text, (line) => this.takeLine(line));
+    } catch {
+    }
+  }
+  end() {
+    try {
+      this.lines.feed(this.decoder.end(), (line) => this.takeLine(line));
+      const rest = this.lines.end();
+      if (rest) this.takeLine(rest);
+      this.crew.currentTool = null;
+      if (this.crew.phase !== "done") this.crew.phase = "done";
+      this.version += 1;
+    } catch {
+    }
+  }
+  takeLine(line) {
+    for (const event of parseStreamLine(line)) {
+      const rendered = renderStreamEvent(event, { color: false, columns: this.columns });
+      if (rendered === null) continue;
+      switch (event.kind) {
+        case "text":
+          this.note(rendered, "text");
+          break;
+        case "tool_use":
+          this.crew.toolCalls += 1;
+          this.crew.currentTool = { name: event.name, summary: event.summary };
+          this.note(rendered, "tool");
+          break;
+        case "tool_result":
+          this.crew.currentTool = null;
+          this.note(rendered, event.ok ? "tool" : "error");
+          break;
+        case "result":
+          this.crew.currentTool = null;
+          this.crew.lastResult = { ok: event.ok, status: event.status };
+          if (event.costUsd !== void 0) this.crew.costUsd = event.costUsd;
+          if (event.turns !== void 0) this.crew.turns = event.turns;
+          this.note(rendered, event.ok ? "result" : "error");
+          break;
+        case "hook":
+          this.note(rendered, "hook");
+          break;
+        case "rate_limit":
+          this.crew.rateLimit = { line: event.line, severe: event.severe };
+          this.note(rendered, "rate_limit");
+          break;
+        case "prompt":
+          this.note(rendered, "prompt");
+          break;
+        case "hitl_reply":
+          this.hitlReplies += 1;
+          this.note(rendered, "hitl");
+          break;
+        default:
+          break;
+      }
+    }
+  }
+};
+function emptyLiveMission() {
+  return {
+    planFile: null,
+    mode: null,
+    todos: { done: 0, total: 0 },
+    currentTodo: null,
+    nextTodo: null,
+    queue: null
+  };
+}
+
+// src/mission-control/live-run.ts
+var LIVE_FRAME_MS = 120;
+var LIVE_PROGRESS_TTL_MS = 2e3;
+function shouldUseLiveTui(opts = {}) {
+  if (opts.plain) return false;
+  const env = opts.env ?? process.env;
+  const stdoutIsTTY = opts.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
+  const stdinIsTTY = opts.stdinIsTTY ?? Boolean(process.stdin.isTTY);
+  if (!stdoutIsTTY || !stdinIsTTY) return false;
+  return shouldUseWelcomeColor({ stdoutIsTTY, env });
+}
+function defaultMissionIo() {
+  return {
+    readFile: async (file) => {
+      try {
+        return await readFile2(file, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    findActivePlan: findActivePlanFile
+  };
+}
+var MODE_RE = /^- \*\*Mode:\*\*\s*(.+)$/m;
+function firstWord(raw) {
+  const word = raw?.trim().split(/\s+/)[0]?.replace(/[`*]/g, "");
+  return word ? word : null;
+}
+async function readLiveMission(root, io = defaultMissionIo()) {
+  const mission = emptyLiveMission();
+  const handoff = await io.readFile(path2.join(root, HANDOFF_REL)) ?? "";
+  mission.mode = firstWord(MODE_RE.exec(handoff)?.[1]);
+  const { queue, cursor, current, status: queueStatus, finished } = readRunQueueState(handoff);
+  let checklist = [];
+  if (queue.length > 0) {
+    const done = finished ? queue.length : cursor ?? 0;
+    mission.queue = {
+      done,
+      total: queue.length,
+      current,
+      status: queueStatus
+    };
+    checklist = queue.map((file, i) => ({
+      label: file,
+      state: finished || cursor !== null && i < cursor ? "done" : i === cursor ? "current" : "pending"
+    }));
+  }
+  const planPath = await resolveActivePlanFromHandoff(root, handoff, io);
+  if (planPath) {
+    const raw = await io.readFile(planPath);
+    if (raw !== null) {
+      mission.planFile = path2.basename(planPath);
+      const { todos } = parsePlanFrontmatter(raw);
+      const open = todos.filter((t) => t.status !== "cancelled");
+      mission.todos = {
+        done: open.filter((t) => t.status === "completed").length,
+        total: open.length
+      };
+      mission.currentTodo = todos.find((t) => t.status === "in_progress")?.id ?? null;
+      mission.nextTodo = todos.find((t) => t.status === "pending")?.id ?? null;
+      if (checklist.length === 0) {
+        checklist = open.map((t) => ({
+          label: t.id,
+          state: t.status === "completed" ? "done" : t.status === "in_progress" ? "current" : "pending"
+        }));
+        const current2 = checklist.findIndex((row) => row.state === "current");
+        if (current2 > 1) checklist = checklist.slice(current2 - 1);
+      }
+    }
+  }
+  return { mission, checklist };
+}
+function createLiveMissionLoader(root, opts = {}) {
+  const ttl = opts.ttlMs ?? LIVE_PROGRESS_TTL_MS;
+  const now = opts.now ?? Date.now;
+  let cached = null;
+  let readAt = Number.NEGATIVE_INFINITY;
+  let inFlight = null;
+  return async () => {
+    if (cached && now() - readAt < ttl) return cached;
+    if (inFlight) return inFlight;
+    inFlight = readLiveMission(root, opts.io).then((state) => {
+      cached = state;
+      readAt = now();
+      return state;
+    }).catch(() => {
+      cached = cached ?? { mission: emptyLiveMission(), checklist: [] };
+      readAt = now();
+      return cached;
+    }).finally(() => {
+      inFlight = null;
+    });
+    return cached ?? inFlight;
+  };
+}
+async function withLiveTui(opts, run) {
+  const write = opts.write ?? ((chunk) => process.stdout.write(chunk));
+  const stdin = opts.stdin ?? process.stdin;
+  const env = opts.env ?? process.env;
+  const now = opts.now ?? Date.now;
+  const columns = opts.columns ?? process.stdout.columns ?? 80;
+  const rows = opts.rows ?? process.stdout.rows ?? 24;
+  const feed = new LiveRunFeed({
+    columns,
+    now,
+    backend: opts.backend,
+    logPath: path2.relative(opts.root, opts.logPath) || opts.logPath
+  });
+  opts.onFeed?.(feed);
+  const missionLoader = opts.missionLoader ?? createLiveMissionLoader(opts.root, { now });
+  const input = new InputLine();
+  let pending = null;
+  let spawnInfo = null;
+  let quitRequested = null;
+  let handle = null;
+  const repaint = () => {
+    void handle?.repaint();
+  };
+  const settleGate = (answer) => {
+    const open = pending;
+    if (!open) return;
+    pending = null;
+    feed.closeGate();
+    open.settle(answer);
+  };
+  const readAnswer = (gate, readOpts) => new Promise((resolve) => {
+    const onAbort = () => settleGate({ kind: "eof" });
+    if (readOpts.signal?.aborted) {
+      resolve({ kind: "eof" });
+      return;
+    }
+    input.reset();
+    pending = {
+      gate,
+      settle: (answer) => {
+        readOpts.signal?.removeEventListener("abort", onAbort);
+        resolve(answer);
+      }
+    };
+    readOpts.signal?.addEventListener("abort", onAbort, { once: true });
+    feed.openGate(gate);
+    repaint();
+  });
+  const stopRun = (stop) => {
+    if (pending) {
+      settleGate({ kind: "sigint" });
+      return;
+    }
+    if (quitRequested) return;
+    quitRequested = stop;
+    feed.setPhase("stopping");
+    feed.note(stop.message);
+    spawnInfo?.stop(stop);
+  };
+  const hooks = {
+    write,
+    stdin,
+    now,
+    setIntervalFn: opts.setIntervalFn,
+    clearIntervalFn: opts.clearIntervalFn,
+    onKey: (chunk) => {
+      if (!pending) return false;
+      const result = input.handleKey(chunk);
+      if (result === "submit") settleGate({ kind: "line", text: input.value });
+      else if (result === "sigint") settleGate({ kind: "sigint" });
+      else if (result === "eof") settleGate({ kind: "eof" });
+      else if (result === "edit") repaint();
+      return true;
+    },
+    onQuit: (key) => {
+      write("\n");
+      stopRun(operatorQuitStop(key));
+    }
+  };
+  const loadView = async () => {
+    const state = await missionLoader();
+    return {
+      mission: state.mission,
+      checklist: state.checklist,
+      gate: pending ? {
+        askId: pending.gate.askId,
+        labels: pending.gate.labels,
+        detection: pending.gate.detection,
+        input
+      } : null,
+      flightLog: feed.log,
+      crew: feed.crew,
+      error: null
+    };
+  };
+  const seams = {
+    render: feed,
+    log: (line) => feed.note(line),
+    onSpawn: (info) => {
+      spawnInfo = info;
+      feed.setProcess({ backend: info.backend, pid: info.pid });
+      if (quitRequested) info.stop(quitRequested);
+    },
+    hitl: {
+      policy: opts.noHitl ? "off" : "prompt",
+      isTTY: true,
+      readAnswer,
+      write: (text) => feed.note(text, "hitl")
+    }
+  };
+  const onSignal = (signal) => {
+    handle?.stop();
+    stopRun(operatorQuitStop(signal));
+  };
+  const onSigint = () => onSignal("SIGINT");
+  const onSigterm = () => onSignal("SIGTERM");
+  const signals = opts.signals ?? true;
+  if (signals) {
+    process.prependListener("SIGINT", onSigint);
+    process.prependListener("SIGTERM", onSigterm);
+  }
+  try {
+    handle = await runMcTuiLoop({
+      loadView,
+      render: (view, renderOpts) => renderMcLive(view, { ...renderOpts, columns, rows, now: now() }),
+      stdoutIsTTY: true,
+      env,
+      intervalMs: opts.intervalMs ?? LIVE_FRAME_MS,
+      renderOpts: { stdoutIsTTY: true, env, columns },
+      hooks
+    });
+    const result = await run(seams);
+    feed.setPhase("done");
+    if (handle) await handle.repaint();
+    return result;
+  } finally {
+    if (pending) settleGate({ kind: "eof" });
+    handle?.stop();
+    if (signals) {
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+    }
+    write("\n");
+  }
+}
+
+// src/plan-loop/detect.ts
+var DETECT_ORDER = ["cursor-agent", "claude"];
+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)."
+};
+function isBackendId(id) {
+  return id === "cursor-agent" || id === "claude";
+}
+function isRequestedBackend(id) {
+  return id === "auto" || isBackendId(id);
+}
+function listDetectBackendIds() {
+  return ["auto", ...DETECT_ORDER];
+}
+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/run-loop.ts
+import { mkdir, readFile as readFile4, rm, unlink } from "fs/promises";
+import path5 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");
+function isPlanExhaustedReason(reason) {
+  const r = reason.trim().toLowerCase();
+  if (!r) return false;
+  if (r.includes("plan exhausted")) return true;
+  if (r.includes("nothing to do")) return true;
+  if (r.includes("no implementable")) return true;
+  if (/\ball\s+(implementable\s+)?to-?dos?\b/.test(r) && (r.includes("completed") || r.includes("done") || r.includes("exhausted"))) {
+    return true;
+  }
+  return false;
+}
+function shouldArmExternalPlanReview(input) {
+  if (input.pending === 0) return true;
+  if (input.stopReason && isPlanExhaustedReason(input.stopReason)) return true;
+  return false;
+}
+async function armExternalPlanReview(root, options = {}) {
+  const spawnFn = options.spawnFn ?? spawn;
+  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);
+  let scriptPath = null;
+  let scriptRel = CANONICAL_REL;
+  if (await existsFn(canonicalPath)) {
+    scriptPath = canonicalPath;
+    scriptRel = CANONICAL_REL;
+  } else if (await existsFn(fallbackPath)) {
+    scriptPath = fallbackPath;
+    scriptRel = FALLBACK_REL;
+  }
+  if (!scriptPath) {
+    log(
+      `tip: ${CANONICAL_REL} missing (optional wrapper: ${FALLBACK_REL}). Manual: /plan-external-review (enable externalPlanReview in .cursor/context/config.json).`
+    );
+    return { invoked: false, exitCode: null, output: "" };
+  }
+  log("Plan exhausted: arming optional external plan review (opt-in handled by script)...");
+  const args = force ? [scriptPath, "--force", "--print"] : [scriptPath, "--print"];
+  return new Promise((resolve) => {
+    const child = spawnFn("bash", args, {
+      cwd: root,
+      env: { ...process.env, AGENT_KIT_HEADLESS: "1" }
+    });
+    const redact = claudeRedactions(process.env);
+    const outBuffer = new RedactingStreamBuffer(redact);
+    const errBuffer = new RedactingStreamBuffer(redact);
+    let output = "";
+    const emitOut = (s) => {
+      if (!s) return;
+      output += s;
+      process.stdout.write(s);
+    };
+    const emitErr = (s) => {
+      if (!s) return;
+      output += s;
+      process.stderr.write(s);
+    };
+    let flushed = false;
+    const flush = () => {
+      if (flushed) return;
+      flushed = true;
+      emitOut(outBuffer.flush());
+      emitErr(errBuffer.flush());
+    };
+    child.stdout?.on("data", (chunk) => emitOut(outBuffer.push(chunk)));
+    child.stderr?.on("data", (chunk) => emitErr(errBuffer.push(chunk)));
+    child.on("error", (err) => {
+      flush();
+      log(
+        `tip: external plan review launcher failed (${redactSecrets(err.message, redact)}). Manual: ${scriptRel} or /plan-external-review`
+      );
+      resolve({ invoked: true, exitCode: null, output });
+    });
+    child.on("close", (code) => {
+      flush();
+      if (code !== 0 && code !== null) {
+        log(
+          `tip: external plan review exited ${code} (ignored; does not fail the loop). Manual: ${scriptRel} or /plan-external-review`
+        );
+      }
+      resolve({ invoked: true, exitCode: code, output });
+    });
+  });
+}
+
+// src/plan-loop/persona-banners.ts
+import path4 from "path";
+import {
+  blue,
+  cyan,
+  gray,
+  green,
+  lightGray,
+  lightGreen,
+  magenta,
+  red,
+  white,
+  yellow
+} from "kolorist";
+var CLI_RUN_PLAN_MODE = "cli-run-plan";
+var DEFAULT_CLI_PERSONA_ID = "ghost-runner";
+var COLORS = {
+  white,
+  gray,
+  green,
+  cyan,
+  magenta,
+  yellow,
+  red,
+  blue,
+  "light-green": lightGreen,
+  lightgreen: lightGreen,
+  "light-gray": lightGray,
+  lightgray: lightGray
+};
+function resolveColor(name, fallback) {
+  if (!name) return fallback;
+  return COLORS[name.toLowerCase()] ?? fallback;
+}
+async function resolveCliPersonaId(root) {
+  try {
+    const cfg = await readJson(
+      path4.join(root, ".cursor", "context", "config.json")
+    );
+    const modes = cfg?.agentPersona?.modes ?? cfg?.workspaceSkin?.modes;
+    const id = modes?.[CLI_RUN_PLAN_MODE];
+    if (typeof id === "string" && id.trim()) return id.trim();
+  } catch {
+  }
+  return DEFAULT_CLI_PERSONA_ID;
+}
+async function loadPersonaPack(root, personaId) {
+  try {
+    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;
+  } catch {
+    return null;
+  }
+}
+async function loadCliRunPlanPersona(root) {
+  const id = await resolveCliPersonaId(root);
+  return loadPersonaPack(root, id);
+}
+function createPersonaBannerPrinter(persona) {
+  if (!persona?.cliBanners) return null;
+  const banners = persona.cliBanners;
+  if (!banners.tickStart && !banners.tickEnd && !banners.phaseComplete) return null;
+  const primary = resolveColor(persona.ansiPalette?.primary, white);
+  const secondary = resolveColor(persona.ansiPalette?.secondary, gray);
+  const accent = resolveColor(persona.ansiPalette?.accent, green);
+  return {
+    tickStart(detail) {
+      if (banners.tickStart) {
+        console.log(`${accent(banners.tickStart)} ${primary(detail)}`);
+      } else {
+        console.log(primary(detail));
+      }
+    },
+    tickEnd(detail) {
+      if (!banners.tickEnd) return;
+      const line = detail ? `${banners.tickEnd} ${detail}` : banners.tickEnd;
+      console.log(secondary(line));
+    },
+    phaseComplete(detail) {
+      if (!banners.phaseComplete) return;
+      const line = detail ? `${banners.phaseComplete} ${detail}` : banners.phaseComplete;
+      console.log(accent(line));
+    },
+    sleep(seconds) {
+      console.log(secondary(`sleep ${seconds}s`));
+    },
+    stop(reason) {
+      if (banners.tickEnd) {
+        console.log(secondary(`${banners.tickEnd} ${reason}`));
+      }
+    }
+  };
+}
+
+// src/plan-loop/sentinel.ts
+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;
+  const m = SENTINEL_RE.exec(text);
+  if (!m?.[1]) return null;
+  const raw = m[1].trim();
+  if (raw.toLowerCase().startsWith("stop")) {
+    const reason = raw.slice(4).replace(/^[—\-\s]+/, "").trim() || "requested by agent";
+    return { kind: "stop", reason };
+  }
+  return { kind: "continue" };
+}
+function parseSentinelFromLog(content) {
+  let lastJson = null;
+  let lastText = null;
+  let sawJson = false;
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (!trimmed.startsWith("{")) {
+      const hit = takeFromText(trimmed);
+      if (hit) lastText = hit;
+      continue;
+    }
+    try {
+      const ev = JSON.parse(trimmed);
+      sawJson = true;
+      if (ev.type === "result" && typeof ev.result === "string") {
+        const hit = takeFromText(ev.result);
+        if (hit) lastJson = hit;
+      }
+      const parts = ev.type === "assistant" ? ev.message?.content : void 0;
+      if (Array.isArray(parts)) {
+        for (const part of parts) {
+          if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string") {
+            const hit = takeFromText(part.text);
+            if (hit) lastJson = hit;
+          }
+        }
+      }
+    } catch {
+      const hit = takeFromText(trimmed);
+      if (hit) lastText = hit;
+    }
+  }
+  return (sawJson ? lastJson : lastText) ?? { kind: "missing" };
+}
+function parseTickResultStatus(content) {
+  let last = null;
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      const ev = JSON.parse(trimmed);
+      if (ev.type !== "result") continue;
+      const errors = Array.isArray(ev.errors) ? ev.errors.filter((e) => typeof e === "string") : [];
+      last = {
+        isError: ev.is_error === true,
+        ...typeof ev.subtype === "string" ? { subtype: ev.subtype } : {},
+        errors
+      };
+    } catch {
+    }
+  }
+  return last;
+}
+async function parseTickResultStatusFromLogFile(logPath) {
+  try {
+    return parseTickResultStatus(await readFile3(logPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function parseSentinelFromLogFile(logPath) {
+  try {
+    const content = await readFile3(logPath, "utf8");
+    return parseSentinelFromLog(content);
+  } catch {
+    return { kind: "missing" };
+  }
+}
+function formatSentinelLine(sentinel) {
+  if (sentinel.kind === "continue") return "LOOP_TICK_RESULT: continue";
+  if (sentinel.kind === "stop") return `LOOP_TICK_RESULT: stop - ${sentinel.reason}`;
+  return "";
+}
+function sentinelFromTurn(turn) {
+  const fromResult = takeFromText(turn.resultText);
+  if (fromResult) return fromResult;
+  for (let i = turn.assistantTexts.length - 1; i >= 0; i--) {
+    const hit = takeFromText(turn.assistantTexts[i] ?? "");
+    if (hit) return hit;
+  }
+  return null;
+}
+function tickResultStatusFromTurn(turn) {
+  return {
+    isError: turn.isError,
+    ...turn.subtype !== null ? { subtype: turn.subtype } : {},
+    errors: turn.errors
+  };
+}
+async function resolveTickResultStatus(lastResult, logPath, fromFile = parseTickResultStatusFromLogFile) {
+  if (lastResult) return tickResultStatusFromTurn(lastResult);
+  return fromFile(logPath);
+}
+async function resolveTickSentinel(lastResult, logPath, fromFile = parseSentinelFromLogFile) {
+  const fromTurn = lastResult ? sentinelFromTurn(lastResult) : null;
+  return fromTurn ?? fromFile(logPath);
+}
+
+// src/plan-loop/run-loop.ts
+var TICK_PROMPT = '/run-plan - single tick from the headless runner (agent-kit run-plan). Read .cursor/HANDOFF.md and the active plan in .cursor/plans/. Mark the next to-do as in_progress in the frontmatter, execute ONLY that to-do, mark completed and update HANDOFF. If there is a commitable diff: run /git-staging without asking for confirmation. NEVER /git-prod. Do NOT re-arm an internal Loop skill - the external runner starts the next agent. End the response with exactly one line: "LOOP_TICK_RESULT: continue" if implementable to-dos remain, or "LOOP_TICK_RESULT: stop - <reason>" (plan exhausted, external blocker, or human decision needed).';
+async function runTickWithSpinner(label, backend, opts, plain) {
+  if (shouldUseLiveTui({ plain })) {
+    return withLiveTui(
+      {
+        root: opts.workspace,
+        backend: backend.id,
+        logPath: opts.logPath,
+        noHitl: opts.hitl?.policy === "off"
+      },
+      (seams) => backend.run({
+        ...opts,
+        hitl: seams.hitl,
+        render: seams.render,
+        onSpawn: seams.onSpawn,
+        log: seams.log
+      })
+    );
+  }
+  if (!shouldUseVisualMotion()) return backend.run(opts);
+  const spinner = new TtySpinner({ motion: true });
+  spinner.start(label);
+  try {
+    return await backend.run({
+      ...opts,
+      hitl: {
+        ...opts.hitl,
+        onPromptStart: () => spinner.stop(),
+        onPromptEnd: () => spinner.start(label)
+      }
+    });
+  } finally {
+    spinner.stop();
+  }
+}
+function stamp() {
+  const d = /* @__PURE__ */ new Date();
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}${p(d.getMilliseconds(), 3)}`;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function runPlanLoop(opts) {
+  const stopFile = path5.join(opts.root, ".cursor", "loop.stop");
+  const logDir = path5.join(opts.root, ".cursor", "loop-logs");
+  const planPath = await resolveActivePlanPath(opts.root);
+  if (!planPath) {
+    logger.error("No active plan in .cursor/plans/");
+    return 1;
+  }
+  const pending = async () => countPendingTodos(await readPlan(planPath));
+  await mkdir(logDir, { recursive: true });
+  try {
+    await unlink(stopFile);
+  } catch {
+  }
+  const onSigInt = () => {
+    console.log("");
+    console.log("Loop interrupted (Ctrl+C). State saved in HANDOFF by the last tick.");
+    process.exit(130);
+  };
+  process.on("SIGINT", onSigInt);
+  try {
+    const persona = await loadCliRunPlanPersona(opts.root);
+    const banners = createPersonaBannerPrinter(persona);
+    console.log(`Active plan: ${path5.basename(planPath)}`);
+    console.log(`Pending to-dos: ${await pending()} | max ticks: ${opts.maxTicks}`);
+    console.log(`Backend: ${opts.backend.id}`);
+    if (persona) {
+      console.log(`CLI persona: ${persona.displayName ?? persona.id}`);
+    }
+    if (opts.dryRun) {
+      console.log("--dry-run: no agent will be started. Tick prompt:");
+      console.log(TICK_PROMPT);
+      return 0;
+    }
+    const binary = await opts.backend.resolve();
+    if (!binary) {
+      logger.error(`${opts.backend.id} not found on PATH`);
+      return 1;
+    }
+    let tick = 0;
+    let stopReason;
+    let planExhausted = false;
+    let exitCode = 0;
+    while (true) {
+      tick += 1;
+      if (tick > opts.maxTicks) {
+        const msg = `Budget of ${opts.maxTicks} ticks reached - stopping. Run again to continue.`;
+        if (banners) banners.stop(msg);
+        else console.log(msg);
+        break;
+      }
+      if (await fileExists(stopFile)) {
+        const msg = `Stop file found (${stopFile}) - stopping.`;
+        if (banners) banners.stop(msg);
+        else console.log(msg);
+        try {
+          await rm(stopFile, { force: true });
+        } catch {
+        }
+        break;
+      }
+      const before = await pending();
+      if (before === 0) {
+        console.log("Plan exhausted (0 pending to-dos) - nothing to do.");
+        planExhausted = true;
+        break;
+      }
+      const logPath = path5.join(logDir, `tick-${stamp()}.log`);
+      const relLog = path5.relative(opts.root, logPath);
+      console.log("");
+      const tickLine = `=== tick ${tick}/${opts.maxTicks} - pending: ${before} - log: ${relLog} ===`;
+      if (banners) banners.tickStart(tickLine);
+      else console.log(tickLine);
+      let agentExit = 0;
+      let hitlStop;
+      let lastResult;
+      try {
+        const result = await runTickWithSpinner(
+          `tick ${tick}`,
+          opts.backend,
+          {
+            workspace: opts.root,
+            prompt: TICK_PROMPT,
+            model: opts.model,
+            logPath,
+            hitl: { policy: opts.noHitl ? "off" : "prompt" }
+          },
+          opts.plain === true
+        );
+        agentExit = result.exitCode;
+        for (const line of formatHitlSummary(result.hitl)) console.log(line);
+        hitlStop = result.hitl?.stop;
+        lastResult = result.lastResult;
+      } catch (err) {
+        logger.error(String(err));
+        return 1;
+      }
+      if (hitlStop) {
+        const msg = `${opts.backend.id} tick ended at a HITL gate without a reply - stopping. See log: ${relLog}`;
+        if (banners) {
+          banners.tickEnd("hitl stop");
+          banners.stop(msg);
+        } else {
+          console.log(msg);
+        }
+        exitCode = hitlStop.exitCode;
+        break;
+      }
+      try {
+        const logText = await readFile4(logPath, "utf8");
+        if (logText.includes("Too many MCP tools")) {
+          const msg = "Too many MCP tools for the headless model - disable servers (cursor-agent mcp disable <id>) and run again.";
+          if (banners) banners.stop(msg);
+          else console.log(msg);
+          break;
+        }
+      } catch {
+      }
+      const status = await resolveTickResultStatus(lastResult, logPath);
+      if (status?.isError) {
+        const detail = status.errors[0] ? `: ${status.errors[0].split("\n")[0]}` : "";
+        const msg = `${opts.backend.id} tick failed (${status.subtype ?? "is_error"}${detail}) - stopping. See log: ${relLog}`;
+        if (banners) {
+          banners.tickEnd(status.subtype ?? "is_error");
+          banners.stop(msg);
+        } else {
+          console.log(msg);
+        }
+        break;
+      }
+      if (agentExit !== 0) {
+        const msg = `${opts.backend.id} exited with code ${agentExit} - stopping. See log: ${relLog}`;
+        if (banners) {
+          banners.tickEnd(`exit ${agentExit}`);
+          banners.stop(msg);
+        } else {
+          console.log(msg);
+        }
+        break;
+      }
+      const sentinel = await resolveTickSentinel(lastResult, logPath);
+      const after = await pending();
+      if (banners) {
+        banners.tickEnd(`pending: ${after}`);
+      }
+      if (sentinel.kind === "continue") {
+      } else if (sentinel.kind === "stop") {
+        console.log(`Agent requested stop: ${formatSentinelLine(sentinel)}`);
+        stopReason = sentinel.reason;
+        if (after === 0 || isPlanExhaustedReason(sentinel.reason)) {
+          planExhausted = true;
+        }
+        break;
+      } else if (after < before) {
+        console.log(
+          `warn: tick without sentinel, but progress (${before} -> ${after}) - continuing.`
+        );
+      } else {
+        const msg = `Tick without sentinel and no progress (${before} -> ${after}) - stopping for safety.`;
+        if (banners) banners.stop(msg);
+        else console.log(msg);
+        break;
+      }
+      if (after === 0) {
+        console.log("All to-dos completed. Suggesting /git-prod stays with the human (HITL).");
+        planExhausted = true;
+        break;
+      }
+      if (opts.sleepSeconds > 0) {
+        if (banners) banners.sleep(opts.sleepSeconds);
+        await withCliProgress(`sleep ${opts.sleepSeconds}s`, () => sleep(opts.sleepSeconds * 1e3));
+      }
+    }
+    const pendingNow = await pending();
+    console.log("");
+    const finishDetail = `after ${tick} tick(s); pending: ${pendingNow}`;
+    if (banners) banners.phaseComplete(finishDetail);
+    console.log(
+      `Loop finished after ${tick} tick(s). Pending now: ${pendingNow}. Logs in ${path5.relative(opts.root, logDir)}/`
+    );
+    if (planExhausted || shouldArmExternalPlanReview({ pending: pendingNow, stopReason })) {
+      await armExternalPlanReview(opts.root);
+    }
+    return exitCode;
+  } finally {
+    process.off("SIGINT", onSigInt);
+  }
+}
+
+export {
+  shouldUseLiveTui,
+  withLiveTui,
+  listDetectBackendIds,
+  detectAgentBackend,
+  runPlanLoop
+};