@dadado/agent-kit-cli 6.3.0 → 6.5.0

package/dist/{chunk-SV2BR2LZ.js → chunk-I2D75F4I.js}

@@ -6,7 +6,7 @@ import {
   formatStaleCliRefusal,
   installL0,
   syncFromManifest
-} from "./chunk-Z7RYIHHX.js";
+} from "./chunk-5LQP4JGH.js";
 import {
   SkippedSymlinkError,
   formatPersonalizationSkippedSymlinks,
@@ -15,11 +15,11 @@ import {
 import {
   REGISTRY_CLI_ARGS,
   resolveRegistryFromCli
-} from "./chunk-U26MRIWN.js";
+} from "./chunk-34BBPQKI.js";
 import {
   assessClaudeCommandAdapters,
   executeSafeReadinessFixes
-} from "./chunk-WMVMBPCR.js";
+} from "./chunk-WOGBBJCX.js";
 import {
   writeReadinessSnapshot
 } from "./chunk-HAFRAXGV.js";
@@ -27,7 +27,7 @@ import {
   CLAUDE_HITL_FALLBACK,
   generateClaudeCommandAdapters,
   writeClaudeSessionStartHook
-} from "./chunk-NNKOWUWM.js";
+} from "./chunk-236IYK6L.js";
 import {
   shouldUseWelcomeColor,
   withCliProgress
@@ -54,13 +54,13 @@ import {
   npxPinned,
   pathCliStatus,
   syncPathCliToRuntime
-} from "./chunk-OWWFKGKS.js";
+} from "./chunk-EI3VQ7FU.js";
 import {
   assessEnvironment
 } from "./chunk-B3VR5YBQ.js";
 import {
   warnIfRunningCliBehindNpm
-} from "./chunk-6GYKOHIL.js";
+} from "./chunk-YIOTJQHL.js";
 import {
   DOMAIN_PACK_IDS,
   allPacks,
@@ -77,7 +77,7 @@ import {
   resolveProtectedGlobs,
   saveManifest,
   skillTargetDir
-} from "./chunk-6KUSG7BJ.js";
+} from "./chunk-5WSFO35Y.js";
 import {
   KIT_VERSION,
   pinnedCliSpec

package/dist/{chunk-25J2SMJQ.js → chunk-IN4MQ3P3.js}

@@ -4,7 +4,7 @@ import {
   loadRegistry,
   packMemberFileTargets,
   skillFileTargets
-} from "./chunk-6KUSG7BJ.js";
+} from "./chunk-5WSFO35Y.js";
 
 // src/lifecycle/l0.ts
 var L0_ARTIFACTS = [

package/dist/{chunk-OVOXRH5W.js → chunk-MEZUW3LL.js}

@@ -1,6 +1,6 @@
 import {
   MANIFEST_RELATIVE_PATH
-} from "./chunk-6KUSG7BJ.js";
+} from "./chunk-5WSFO35Y.js";
 import {
   fileExists
 } from "./chunk-5B4DVO6C.js";

package/dist/chunk-MTLQN57O.js

@@ -0,0 +1,380 @@
+// 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 formatHitlGateLine(gate) {
+  return `HITL_GATE: ${gate.askId} | ${gate.labels.join(" | ")}`;
+}
+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 driverStop(askId, raw) {
+  const detail = raw.detail ? `: ${raw.detail}` : "";
+  return {
+    askId,
+    cause: raw.cause,
+    message: raw.cause === "driver stop" ? `stopped-by-operator: gate ${askId}, no reply (driver stop)` : `stopped: unanswered gate (driver protocol error${detail})`,
+    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 && opts.policy !== "driver") {
+    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") };
+  if (raw.kind === "stop") return { kind: "stop", stop: driverStop(gate.askId, raw) };
+  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 = [];
+  backgroundTasks = 0;
+  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 === "system" && ev.subtype === "background_tasks_changed") {
+      this.backgroundTasks = Array.isArray(ev.tasks) ? ev.tasks.length : 0;
+      return;
+    }
+    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") : [],
+        backgroundTasks: this.backgroundTasks
+      });
+    }
+  }
+};
+
+export {
+  LineSplitter,
+  RESERVED_GATE_IDS,
+  HITL_UNANSWERED_EXIT_CODE,
+  formatHitlGateLine,
+  findHitlGateInText,
+  detectHitlGate,
+  createTerminalAnswerReader,
+  emptyHitlRecord,
+  operatorQuitStop,
+  unansweredStop,
+  noRelayStop,
+  askOperator,
+  formatHitlSummary,
+  hitlExitCode,
+  userEventLine,
+  TurnWatcher
+};

