@dadado/agent-kit-cli 6.3.0 → 6.4.0

package/dist/{chunk-NNKOWUWM.js → chunk-HHR56LJQ.js}

@@ -1,6 +1,7 @@
 import {
+  INTERACTIVE_ALLOW_RULES,
   INTERACTIVE_DENY_RULES
-} from "./chunk-MAPOQEA2.js";
+} from "./chunk-6RRG3WOE.js";
 import {
   assertRealContained,
   assertRealParentContained,
@@ -10,7 +11,7 @@ import {
   resolveContained,
   saveManagedHashLedger,
   shouldPreserveCustomizedOverlay
-} from "./chunk-6KUSG7BJ.js";
+} from "./chunk-7BEHUBEJ.js";
 import {
   ensureDir,
   fileExists
@@ -149,17 +150,18 @@ var ClaudeSettingsLedgerInvalidError = class extends Error {
   path;
 };
 function emptyLedger() {
-  return { schemaVersion: 1, denyRowsWritten: [], hookEntriesWritten: [] };
+  return { schemaVersion: 1, denyRowsWritten: [], allowRowsWritten: [], hookEntriesWritten: [] };
 }
 function hookKey(r) {
   return `${r.event}\0${r.marker}`;
 }
-function normalize(denyRows, hooks) {
+function normalize(denyRows, allowRows, hooks) {
   const seen = /* @__PURE__ */ new Map();
   for (const h of hooks) seen.set(hookKey(h), { event: h.event, marker: h.marker });
   return {
     schemaVersion: 1,
     denyRowsWritten: [...new Set(denyRows)].sort(),
+    allowRowsWritten: [...new Set(allowRows)].sort(),
     hookEntriesWritten: [...seen.values()].sort(
       (a, b) => a.event.localeCompare(b.event) || a.marker.localeCompare(b.marker)
     )
@@ -178,6 +180,8 @@ function parseLedger(raw) {
   if (!Array.isArray(o.denyRowsWritten) || !o.denyRowsWritten.every((r) => typeof r === "string")) {
     return null;
   }
+  const allowRows = o.allowRowsWritten ?? [];
+  if (!Array.isArray(allowRows) || !allowRows.every((r) => typeof r === "string")) return null;
   if (!Array.isArray(o.hookEntriesWritten)) return null;
   const hooks = [];
   for (const h of o.hookEntriesWritten) {
@@ -189,7 +193,7 @@ function parseLedger(raw) {
       marker: h.marker
     });
   }
-  return normalize(o.denyRowsWritten, hooks);
+  return normalize(o.denyRowsWritten, allowRows, hooks);
 }
 async function readState(root) {
   const abs = resolveContained(root, CLAUDE_SETTINGS_LEDGER_REL);
@@ -224,6 +228,7 @@ async function saveClaudeSettingsLedger(root, additions, opts = {}) {
   const base = state.kind === "ok" ? state.ledger : emptyLedger();
   const merged = normalize(
     [...base.denyRowsWritten, ...additions.denyRowsWritten ?? []],
+    [...base.allowRowsWritten, ...additions.allowRowsWritten ?? []],
     [...base.hookEntriesWritten, ...additions.hookEntriesWritten ?? []]
   );
   await mkdir(path2.dirname(abs), { recursive: true });
@@ -300,8 +305,12 @@ function mergeSessionStartHookIntoSettings(existingRaw, opts = {}) {
       };
     }
   }
-  const pending = { denyRows: [], hookEntries: [] };
-  const additions = { denyRowsWritten: [], hookEntriesWritten: [] };
+  const pending = { denyRows: [], allowRows: [], hookEntries: [] };
+  const additions = {
+    denyRowsWritten: [],
+    allowRowsWritten: [],
+    hookEntriesWritten: []
+  };
   const hooks = isPlainObject(root.hooks) ? { ...root.hooks } : {};
   const sessionStart = Array.isArray(hooks.SessionStart) ? [...hooks.SessionStart] : [];
   const preToolUse = Array.isArray(hooks.PreToolUse) ? [...hooks.PreToolUse] : [];
@@ -342,8 +351,17 @@ function mergeSessionStartHookIntoSettings(existingRaw, opts = {}) {
     (acc, next, i) => i === 0 ? next : combineStatus(acc, next),
     "unchanged"
   );
-  const denyAdded = mergeKitDenyRules(root, { ledger, authorized }, pending, additions);
-  const finalStatus = denyAdded && status === "unchanged" ? "refreshed" : status;
+  const ctx = { ledger, authorized };
+  const denyAdded = mergeKitRuleRows(root, "deny", INTERACTIVE_DENY_RULES, ctx, pending, additions);
+  const allowAdded = mergeKitRuleRows(
+    root,
+    "allow",
+    INTERACTIVE_ALLOW_RULES,
+    ctx,
+    pending,
+    additions
+  );
+  const finalStatus = (denyAdded || allowAdded) && status === "unchanged" ? "refreshed" : status;
   return {
     content: `${JSON.stringify(root, null, 2)}
 `,
@@ -355,23 +373,25 @@ function mergeSessionStartHookIntoSettings(existingRaw, opts = {}) {
 function combineStatus(a, b) {
   return a === "unchanged" && b !== "unchanged" ? "refreshed" : a;
 }
-function mergeKitDenyRules(root, ctx, pending, additions) {
+function mergeKitRuleRows(root, kind, rules, ctx, pending, additions) {
   if (root.permissions !== void 0 && !isPlainObject(root.permissions)) return false;
   const permissions = isPlainObject(root.permissions) ? { ...root.permissions } : {};
-  if (permissions.deny !== void 0 && !Array.isArray(permissions.deny)) return false;
-  const deny = Array.isArray(permissions.deny) ? [...permissions.deny] : [];
-  const written = new Set(ctx.ledger?.denyRowsWritten ?? []);
-  for (const rule of INTERACTIVE_DENY_RULES) {
-    if (deny.includes(rule)) additions.denyRowsWritten.push(rule);
-  }
-  const missing = INTERACTIVE_DENY_RULES.filter(
-    (rule) => !deny.includes(rule) && !written.has(rule)
+  if (permissions[kind] !== void 0 && !Array.isArray(permissions[kind])) return false;
+  const list = Array.isArray(permissions[kind]) ? [...permissions[kind]] : [];
+  const pendingRows = kind === "deny" ? pending.denyRows : pending.allowRows;
+  const written = kind === "deny" ? additions.denyRowsWritten : additions.allowRowsWritten;
+  const ledgerRows = new Set(
+    (kind === "deny" ? ctx.ledger?.denyRowsWritten : ctx.ledger?.allowRowsWritten) ?? []
   );
+  for (const rule of rules) {
+    if (list.includes(rule)) written.push(rule);
+  }
+  const missing = rules.filter((rule) => !list.includes(rule) && !ledgerRows.has(rule));
   const toAdd = ctx.ledger === null && !ctx.authorized ? [] : missing;
-  if (ctx.ledger === null && !ctx.authorized) pending.denyRows.push(...missing);
+  if (ctx.ledger === null && !ctx.authorized) pendingRows.push(...missing);
   if (toAdd.length === 0) return false;
-  additions.denyRowsWritten.push(...toAdd);
-  permissions.deny = [...deny, ...toAdd];
+  written.push(...toAdd);
+  permissions[kind] = [...list, ...toAdd];
   root.permissions = permissions;
   return true;
 }
@@ -425,7 +445,7 @@ async function writeClaudeSessionStartHook(rootDir, opts = {}) {
     relativePath: CLAUDE_SETTINGS_REL,
     status: merged.status
   };
-  if (merged.pending && (merged.pending.denyRows.length || merged.pending.hookEntries.length)) {
+  if (merged.pending && (merged.pending.denyRows.length || merged.pending.allowRows.length || merged.pending.hookEntries.length)) {
     result.pending = merged.pending;
   }
   if (authorized && merged.ledgerAdditions && ledgerGrows(ledger, merged.ledgerAdditions)) {
@@ -437,8 +457,9 @@ async function writeClaudeSessionStartHook(rootDir, opts = {}) {
 function ledgerGrows(ledger, add) {
   if (ledger === null) return true;
   const rows = new Set(ledger.denyRowsWritten);
+  const allowRows = new Set(ledger.allowRowsWritten);
   const hooks = new Set(ledger.hookEntriesWritten.map((h) => `${h.event}\0${h.marker}`));
-  return add.denyRowsWritten.some((r) => !rows.has(r)) || add.hookEntriesWritten.some((h) => !hooks.has(`${h.event}\0${h.marker}`));
+  return add.denyRowsWritten.some((r) => !rows.has(r)) || add.allowRowsWritten.some((r) => !allowRows.has(r)) || add.hookEntriesWritten.some((h) => !hooks.has(`${h.event}\0${h.marker}`));
 }
 async function planClaudeSettingsDrift(rootDir) {
   const abs = resolveContained(rootDir, CLAUDE_SETTINGS_REL);
@@ -477,17 +498,23 @@ async function planClaudeSettingsDrift(rootDir) {
   const merged = mergeSessionStartHookIntoSettings(raw, { ledger, authorized: false });
   if (merged.content === null) return null;
   const next = JSON.parse(merged.content);
-  const deny = (r) => isPlainObject(r.permissions) && Array.isArray(r.permissions.deny) ? r.permissions.deny.filter((x) => typeof x === "string") : [];
-  const had = new Set(deny(existing));
-  const denyRows = deny(next).filter((r) => !had.has(r));
+  const rowsOf = (r, kind) => {
+    const list = isPlainObject(r.permissions) ? r.permissions[kind] : void 0;
+    return Array.isArray(list) ? list.filter((x) => typeof x === "string") : [];
+  };
+  const hadDeny = new Set(rowsOf(existing, "deny"));
+  const hadAllow = new Set(rowsOf(existing, "allow"));
+  const denyRows = rowsOf(next, "deny").filter((r) => !hadDeny.has(r));
+  const allowRows = rowsOf(next, "allow").filter((r) => !hadAllow.has(r));
   const ambiguousDenyRows = merged.pending?.denyRows ?? [];
+  const ambiguousAllowRows = merged.pending?.allowRows ?? [];
   const missingEntries = kitEntries.filter((e) => !present.includes(e));
   const ledgerHas = (e) => Boolean(ledger?.hookEntriesWritten.some((h) => h.event === e.event && h.marker === e.marker));
   const hookEntries = missingEntries.filter((e) => !ledgerHas(e));
-  if (denyRows.length === 0 && ambiguousDenyRows.length === 0 && hookEntries.length === 0) {
+  if (denyRows.length === 0 && ambiguousDenyRows.length === 0 && allowRows.length === 0 && ambiguousAllowRows.length === 0 && hookEntries.length === 0) {
     return null;
   }
-  return { denyRows, ambiguousDenyRows, hookEntries };
+  return { denyRows, ambiguousDenyRows, allowRows, ambiguousAllowRows, hookEntries };
 }
 function formatClaudeSettingsDrift(report, opts) {
   const rows = [...report.denyRows, ...report.ambiguousDenyRows];
@@ -502,6 +529,15 @@ function formatClaudeSettingsDrift(report, opts) {
       );
     }
   }
+  const allowRows = [...report.allowRows, ...report.ambiguousAllowRows];
+  if (allowRows.length > 0) {
+    lines.push("Add to permissions.allow:", JSON.stringify(allowRows, null, 2));
+    if (report.ambiguousAllowRows.length > 0) {
+      lines.push(
+        `(${report.ambiguousAllowRows.length} row(s) ambiguous: no ${CLAUDE_SETTINGS_LEDGER_REL} ledger, so a deliberate deletion cannot be told apart.)`
+      );
+    }
+  }
   if (report.hookEntries.length > 0) {
     lines.push("Missing hook entries (add by hand or use the command below):");
     for (const e of report.hookEntries) lines.push(`  ${e.event}: ${e.marker}`);

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

@@ -6,7 +6,7 @@ import {
   formatStaleCliRefusal,
   installL0,
   syncFromManifest
-} from "./chunk-Z7RYIHHX.js";
+} from "./chunk-6OTJEQEC.js";
 import {
   SkippedSymlinkError,
   formatPersonalizationSkippedSymlinks,
@@ -15,11 +15,11 @@ import {
 import {
   REGISTRY_CLI_ARGS,
   resolveRegistryFromCli
-} from "./chunk-U26MRIWN.js";
+} from "./chunk-H46W7NHC.js";
 import {
   assessClaudeCommandAdapters,
   executeSafeReadinessFixes
-} from "./chunk-WMVMBPCR.js";
+} from "./chunk-AXLXEAVJ.js";
 import {
   writeReadinessSnapshot
 } from "./chunk-HAFRAXGV.js";
@@ -27,7 +27,7 @@ import {
   CLAUDE_HITL_FALLBACK,
   generateClaudeCommandAdapters,
   writeClaudeSessionStartHook
-} from "./chunk-NNKOWUWM.js";
+} from "./chunk-HHR56LJQ.js";
 import {
   shouldUseWelcomeColor,
   withCliProgress
@@ -54,13 +54,13 @@ import {
   npxPinned,
   pathCliStatus,
   syncPathCliToRuntime
-} from "./chunk-OWWFKGKS.js";
+} from "./chunk-SE7ZIRLX.js";
 import {
   assessEnvironment
 } from "./chunk-B3VR5YBQ.js";
 import {
   warnIfRunningCliBehindNpm
-} from "./chunk-6GYKOHIL.js";
+} from "./chunk-3OM7JODZ.js";
 import {
   DOMAIN_PACK_IDS,
   allPacks,
@@ -77,7 +77,7 @@ import {
   resolveProtectedGlobs,
   saveManifest,
   skillTargetDir
-} from "./chunk-6KUSG7BJ.js";
+} from "./chunk-7BEHUBEJ.js";
 import {
   KIT_VERSION,
   pinnedCliSpec

package/dist/chunk-IRTS7WEA.js

@@ -0,0 +1,374 @@
+// 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 = [];
+  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") : []
+      });
+    }
+  }
+};
+
+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-MO63KZBP.js → chunk-KX3OUY4W.js}

@@ -1,6 +1,6 @@
 import {
   isBranchInBase
-} from "./chunk-QTBTKEXK.js";
+} from "./chunk-ZPZVROS5.js";
 import {
   GATE_EXIT_BRANCH_PREFIX,
   GATE_EXIT_NOTE_DIR,
@@ -11,7 +11,7 @@ import {
   isSafeBaseRef,
   landGateExit,
   resolveGateExitRefs
-} from "./chunk-KVY425NM.js";
+} from "./chunk-TZ5XYIEF.js";
 import {
   ensurePathIgnored
 } from "./chunk-MUTTNRX4.js";
@@ -19,12 +19,14 @@ import {
   ensureDispatchLogPath,
   readCommandFile,
   runHeadlessDispatch
-} from "./chunk-Z7ABX5QI.js";
+} from "./chunk-WOHZ4T5V.js";
 import {
-  formatHitlSummary,
-  hitlExitCode,
   redactSecrets
-} from "./chunk-JEI6HACW.js";
+} from "./chunk-NJVWTROP.js";
+import {
+  formatHitlSummary,
+  hitlExitCode
+} from "./chunk-IRTS7WEA.js";
 
 // src/plan-loop/review-job.ts
 import { randomBytes } from "crypto";