@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-OUQZC744.js

@@ -0,0 +1,1315 @@
+import {
+  HEADLESS_DENY_RULES
+} from "./chunk-MAPOQEA2.js";
+import {
+  HELMET_ACCENT,
+  LABEL_MUTED,
+  SPACE_MARKS,
+  STATUS_ERR,
+  STATUS_OK,
+  STATUS_WARN,
+  shouldUseWelcomeColor,
+  withKoloristColor
+} from "./chunk-QTON2GQX.js";
+
+// src/plan-loop/hitl-relay.ts
+import { createInterface } from "readline";
+import { StringDecoder } from "string_decoder";
+
+// src/plan-loop/line-splitter.ts
+var PENDING_MAX_CHARS = 4 * 1024 * 1024;
+var LineSplitter = class {
+  constructor(maxChars = PENDING_MAX_CHARS) {
+    this.maxChars = maxChars;
+  }
+  maxChars;
+  parts = [];
+  length = 0;
+  dropping = false;
+  /** Calls `onLine` for every line the chunk completes (without the `\n`). */
+  feed(text, onLine) {
+    let start = 0;
+    let nl = text.indexOf("\n", start);
+    while (nl !== -1) {
+      const segment = text.slice(start, nl);
+      if (this.dropping) {
+        this.dropping = false;
+      } else if (this.parts.length === 0) {
+        onLine(segment);
+      } else {
+        this.parts.push(segment);
+        const line = this.parts.join("");
+        this.parts = [];
+        this.length = 0;
+        onLine(line);
+      }
+      start = nl + 1;
+      nl = text.indexOf("\n", start);
+    }
+    if (start >= text.length || this.dropping) return;
+    const tail = start === 0 ? text : text.slice(start);
+    this.parts.push(tail);
+    this.length += tail.length;
+    if (this.length > this.maxChars) {
+      this.parts = [];
+      this.length = 0;
+      this.dropping = true;
+    }
+  }
+  /** The held partial line ("" when none or when it was dropped); resets. */
+  end() {
+    const rest = this.dropping ? "" : this.parts.join("");
+    this.parts = [];
+    this.length = 0;
+    this.dropping = false;
+    return rest;
+  }
+};
+
+// src/plan-loop/hitl-relay.ts
+var HITL_GATE_LINE_RE = /^HITL_GATE:\s*([a-z0-9-]+)\s*\|\s*(.+)$/;
+var HITL_REPLY_PREFIX = "HITL_REPLY:";
+var RESERVED_GATE_IDS = ["git-prod", "kit-prod"];
+var FALLBACK_ASK_ID = "prose-fallback";
+var HITL_UNANSWERED_EXIT_CODE = 4;
+var HITL_SIGINT_EXIT_CODE = 130;
+var NUMBERED_LINE_RE = /^\s*(\d+)\.\s+(.+?)\s*$/;
+var FALLBACK_WORDING_RES = [
+  /reply with (?:the |a )?number/i,
+  /ask questions is not available/i,
+  /skip or cancel means stop/i
+];
+var TICK_SENTINEL_RE = /LOOP_TICK_RESULT:/;
+function parseHitlGateLine(line) {
+  const m = HITL_GATE_LINE_RE.exec(line.trim());
+  if (!m?.[1] || !m[2]) return null;
+  const labels = m[2].split("|").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (labels.length === 0) return null;
+  return { askId: m[1], labels, detection: "sentinel" };
+}
+function findHitlGateInText(text) {
+  let last = null;
+  for (const line of text.split(/\r?\n/)) {
+    const gate = parseHitlGateLine(line);
+    if (gate) last = gate;
+  }
+  return last;
+}
+function cleanFallbackLabel(raw) {
+  let label = raw.trim();
+  const bold = /^\*\*(.+?)\*\*/.exec(label);
+  if (bold?.[1]) label = bold[1];
+  else label = label.replace(/\*\*/g, "").replace(/^`(.+)`$/, "$1");
+  label = label.split(/\s+[—–]\s+/)[0] ?? label;
+  return label.replace(/[.:]+$/, "").trim();
+}
+function detectFallbackGate(text) {
+  if (!FALLBACK_WORDING_RES.some((re) => re.test(text))) return null;
+  const labels = [];
+  let expected = 1;
+  for (const line of text.split(/\r?\n/)) {
+    const m = NUMBERED_LINE_RE.exec(line);
+    if (!m?.[1] || !m[2]) continue;
+    const n = Number(m[1]);
+    if (n === 1) {
+      labels.length = 0;
+      expected = 1;
+    }
+    if (n !== expected) continue;
+    labels.push(cleanFallbackLabel(m[2]));
+    expected += 1;
+  }
+  if (labels.length < 2) return null;
+  return { askId: FALLBACK_ASK_ID, labels, detection: "fallback" };
+}
+function detectHitlGate(resultText, assistantTexts) {
+  if (TICK_SENTINEL_RE.test(resultText)) return null;
+  const fromResult = findHitlGateInText(resultText);
+  if (fromResult) return fromResult;
+  for (let i = assistantTexts.length - 1; i >= 0; i -= 1) {
+    const text = assistantTexts[i] ?? "";
+    if (TICK_SENTINEL_RE.test(text)) return null;
+    const gate = findHitlGateInText(text);
+    if (gate) return gate;
+  }
+  const fallback = detectFallbackGate(resultText);
+  if (fallback) return fallback;
+  for (let i = assistantTexts.length - 1; i >= 0; i -= 1) {
+    const gate = detectFallbackGate(assistantTexts[i] ?? "");
+    if (gate) return gate;
+  }
+  return null;
+}
+function isReservedGateId(askId) {
+  return RESERVED_GATE_IDS.includes(askId);
+}
+var STOP_WORDS = /* @__PURE__ */ new Set(["skip", "cancel"]);
+function resolveOperatorAnswer(input, labels) {
+  const text = input.trim();
+  if (!text) return { kind: "stop", cause: "empty" };
+  const exact = labels.indexOf(text);
+  if (exact !== -1) return { kind: "reply", n: exact + 1, label: labels[exact] ?? text };
+  if (/^\d+$/.test(text)) {
+    const n = Number(text);
+    const label = labels[n - 1];
+    if (n >= 1 && label !== void 0) return { kind: "reply", n, label };
+  }
+  const lower = text.toLowerCase();
+  if (STOP_WORDS.has(lower)) return { kind: "stop", cause: lower };
+  return { kind: "other", text };
+}
+function formatHitlReply(askId, answer) {
+  if (answer.kind === "reply") {
+    return `${HITL_REPLY_PREFIX} ${askId} | operator reply ${answer.n} | ${answer.label}`;
+  }
+  if (answer.kind === "other") {
+    return `${HITL_REPLY_PREFIX} ${askId} | operator reply other | ${answer.text}`;
+  }
+  throw new Error("a stop answer has no reply stamp");
+}
+function createTerminalAnswerReader(opts = {}) {
+  return (_gate, readOpts) => new Promise((resolve) => {
+    const input = opts.input ?? process.stdin;
+    const output = opts.output ?? process.stdout;
+    const terminal = opts.terminal ?? Boolean(input.isTTY);
+    const rl = createInterface({ input, output, terminal });
+    let settled = false;
+    const finish = (answer) => {
+      if (settled) return;
+      settled = true;
+      readOpts.signal?.removeEventListener("abort", onAbort);
+      rl.close();
+      if (typeof input.pause === "function") {
+        input.pause();
+      }
+      resolve(answer);
+    };
+    const onAbort = () => finish({ kind: "eof" });
+    if (readOpts.signal?.aborted) {
+      onAbort();
+      return;
+    }
+    readOpts.signal?.addEventListener("abort", onAbort, { once: true });
+    rl.on("SIGINT", () => finish({ kind: "sigint" }));
+    rl.on("close", () => finish({ kind: "eof" }));
+    rl.question("> ", (line) => finish({ kind: "line", text: line }));
+  });
+}
+function emptyHitlRecord() {
+  return { replies: [], fallbackDetections: 0 };
+}
+function operatorStop(askId, cause) {
+  return {
+    askId,
+    cause,
+    message: `stopped-by-operator: gate ${askId}, no reply (${cause})`,
+    exitCode: cause === "SIGINT" ? HITL_SIGINT_EXIT_CODE : HITL_UNANSWERED_EXIT_CODE
+  };
+}
+function operatorQuitStop(key) {
+  return {
+    askId: "none",
+    cause: "quit",
+    message: `stopped-by-operator: quit (${key}), no gate open`,
+    exitCode: HITL_SIGINT_EXIT_CODE
+  };
+}
+function unansweredStop(askId, cause) {
+  return {
+    askId,
+    cause,
+    message: `stopped: unanswered gate (${cause})`,
+    exitCode: HITL_UNANSWERED_EXIT_CODE
+  };
+}
+function noRelayStop(askId, backend) {
+  return {
+    askId,
+    cause: "no relay",
+    message: `stopped: unanswered gate (backend ${backend} has no relay)`,
+    exitCode: HITL_UNANSWERED_EXIT_CODE
+  };
+}
+function reservedStop(askId) {
+  return {
+    askId,
+    cause: "reserved",
+    message: `stopped: gate ${askId} is operator-gated; run the /${askId} slash yourself (never headless)`,
+    exitCode: HITL_UNANSWERED_EXIT_CODE
+  };
+}
+function formatGatePrompt(gate) {
+  const head = gate.detection === "fallback" ? `HITL gate (prose fallback, ask-id ${gate.askId})` : `HITL gate ${gate.askId}`;
+  const lines = [
+    "",
+    `${head}: reply with the number or the label; anything else is sent as "other"; empty, skip, cancel or Ctrl-C stops the run.`,
+    ...gate.labels.map((label, i) => `  ${i + 1}. ${label}`)
+  ];
+  return `${lines.join("\n")}
+`;
+}
+async function askOperator(gate, opts) {
+  if (isReservedGateId(gate.askId)) return { kind: "stop", stop: reservedStop(gate.askId) };
+  if (opts.policy === "off") return { kind: "stop", stop: unansweredStop(gate.askId, "--no-hitl") };
+  if (!opts.isTTY) return { kind: "stop", stop: unansweredStop(gate.askId, "no TTY") };
+  opts.onPromptStart?.();
+  let raw;
+  try {
+    opts.write(formatGatePrompt(gate));
+    raw = await opts.readAnswer(gate, { signal: opts.signal });
+  } finally {
+    opts.onPromptEnd?.();
+  }
+  if (opts.signal?.aborted) {
+    return { kind: "stop", stop: unansweredStop(gate.askId, "child exited") };
+  }
+  if (raw.kind === "eof") return { kind: "stop", stop: operatorStop(gate.askId, "EOF") };
+  if (raw.kind === "sigint") return { kind: "stop", stop: operatorStop(gate.askId, "SIGINT") };
+  const answer = resolveOperatorAnswer(raw.text, gate.labels);
+  if (answer.kind === "stop") return { kind: "stop", stop: operatorStop(gate.askId, answer.cause) };
+  const line = formatHitlReply(gate.askId, answer);
+  const stamp = {
+    askId: gate.askId,
+    reply: answer.kind === "reply" ? `operator reply ${answer.n}` : "operator reply other",
+    label: answer.kind === "reply" ? answer.label : answer.text,
+    line,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    detection: gate.detection
+  };
+  return { kind: "reply", stamp };
+}
+function formatHitlSummary(record) {
+  if (!record) return [];
+  const lines = record.replies.map(
+    (s) => `HITL ${s.askId}: ${s.reply} (${s.label}) ${s.at}${s.detection === "fallback" ? " [fallback]" : ""}`
+  );
+  if (record.fallbackDetections > 0) {
+    lines.push(`hitl-detect: prose-fallback x${record.fallbackDetections}`);
+  }
+  if (record.stop) lines.push(record.stop.message);
+  return lines;
+}
+function hitlExitCode(childExitCode, record) {
+  if (record?.stop) return record.stop.exitCode;
+  return childExitCode;
+}
+function userEventLine(text) {
+  return `${JSON.stringify({ type: "user", message: { role: "user", content: text } })}
+`;
+}
+var TurnWatcher = class {
+  constructor(onResult) {
+    this.onResult = onResult;
+  }
+  onResult;
+  lines = new LineSplitter();
+  assistantTexts = [];
+  decoder = new StringDecoder("utf8");
+  feed(chunk) {
+    const text = typeof chunk === "string" ? chunk : this.decoder.write(chunk);
+    if (!text) return;
+    this.lines.feed(text, (line) => this.take(line));
+  }
+  end() {
+    this.lines.feed(this.decoder.end(), (line) => this.take(line));
+    const rest = this.lines.end();
+    if (rest.trim()) this.take(rest);
+  }
+  take(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) return;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    if (typeof event !== "object" || event === null) return;
+    const ev = event;
+    if (ev.type === "assistant") {
+      const content = ev.message?.content;
+      if (typeof content === "string") {
+        if (content) this.assistantTexts.push(content);
+      } else if (Array.isArray(content)) {
+        for (const part of content) {
+          if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string") {
+            this.assistantTexts.push(part.text);
+          }
+        }
+      }
+      return;
+    }
+    if (ev.type === "result") {
+      const texts = this.assistantTexts;
+      this.assistantTexts = [];
+      this.onResult({
+        resultText: typeof ev.result === "string" ? ev.result : "",
+        assistantTexts: texts,
+        isError: ev.is_error === true,
+        subtype: typeof ev.subtype === "string" ? ev.subtype : null,
+        errors: Array.isArray(ev.errors) ? ev.errors.filter((e) => typeof e === "string") : []
+      });
+    }
+  }
+};
+
+// src/plan-loop/backends.ts
+import { execFileSync, spawn } from "child_process";
+import { createWriteStream } from "fs";
+import { access } from "fs/promises";
+import path from "path";
+import { StringDecoder as StringDecoder3 } from "string_decoder";
+
+// src/plan-loop/stream-render.ts
+import { StringDecoder as StringDecoder2 } from "string_decoder";
+import { trueColor } from "kolorist";
+
+// src/plan-loop/stream-events.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+var SUMMARY_KEYS = [
+  "command",
+  "file_path",
+  "path",
+  "pattern",
+  "query",
+  "url",
+  "description",
+  "prompt",
+  "content"
+];
+function summarizeToolInput(input) {
+  if (typeof input === "string") return oneLine(input);
+  if (!isRecord(input)) return input === void 0 ? "" : oneLine(JSON.stringify(input));
+  for (const key of SUMMARY_KEYS) {
+    const value = input[key];
+    if (typeof value === "string" && value.trim()) return oneLine(value);
+  }
+  const keys = Object.keys(input);
+  if (keys.length === 0) return "";
+  return oneLine(JSON.stringify(input));
+}
+function firstLineOfContent(content) {
+  if (typeof content === "string") return firstNonEmptyLine(content);
+  if (Array.isArray(content)) {
+    for (const part of content) {
+      if (isRecord(part) && typeof part.text === "string") {
+        const line = firstNonEmptyLine(part.text);
+        if (line) return line;
+      }
+    }
+    return "";
+  }
+  if (isRecord(content)) return oneLine(JSON.stringify(content));
+  return "";
+}
+function firstNonEmptyLine(text) {
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed) return trimmed;
+  }
+  return "";
+}
+function parseAssistant(event) {
+  const message = event.message;
+  const content = isRecord(message) ? message.content : void 0;
+  if (typeof content === "string") return content ? [{ kind: "text", text: content }] : [];
+  if (!Array.isArray(content)) return [{ kind: "silent" }];
+  const out = [];
+  for (const part of content) {
+    if (!isRecord(part)) continue;
+    const type = asString(part.type);
+    if (type === "text" && typeof part.text === "string") {
+      if (part.text) out.push({ kind: "text", text: part.text });
+    } else if (type === "tool_use" || type === "server_tool_use") {
+      out.push({
+        kind: "tool_use",
+        name: asString(part.name) ?? "tool",
+        summary: summarizeToolInput(part.input)
+      });
+    }
+  }
+  return out.length > 0 ? out : [{ kind: "silent" }];
+}
+var HITL_REPLY_PREFIX2 = "HITL_REPLY:";
+function parseUser(event) {
+  const message = event.message;
+  const content = isRecord(message) ? message.content : void 0;
+  if (typeof content === "string") {
+    if (event.isReplay === true && content.startsWith(HITL_REPLY_PREFIX2)) {
+      return [{ kind: "hitl_reply", line: oneLine(content) }];
+    }
+    return [{ kind: "prompt", chars: content.length }];
+  }
+  if (!Array.isArray(content)) return [{ kind: "silent" }];
+  const out = [];
+  let promptChars = 0;
+  for (const part of content) {
+    if (!isRecord(part)) continue;
+    const type = asString(part.type);
+    if (type === "tool_result") {
+      out.push({
+        kind: "tool_result",
+        ok: part.is_error !== true,
+        line: firstLineOfContent(part.content)
+      });
+    } else if (type === "text" && typeof part.text === "string") {
+      if (event.isReplay === true && part.text.startsWith(HITL_REPLY_PREFIX2)) {
+        out.push({ kind: "hitl_reply", line: oneLine(part.text) });
+        continue;
+      }
+      promptChars += part.text.length;
+    }
+  }
+  if (promptChars > 0) out.push({ kind: "prompt", chars: promptChars });
+  return out.length > 0 ? out : [{ kind: "silent" }];
+}
+function parseResult(event) {
+  const isError = event.is_error === true;
+  const subtype = asString(event.subtype);
+  return {
+    kind: "result",
+    ok: !isError,
+    status: subtype ?? (isError ? "error" : "success"),
+    costUsd: asNumber(event.total_cost_usd),
+    durationMs: asNumber(event.duration_ms),
+    apiMs: asNumber(event.duration_api_ms),
+    turns: asNumber(event.num_turns)
+  };
+}
+function parseSystem(event) {
+  const subtype = asString(event.subtype) ?? "";
+  if (!subtype.startsWith("hook_")) return { kind: "silent" };
+  const phase = subtype.slice("hook_".length);
+  const name = asString(event.hook_name) ?? asString(event.hook_event) ?? "hook";
+  const details = [];
+  const outcome = asString(event.outcome);
+  if (outcome) details.push(outcome);
+  const exitCode = asNumber(event.exit_code);
+  if (exitCode !== void 0) details.push(`exit ${exitCode}`);
+  return { kind: "hook", name, phase, detail: details.join(", ") };
+}
+function percent(value) {
+  const n = asNumber(value);
+  return n === void 0 ? null : `${Math.round(n * 100)}%`;
+}
+function parseRateLimit(event) {
+  const info = isRecord(event.rate_limit_info) ? event.rate_limit_info : event;
+  const status = asString(info.status) ?? "unknown";
+  const type = asString(info.rateLimitType);
+  const parts = [];
+  if (type) parts.push(type);
+  parts.push(status);
+  const windows = isRecord(info.unifiedWindows) ? info.unifiedWindows : null;
+  if (windows) {
+    for (const [name, window] of Object.entries(windows)) {
+      if (!isRecord(window)) continue;
+      const used = percent(window.utilization);
+      if (used) parts.push(`${name} ${used}`);
+    }
+  }
+  return { kind: "rate_limit", line: parts.join(" \xB7 "), severe: status !== "allowed" };
+}
+function parseCursorToolCall(event) {
+  const call = isRecord(event.tool_call) ? event.tool_call : null;
+  const entry = call ? Object.entries(call).find(([, v]) => isRecord(v)) : void 0;
+  const name = entry ? entry[0].replace(/ToolCall$/, "") : "tool";
+  const body = entry && isRecord(entry[1]) ? entry[1] : {};
+  const subtype = asString(event.subtype) ?? "";
+  if (subtype === "started") {
+    return { kind: "tool_use", name, summary: summarizeToolInput(body.args) };
+  }
+  if (subtype === "completed") {
+    const result = isRecord(body.result) ? body.result : null;
+    const failed = result !== null && ("error" in result || "failure" in result || "rejected" in result);
+    let line = "";
+    if (result) {
+      const payload = failed ? result.error ?? result.failure ?? result.rejected : result.success;
+      line = firstLineOfContent(
+        typeof payload === "string" ? payload : payload === void 0 ? result : payload
+      );
+    }
+    return { kind: "tool_result", ok: !failed, line };
+  }
+  return { kind: "silent" };
+}
+function parseStreamLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith("{")) return [{ kind: "unparsed" }];
+  let event;
+  try {
+    event = JSON.parse(trimmed);
+  } catch {
+    return [{ kind: "unparsed" }];
+  }
+  if (!isRecord(event)) return [{ kind: "unparsed" }];
+  switch (asString(event.type)) {
+    case "assistant":
+      return parseAssistant(event);
+    case "user":
+      return parseUser(event);
+    case "result":
+      return [parseResult(event)];
+    case "system":
+      return [parseSystem(event)];
+    case "rate_limit_event":
+      return [parseRateLimit(event)];
+    case "tool_call":
+      return [parseCursorToolCall(event)];
+    default:
+      return [{ kind: "silent" }];
+  }
+}
+
+// src/plan-loop/stream-render.ts
+var PENDING_MAX_CHARS2 = 4 * 1024 * 1024;
+var MIN_COLUMNS = 40;
+function paint(hex, text, color) {
+  if (!color) return text;
+  return withKoloristColor(
+    () => trueColor(
+      Number.parseInt(hex.slice(1, 3), 16),
+      Number.parseInt(hex.slice(3, 5), 16),
+      Number.parseInt(hex.slice(5, 7), 16)
+    )(text)
+  );
+}
+function truncate(text, width) {
+  if (text.length <= width) return text;
+  return `${text.slice(0, Math.max(1, width - 1))}\u2026`;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const rest = Math.round(seconds - minutes * 60);
+  return `${minutes}m ${rest}s`;
+}
+function formatCost(usd) {
+  return `$${usd.toFixed(usd < 0.1 ? 4 : 2)}`;
+}
+function renderStreamEvent(event, opts) {
+  const width = Math.max(MIN_COLUMNS, opts.columns);
+  const color = opts.color;
+  switch (event.kind) {
+    case "text":
+      return event.text;
+    case "tool_use": {
+      const head = `${SPACE_MARKS.diamond} ${event.name}`;
+      const summary = truncate(event.summary, width - head.length - 3);
+      return paint(HELMET_ACCENT, summary ? `${head} ${SPACE_MARKS.tick} ${summary}` : head, color);
+    }
+    case "tool_result": {
+      const label = event.ok ? "ok" : "error";
+      const head = `  ${SPACE_MARKS.tick} ${label}`;
+      const line = truncate(oneLine(event.line), width - head.length - 3);
+      const text = line ? `${head} ${SPACE_MARKS.tick} ${line}` : head;
+      return paint(event.ok ? LABEL_MUTED : STATUS_ERR, text, color);
+    }
+    case "result": {
+      const parts = [`${SPACE_MARKS.star} result ${event.status}`];
+      if (event.costUsd !== void 0) parts.push(formatCost(event.costUsd));
+      if (event.durationMs !== void 0) parts.push(formatDuration(event.durationMs));
+      else if (event.apiMs !== void 0) parts.push(`${formatDuration(event.apiMs)} api`);
+      if (event.turns !== void 0) {
+        parts.push(`${event.turns} turn${event.turns === 1 ? "" : "s"}`);
+      }
+      return paint(event.ok ? STATUS_OK : STATUS_ERR, parts.join(` ${SPACE_MARKS.tick} `), color);
+    }
+    case "hook": {
+      const detail = event.detail ? ` (${event.detail})` : "";
+      return paint(
+        LABEL_MUTED,
+        truncate(`${SPACE_MARKS.tick} hook ${event.name} ${event.phase}${detail}`, width),
+        color
+      );
+    }
+    case "rate_limit":
+      return paint(
+        event.severe ? STATUS_ERR : STATUS_WARN,
+        truncate(`! rate limit ${SPACE_MARKS.tick} ${event.line}`, width),
+        color
+      );
+    case "prompt":
+      return paint(
+        LABEL_MUTED,
+        `${SPACE_MARKS.tick} prompt sent ${SPACE_MARKS.tick} ${event.chars} chars`,
+        color
+      );
+    case "hitl_reply":
+      return paint(HELMET_ACCENT, truncate(`\u21A9 ${event.line}`, width), color);
+    default:
+      return null;
+  }
+}
+var StreamRenderer = class {
+  pending = "";
+  dropped = false;
+  textOpen = false;
+  decoder = new StringDecoder2("utf8");
+  write;
+  color;
+  columns;
+  constructor(opts = {}) {
+    this.write = opts.write ?? ((text) => process.stdout.write(text));
+    this.color = shouldUseWelcomeColor({
+      stdoutIsTTY: opts.isTTY ?? Boolean(process.stdout.isTTY),
+      env: opts.env
+    });
+    this.columns = opts.columns ?? process.stdout.columns ?? 80;
+  }
+  feed(chunk) {
+    try {
+      const text = typeof chunk === "string" ? chunk : this.decoder.write(chunk);
+      if (!text) return;
+      const combined = this.pending + text;
+      const lines = combined.split("\n");
+      this.pending = lines.pop() ?? "";
+      for (const line of lines) {
+        if (this.dropped) {
+          this.dropped = false;
+          continue;
+        }
+        this.renderLine(line);
+      }
+      if (this.pending.length > PENDING_MAX_CHARS2) {
+        this.pending = "";
+        this.dropped = true;
+      }
+    } catch {
+    }
+  }
+  end() {
+    try {
+      const rest = this.pending + this.decoder.end();
+      this.pending = "";
+      if (rest && !this.dropped) this.renderLine(rest);
+      this.dropped = false;
+      this.closeText();
+    } catch {
+    }
+  }
+  renderLine(line) {
+    for (const event of parseStreamLine(line)) {
+      const rendered = renderStreamEvent(event, { color: this.color, columns: this.columns });
+      if (rendered === null) continue;
+      if (event.kind === "text") {
+        this.write(rendered);
+        this.textOpen = !rendered.endsWith("\n");
+        continue;
+      }
+      this.closeText();
+      this.write(`${rendered}
+`);
+    }
+  }
+  closeText() {
+    if (!this.textOpen) return;
+    this.textOpen = false;
+    this.write("\n");
+  }
+};
+function createStreamRenderer(opts = {}) {
+  return new StreamRenderer(opts);
+}
+
+// src/plan-loop/backends.ts
+var HITL_KILL_GRACE_MS = 5e3;
+function resolveHitlRunOptions(hitl, transport) {
+  return {
+    transport,
+    policy: hitl?.policy ?? "prompt",
+    isTTY: hitl?.isTTY ?? Boolean(process.stdin.isTTY),
+    readAnswer: hitl?.readAnswer ?? createTerminalAnswerReader(),
+    write: hitl?.write ?? ((text) => process.stdout.write(text)),
+    onPromptStart: hitl?.onPromptStart,
+    onPromptEnd: hitl?.onPromptEnd,
+    killAfterMs: hitl?.killAfterMs
+  };
+}
+var CLAUDE_ENV_PASSTHROUGH = [
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_API_KEY"
+];
+function redactSecrets(text, secrets) {
+  let out = text;
+  const ordered = secrets.filter((s) => s.value.length > 0).sort((a, b) => b.value.length - a.value.length);
+  for (const s of ordered) {
+    out = out.split(s.value).join(`[${s.label}]`);
+  }
+  return out;
+}
+var REDACT_HOLD_MAX_CHARS = 64 * 1024;
+var RedactingStreamBuffer = class {
+  pending = "";
+  decoder = new StringDecoder3("utf8");
+  secrets;
+  keep;
+  constructor(secrets) {
+    this.secrets = secrets.filter((s) => s.value.length > 0);
+    this.keep = this.secrets.length > 0 ? Math.max(...this.secrets.map((s) => s.value.length)) - 1 : 0;
+  }
+  /** Append a chunk; returns the redacted text that is safe to emit now. */
+  push(chunk) {
+    const text = typeof chunk === "string" ? chunk : this.decoder.write(chunk);
+    if (this.secrets.length === 0) return text;
+    this.pending += text;
+    let cut = this.pending.lastIndexOf("\n") + 1;
+    if (cut === 0) {
+      if (this.pending.length < REDACT_HOLD_MAX_CHARS) return "";
+      cut = this.pending.length - this.keep;
+    }
+    if (cut <= 0) return "";
+    let moved = true;
+    while (moved) {
+      moved = false;
+      for (const s of this.secrets) {
+        let idx = this.pending.indexOf(s.value, Math.max(0, cut - s.value.length + 1));
+        while (idx !== -1 && idx < cut) {
+          if (idx + s.value.length > cut) {
+            cut = idx;
+            moved = true;
+            break;
+          }
+          idx = this.pending.indexOf(s.value, idx + 1);
+        }
+        if (moved) break;
+      }
+    }
+    if (cut <= 0) return "";
+    const out = redactSecrets(this.pending.slice(0, cut), this.secrets);
+    this.pending = this.pending.slice(cut);
+    return out;
+  }
+  /** Emit whatever is still held back (call once, on stream end). */
+  flush() {
+    const rest = this.pending + this.decoder.end();
+    this.pending = "";
+    return this.secrets.length === 0 ? rest : redactSecrets(rest, this.secrets);
+  }
+};
+function mergeChildEnv(overrides) {
+  const merged = { ...process.env };
+  if (!overrides) return merged;
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === void 0) delete merged[key];
+    else merged[key] = value;
+  }
+  return merged;
+}
+var CLAUDE_NESTED_SESSION_KEYS = [
+  "CLAUDECODE",
+  "CLAUDE_CODE_SESSION_ID",
+  "CLAUDE_CODE_CHILD_SESSION",
+  "CLAUDE_CODE_BRIDGE_SESSION_ID"
+];
+function claudeChildEnv(overrides) {
+  const env = mergeChildEnv(overrides);
+  for (const key of CLAUDE_NESTED_SESSION_KEYS) delete env[key];
+  return env;
+}
+var CLAUDE_MAX_TURNS_ENV = "AGENT_KIT_CLAUDE_MAX_TURNS";
+var CLAUDE_MAX_BUDGET_USD_ENV = "AGENT_KIT_CLAUDE_MAX_BUDGET_USD";
+function claudeRunCaps(env) {
+  const caps = {};
+  const invalid = [];
+  const turnsRaw = env[CLAUDE_MAX_TURNS_ENV];
+  if (turnsRaw !== void 0 && turnsRaw !== "") {
+    const n = Number(turnsRaw);
+    if (Number.isInteger(n) && n > 0) caps.maxTurns = n;
+    else invalid.push(`${CLAUDE_MAX_TURNS_ENV} (want a positive integer)`);
+  }
+  const budgetRaw = env[CLAUDE_MAX_BUDGET_USD_ENV];
+  if (budgetRaw !== void 0 && budgetRaw !== "") {
+    const n = Number(budgetRaw);
+    if (Number.isFinite(n) && n > 0) caps.maxBudgetUsd = n;
+    else invalid.push(`${CLAUDE_MAX_BUDGET_USD_ENV} (want a positive number)`);
+  }
+  return { caps, invalid };
+}
+var REDACT_DERIVED_MIN_CHARS = 4;
+var REDACT_DERIVED_SKIP = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0", "::1", "[::1]"]);
+function derivedSecretForms(value) {
+  const forms = [
+    value.replaceAll("/", "\\/"),
+    // JSON-escaped (JSON.stringify leaves `/` alone)
+    encodeURIComponent(value),
+    Buffer.from(value, "utf8").toString("base64"),
+    Buffer.from(value, "utf8").toString("base64url")
+  ];
+  return forms.filter((f) => f !== value);
+}
+function derivedUrlForms(value) {
+  const forms = [];
+  const trimmed = value.replace(/\/+$/, "");
+  if (trimmed !== value) forms.push(trimmed);
+  else forms.push(`${value}/`);
+  try {
+    const url = new URL(value);
+    forms.push(url.origin, url.host, url.hostname);
+  } catch {
+  }
+  return forms.filter((f) => f !== value);
+}
+function claudeRedactions(env) {
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (label, value, derived) => {
+    if (!value || seen.has(value)) return;
+    if (derived && (value.length < REDACT_DERIVED_MIN_CHARS || REDACT_DERIVED_SKIP.has(value))) {
+      return;
+    }
+    seen.add(value);
+    entries.push({ label, value });
+  };
+  for (const key of CLAUDE_ENV_PASSTHROUGH) {
+    const value = env[key];
+    if (!value) continue;
+    add(key, value, false);
+    const derived = key === "ANTHROPIC_BASE_URL" ? derivedUrlForms(value) : derivedSecretForms(value);
+    for (const form of derived) add(key, form, true);
+  }
+  return entries;
+}
+async function whichBinary(bin) {
+  try {
+    const out = execFileSync("which", [bin], { encoding: "utf8" }).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+function spawnLogged(command, args, logPath, options = {}) {
+  const spawnFn = options.spawnFn ?? spawn;
+  const redact = options.redact ?? [];
+  const redactedError = (err) => new Error(redactSecrets(String(err), redact));
+  const hitl = options.hitl;
+  const stdinTransport = hitl?.transport.kind === "stdin-stream-json";
+  return new Promise((resolve, reject) => {
+    let out;
+    let child;
+    let logError = null;
+    try {
+      out = createWriteStream(logPath, { flags: "w" });
+      out.on("error", (err) => {
+        logError = err;
+        reject(redactedError(err));
+      });
+      child = spawnFn(command, args, {
+        stdio: [stdinTransport ? "pipe" : "ignore", "pipe", "pipe"],
+        ...options.cwd ? { cwd: options.cwd } : {},
+        ...options.env ? { env: options.env } : {}
+      });
+    } catch (err) {
+      reject(redactedError(err));
+      return;
+    }
+    const render = options.render ?? createStreamRenderer();
+    const relay = hitl ? createRelay(hitl, child, redactedError) : null;
+    const emit = (text) => {
+      if (text.length === 0) return;
+      out.write(text);
+      render.feed(text);
+      relay?.feed(text);
+    };
+    if (relay?.startError) {
+      out.end();
+      reject(relay.startError);
+      return;
+    }
+    options.onSpawn?.({
+      backend: options.backendId ?? "claude",
+      pid: child.pid,
+      stop: (stop) => {
+        if (relay) {
+          relay.stop(stop);
+          return;
+        }
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+      }
+    });
+    const buffers = [];
+    const tee = (stream) => {
+      if (!stream) return;
+      if (redact.length === 0) {
+        stream.on("data", (chunk) => emit(chunk));
+        return;
+      }
+      const buffer = new RedactingStreamBuffer(redact);
+      buffers.push(buffer);
+      stream.on("data", (chunk) => emit(buffer.push(chunk)));
+    };
+    tee(child.stdout);
+    tee(child.stderr);
+    child.on("error", (err) => {
+      out.end();
+      reject(redactedError(err));
+    });
+    child.on("close", (code) => {
+      for (const buffer of buffers) emit(buffer.flush());
+      render.end();
+      relay?.finish();
+      const finish = () => {
+        out.end((err) => {
+          const failure = err ?? logError;
+          if (failure) reject(redactedError(failure));
+          else if (relay) {
+            const lastResult = relay.lastResult();
+            resolve({
+              exitCode: code ?? 1,
+              hitl: relay.record,
+              ...lastResult ? { lastResult } : {}
+            });
+          } else resolve({ exitCode: code ?? 1 });
+        });
+      };
+      if (relay) relay.closed().then(finish, finish);
+      else finish();
+    });
+  });
+}
+function createRelay(hitl, child, redactedError) {
+  const record = emptyHitlRecord();
+  const stdinTransport = hitl.transport.kind === "stdin-stream-json";
+  const abort = new AbortController();
+  const grace = hitl.killAfterMs ?? HITL_KILL_GRACE_MS;
+  let startError = null;
+  let closed = false;
+  let stdinEnded = false;
+  let pendingAsk = null;
+  const timers = [];
+  let resolveClosed = () => {
+  };
+  const closedPromise = new Promise((resolve) => {
+    resolveClosed = resolve;
+  });
+  const stdin = child.stdin;
+  if (hitl.transport.kind === "stdin-stream-json") {
+    if (!stdin) {
+      startError = new Error("claude child has no writable stdin (stream-json transport)");
+    } else {
+      stdin.on("error", () => {
+      });
+      try {
+        stdin.write(userEventLine(hitl.transport.firstPrompt));
+      } catch (err) {
+        startError = redactedError(err);
+      }
+    }
+  }
+  const endStdin = () => {
+    if (!stdinTransport || stdinEnded) return;
+    stdinEnded = true;
+    try {
+      stdin?.end();
+    } catch {
+    }
+  };
+  const stopChild = () => {
+    endStdin();
+    const term = setTimeout(() => {
+      if (closed) return;
+      child.kill("SIGTERM");
+      const kill = setTimeout(() => {
+        if (!closed) child.kill("SIGKILL");
+      }, grace);
+      kill.unref?.();
+      timers.push(kill);
+    }, grace);
+    term.unref?.();
+    timers.push(term);
+  };
+  let lastResult;
+  const watcher = new TurnWatcher((turn) => {
+    lastResult = turn;
+    const { resultText, assistantTexts } = turn;
+    if (record.stop || closed) return;
+    const gate = detectHitlGate(resultText, assistantTexts);
+    if (!gate) {
+      endStdin();
+      return;
+    }
+    if (gate.detection === "fallback") record.fallbackDetections += 1;
+    if (hitl.transport.kind === "none") {
+      record.stop = noRelayStop(gate.askId, hitl.transport.backend);
+      return;
+    }
+    const ask = askOperator(gate, {
+      isTTY: hitl.isTTY,
+      policy: hitl.policy,
+      readAnswer: hitl.readAnswer,
+      write: hitl.write,
+      signal: abort.signal,
+      onPromptStart: hitl.onPromptStart,
+      onPromptEnd: hitl.onPromptEnd
+    }).then(
+      (outcome) => {
+        if (record.stop) return;
+        if (outcome.kind === "stop") {
+          record.stop = outcome.stop;
+          stopChild();
+          return;
+        }
+        if (closed || !stdin) {
+          record.stop = unansweredStop(gate.askId, "child exited");
+          return;
+        }
+        record.replies.push(outcome.stamp);
+        hitl.write(`\u2192 ${outcome.stamp.line}
+`);
+        stdin.write(userEventLine(outcome.stamp.line));
+      },
+      (err) => {
+        record.stop = unansweredStop(gate.askId, "child exited");
+        hitl.write(`hitl relay: ${redactedError(err).message}
+`);
+        stopChild();
+      }
+    );
+    pendingAsk = ask;
+  });
+  child.on("close", () => {
+    closed = true;
+    for (const t of timers) clearTimeout(t);
+    abort.abort();
+    const settle = () => resolveClosed();
+    if (pendingAsk) pendingAsk.then(settle, settle);
+    else settle();
+  });
+  return {
+    startError,
+    record,
+    lastResult: () => lastResult,
+    feed: (text) => watcher.feed(text),
+    finish: () => watcher.end(),
+    closed: () => closedPromise,
+    stop: (stop) => {
+      if (closed || record.stop) return;
+      record.stop = stop;
+      stopChild();
+    }
+  };
+}
+function cursorAgentHeadlessArgs(opts) {
+  const args = [
+    "-p",
+    "--force",
+    "--sandbox",
+    "disabled",
+    "--output-format",
+    "stream-json",
+    "--workspace",
+    opts.workspace
+  ];
+  if (opts.model) args.push("--model", opts.model);
+  args.push(opts.prompt);
+  return args;
+}
+var cursorAgentBackend = {
+  id: "cursor-agent",
+  async resolve() {
+    return whichBinary("cursor-agent");
+  },
+  async run(opts) {
+    const args = cursorAgentHeadlessArgs({
+      workspace: opts.workspace,
+      prompt: opts.prompt,
+      model: opts.model
+    });
+    const env = opts.env ? mergeChildEnv(opts.env) : void 0;
+    return spawnLogged("cursor-agent", args, opts.logPath, {
+      spawnFn: opts.spawnFn,
+      env,
+      redact: claudeRedactions(env ?? process.env),
+      hitl: resolveHitlRunOptions(opts.hitl, { kind: "none", backend: "cursor-agent" }),
+      render: opts.render,
+      onSpawn: opts.onSpawn,
+      backendId: "cursor-agent"
+    });
+  }
+};
+var CLAUDE_MIN_VERSION = "2.1.259";
+function parseClaudeVersion(raw) {
+  if (!raw) return null;
+  const m = /(\d+)\.(\d+)\.(\d+)/.exec(raw);
+  return m ? `${m[1]}.${m[2]}.${m[3]}` : null;
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i += 1) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+var claudeVersionCache = /* @__PURE__ */ new Map();
+function defaultVersionFn(bin) {
+  try {
+    return execFileSync(bin, ["--version"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return null;
+  }
+}
+function checkClaudeVersion(bin, versionFn = defaultVersionFn) {
+  if (!claudeVersionCache.has(bin)) {
+    claudeVersionCache.set(bin, parseClaudeVersion(versionFn(bin)));
+  }
+  const version = claudeVersionCache.get(bin) ?? null;
+  if (version === null) {
+    return {
+      ok: true,
+      version: null,
+      warning: `claude tick: could not read \`claude --version\`; the tick needs claude >= ${CLAUDE_MIN_VERSION} (--permission-prompts). Continuing.`
+    };
+  }
+  if (compareVersions(version, CLAUDE_MIN_VERSION) < 0) {
+    return {
+      ok: false,
+      version,
+      message: `claude ${version} is older than ${CLAUDE_MIN_VERSION}, the first release that accepts \`--permission-prompts none\`. Run \`claude update\` and retry.`
+    };
+  }
+  return { ok: true, version };
+}
+function claudeHeadlessArgs(opts = {}) {
+  const args = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--dangerously-skip-permissions",
+    "--permission-prompts",
+    "none",
+    "--input-format",
+    "stream-json",
+    "--replay-user-messages"
+  ];
+  if (opts.maxTurns !== void 0) {
+    args.push("--max-turns", String(opts.maxTurns));
+  }
+  if (opts.maxBudgetUsd !== void 0) {
+    args.push("--max-budget-usd", String(opts.maxBudgetUsd));
+  }
+  if (opts.model) {
+    args.push("--model", opts.model);
+  }
+  args.push("--disallowedTools", ...HEADLESS_DENY_RULES);
+  return args;
+}
+async function missingClaudeAdapter(workspace, prompt) {
+  const m = /^\/([A-Za-z0-9][A-Za-z0-9_-]*)/.exec(prompt.trimStart());
+  if (!m?.[1]) return null;
+  const rel = path.join(".claude", "commands", `${m[1]}.md`);
+  try {
+    await access(path.join(workspace, rel));
+    return null;
+  } catch {
+    return rel;
+  }
+}
+var claudeBackend = {
+  id: "claude",
+  async resolve() {
+    return whichBinary("claude");
+  },
+  async run(opts) {
+    const log = opts.log ?? ((line) => console.log(line));
+    const env = claudeChildEnv(opts.env);
+    const redact = claudeRedactions(env);
+    const version = checkClaudeVersion("claude", opts.versionFn);
+    if (!version.ok) {
+      throw new Error(`claude backend: ${version.message}`);
+    }
+    if (version.warning) log(version.warning);
+    const adapter = await missingClaudeAdapter(opts.workspace, opts.prompt);
+    if (adapter) {
+      throw new Error(
+        `claude backend: ${adapter} is missing in the workspace, so the tick's leading slash would be sent as literal text. Generate the Claude Code adapters with \`agent-kit install --claude\` and retry.`
+      );
+    }
+    const { caps, invalid } = claudeRunCaps(env);
+    for (const problem of invalid)
+      log(`claude tick: ignoring invalid ${problem}; running uncapped.`);
+    const capText = [
+      caps.maxTurns !== void 0 ? `max-turns=${caps.maxTurns}` : null,
+      caps.maxBudgetUsd !== void 0 ? `max-budget-usd=${caps.maxBudgetUsd}` : null
+    ].filter(Boolean).join(" ");
+    const presence = CLAUDE_ENV_PASSTHROUGH.map(
+      (key) => `${key}=${env[key] ? "set" : "unset"}`
+    ).join(" ");
+    log(
+      `claude tick: claude -p (bypass permissions, stream-json, stdin relay${capText ? `, ${capText}` : ""}). env: ${presence}`
+    );
+    const args = claudeHeadlessArgs({ model: opts.model, ...caps });
+    try {
+      return await spawnLogged("claude", args, opts.logPath, {
+        cwd: opts.workspace,
+        env,
+        spawnFn: opts.spawnFn,
+        redact,
+        hitl: resolveHitlRunOptions(opts.hitl, {
+          kind: "stdin-stream-json",
+          firstPrompt: opts.prompt
+        }),
+        render: opts.render,
+        onSpawn: opts.onSpawn,
+        backendId: "claude"
+      });
+    } catch (err) {
+      throw new Error(`claude backend failed to start: ${redactSecrets(String(err), redact)}`);
+    }
+  }
+};
+var BACKENDS = {
+  "cursor-agent": cursorAgentBackend,
+  claude: claudeBackend
+};
+function getBackend(id) {
+  const backend = BACKENDS[id];
+  if (!backend) {
+    throw new Error(`Unknown backend '${id}'. Supported: ${Object.keys(BACKENDS).join(", ")}`);
+  }
+  return backend;
+}
+
+export {
+  LineSplitter,
+  RESERVED_GATE_IDS,
+  HITL_UNANSWERED_EXIT_CODE,
+  operatorQuitStop,
+  formatHitlSummary,
+  hitlExitCode,
+  parseStreamLine,
+  renderStreamEvent,
+  resolveHitlRunOptions,
+  redactSecrets,
+  RedactingStreamBuffer,
+  claudeChildEnv,
+  claudeRunCaps,
+  claudeRedactions,
+  whichBinary,
+  spawnLogged,
+  cursorAgentHeadlessArgs,
+  checkClaudeVersion,
+  claudeHeadlessArgs,
+  getBackend
+};