package/dist/chunk-R6WH5P7R.js

@@ -0,0 +1,223 @@
+import {
+  formatHitlGateLine
+} from "./chunk-MTLQN57O.js";
+
+// src/plan-loop/driver-events.ts
+import { createInterface } from "readline";
+import { StringDecoder } from "string_decoder";
+var DRIVER_PROTOCOL_MAJOR = 1;
+var DRIVER_PROTOCOL_VERSION = "1.1.0";
+var DRIVER_EVENTS_FORMATS = ["ndjson"];
+var INBOUND_MAX_CHARS = 64 * 1024;
+var AGENT_PENDING_MAX_CHARS = 4 * 1024 * 1024;
+function formatDriverEvent(event, now = () => /* @__PURE__ */ new Date()) {
+  return `${JSON.stringify({ v: DRIVER_PROTOCOL_MAJOR, ts: now().toISOString(), ...event })}
+`;
+}
+function createDriverEmitter(write = (text) => {
+  process.stdout.write(text);
+}, now) {
+  return {
+    emit(event) {
+      try {
+        write(formatDriverEvent(event, now));
+      } catch {
+      }
+    }
+  };
+}
+function parseDriverInbound(line) {
+  const text = line.trim();
+  if (text.length > INBOUND_MAX_CHARS) return { ok: false, error: "line too long" };
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return { ok: false, error: "not JSON" };
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, error: "not a JSON object" };
+  }
+  const msg = value;
+  if (msg.v !== void 0 && msg.v !== DRIVER_PROTOCOL_MAJOR) {
+    return { ok: false, error: `unsupported protocol v${String(msg.v)}` };
+  }
+  if (msg.type === "stop") {
+    return {
+      ok: true,
+      message: { type: "stop", ...typeof msg.reason === "string" ? { reason: msg.reason } : {} }
+    };
+  }
+  if (msg.type !== "hitl_reply")
+    return { ok: false, error: `unknown type ${JSON.stringify(msg.type)}` };
+  if (typeof msg.askId !== "string" || !/^[a-z0-9-]+$/.test(msg.askId)) {
+    return { ok: false, error: "hitl_reply.askId must be a kebab-case string" };
+  }
+  if (typeof msg.reply === "number") {
+    if (!Number.isInteger(msg.reply) || msg.reply < 1) {
+      return { ok: false, error: "hitl_reply.reply number must be a positive integer" };
+    }
+    return { ok: true, message: { type: "hitl_reply", askId: msg.askId, reply: msg.reply } };
+  }
+  if (typeof msg.reply === "string" && msg.reply.trim() && !/[\r\n]/.test(msg.reply)) {
+    return { ok: true, message: { type: "hitl_reply", askId: msg.askId, reply: msg.reply.trim() } };
+  }
+  return { ok: false, error: "hitl_reply.reply must be a number or a one-line non-empty string" };
+}
+function inboundToRawAnswer(gate, parsed) {
+  if (!parsed.ok) return { kind: "stop", cause: "protocol error", detail: parsed.error };
+  const message = parsed.message;
+  if (message.type === "stop") return { kind: "stop", cause: "driver stop" };
+  if (message.askId !== gate.askId) {
+    return {
+      kind: "stop",
+      cause: "protocol error",
+      detail: `reply for ${message.askId} while gate ${gate.askId} is open`
+    };
+  }
+  return { kind: "line", text: String(message.reply) };
+}
+function createDriverAnswerReader(opts) {
+  const input = opts.input ?? process.stdin;
+  const queue = [];
+  let ended = false;
+  let waiter = null;
+  let rl = null;
+  const ensure = () => {
+    if (rl) return;
+    rl = createInterface({ input, terminal: false, crlfDelay: Number.POSITIVE_INFINITY });
+    rl.on("line", (line) => {
+      if (!line.trim()) return;
+      if (waiter) {
+        const w = waiter;
+        waiter = null;
+        w(line);
+      } else queue.push(line);
+    });
+    rl.on("close", () => {
+      ended = true;
+      if (waiter) {
+        const w = waiter;
+        waiter = null;
+        w(null);
+      }
+    });
+  };
+  const nextLine = (signal) => new Promise((resolve) => {
+    const queued = queue.shift();
+    if (queued !== void 0) {
+      resolve(queued);
+      return;
+    }
+    if (ended) {
+      resolve(null);
+      return;
+    }
+    const onAbort = () => {
+      if (waiter === settle) waiter = null;
+      resolve(null);
+    };
+    const settle = (line) => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve(line);
+    };
+    if (signal?.aborted) {
+      resolve(null);
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    waiter = settle;
+  });
+  return {
+    read: async (gate, readOpts) => {
+      ensure();
+      opts.emitter.emit({
+        type: "hitl_gate",
+        tick: opts.tick(),
+        askId: gate.askId,
+        labels: [...gate.labels],
+        detection: gate.detection,
+        line: formatHitlGateLine(gate)
+      });
+      const line = await nextLine(readOpts.signal);
+      if (line === null) return { kind: "eof" };
+      return inboundToRawAnswer(gate, parseDriverInbound(line));
+    },
+    close: () => {
+      const r = rl;
+      rl = null;
+      r?.close();
+      if (typeof input.pause === "function") {
+        input.pause();
+      }
+    }
+  };
+}
+var DriverAgentSink = class {
+  constructor(emitter, tick) {
+    this.emitter = emitter;
+    this.tick = tick;
+  }
+  emitter;
+  tick;
+  pending = "";
+  dropped = false;
+  decoder = new StringDecoder("utf8");
+  feed(chunk) {
+    try {
+      const text = typeof chunk === "string" ? chunk : this.decoder.write(chunk);
+      if (!text) return;
+      const lines = (this.pending + text).split("\n");
+      this.pending = lines.pop() ?? "";
+      for (const line of lines) {
+        if (this.dropped) {
+          this.dropped = false;
+          continue;
+        }
+        this.take(line);
+      }
+      if (this.pending.length > AGENT_PENDING_MAX_CHARS) {
+        this.pending = "";
+        this.dropped = true;
+      }
+    } catch {
+    }
+  }
+  end() {
+    try {
+      const rest = this.pending + this.decoder.end();
+      this.pending = "";
+      if (rest && !this.dropped) this.take(rest);
+      this.dropped = false;
+    } catch {
+    }
+  }
+  take(raw) {
+    const line = raw.replace(/\r$/, "");
+    if (!line.trim()) return;
+    const trimmed = line.trim();
+    if (trimmed.startsWith("{")) {
+      try {
+        const event = JSON.parse(trimmed);
+        if (typeof event === "object" && event !== null && !Array.isArray(event)) {
+          this.emitter.emit({
+            type: "agent_event",
+            tick: this.tick,
+            event
+          });
+          return;
+        }
+      } catch {
+      }
+    }
+    this.emitter.emit({ type: "agent_text", tick: this.tick, text: line });
+  }
+};
+
+export {
+  DRIVER_PROTOCOL_VERSION,
+  DRIVER_EVENTS_FORMATS,
+  createDriverEmitter,
+  createDriverAnswerReader,
+  DriverAgentSink
+};

package/dist/{chunk-VQBI3JVS.js → chunk-TNO7GTAJ.js}

@@ -1,11 +1,11 @@
 import {
   managedPairs
-} from "./chunk-25J2SMJQ.js";
+} from "./chunk-IN4MQ3P3.js";
 import {
   isProtectedPath,
   resolveContained,
   resolveProtectedGlobs
-} from "./chunk-6KUSG7BJ.js";
+} from "./chunk-5WSFO35Y.js";
 
 // src/lifecycle/diff.ts
 import { readFile } from "fs/promises";

package/dist/{chunk-Z7ABX5QI.js → chunk-U7XOLYDG.js}

@@ -1,5 +1,4 @@
 import {
-  RESERVED_GATE_IDS,
   checkClaudeVersion,
   claudeChildEnv,
   claudeHeadlessArgs,
@@ -13,7 +12,10 @@ import {
   redactSecrets,
   resolveHitlRunOptions,
   spawnLogged
-} from "./chunk-JEI6HACW.js";
+} from "./chunk-2TCRKQHD.js";
+import {
+  RESERVED_GATE_IDS
+} from "./chunk-MTLQN57O.js";
 import {
   ensureLoopLogsDir,
   runnerStatePaths