claudish 12.0.1 → 12.1.1

package/dist/index.js

@@ -901,7 +901,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "12.0.1";
+var VERSION = "12.1.1";
 
 // src/logger.ts
 import { appendFile, existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
@@ -45606,7 +45606,8 @@ var init_contract = __esm(() => {
     "cancel",
     "capture",
     "capture_since_seq",
-    "capture_spans"
+    "capture_spans",
+    "resize"
   ];
   SLOT_STATES = [
     "STARTING",
@@ -63874,6 +63875,20 @@ function resolveClaudishSpawn(env = process.env) {
 }
 var CLAUDISH_BIN_ENV = "CLAUDISH_BIN";
 
+// src/pane/pane-size.ts
+function clamp(n, lo, hi) {
+  return Math.min(hi, Math.max(lo, Math.trunc(n)));
+}
+function clampPaneSize(cols, rows) {
+  const c = clamp(cols, MIN_PANE_COLS, MAX_PANE_COLS);
+  const r = clamp(rows, MIN_PANE_ROWS, MAX_PANE_ROWS);
+  return { cols: c, rows: Math.min(r, Math.floor(MAX_PANE_CELLS / c)) };
+}
+function samePaneSize(a, b) {
+  return !!a && !!b && a.cols === b.cols && a.rows === b.rows;
+}
+var DEFAULT_PANE_COLS = 160, DEFAULT_PANE_ROWS = 50, MIN_PANE_COLS = 80, MAX_PANE_COLS = 9999, MIN_PANE_ROWS = 24, MAX_PANE_ROWS = 9999, MAX_PANE_CELLS = 4000000, RESIZE_QUIET_MS = 2000;
+
 // src/pane/process-identity.ts
 import { execFile, execFileSync as execFileSync2 } from "child_process";
 import { lstatSync } from "fs";
@@ -64217,12 +64232,6 @@ function mintPaneId(kind, label) {
     throw new Error(`minted an invalid pane id: ${id}`);
   return id;
 }
-function sockPathFor(root, id) {
-  const p = sockPathOf(root, id);
-  if (Buffer.byteLength(p) >= 100)
-    throw new PaneRootError(`pane socket path ${p} is ${Buffer.byteLength(p)} bytes; it must be < 100`);
-  return p;
-}
 function isStrippedFromChildEnv(key) {
   return STRIPPED_CHILD_VARS.includes(key) || key.startsWith("MAGMUX_") || TERMINAL_IDENTITY_VARS.includes(key) || TERMINAL_IDENTITY_PREFIXES.some((p) => key.startsWith(p)) || HOST_IDENTITY_VARS.includes(key);
 }
@@ -64233,8 +64242,8 @@ function buildPaneEnv(input) {
       continue;
     env[k] = v;
   }
-  env.COLUMNS = "160";
-  env.LINES = "50";
+  env.COLUMNS = String(input.cols ?? DEFAULT_PANE_COLS);
+  env.LINES = String(input.rows ?? DEFAULT_PANE_ROWS);
   if (input.parentEnv.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC === undefined)
     env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
   Object.assign(env, input.slotEnv);
@@ -64360,24 +64369,46 @@ function versionAtLeast(v, min) {
   return true;
 }
 async function assertMagmuxAvailable(binary) {
-  const cached = magmuxCache.get(binary ?? "");
+  const key = binary ?? "";
+  const cached = magmuxCache.get(key);
   if (cached)
     return cached;
+  const inFlight = magmuxProbes.get(key);
+  if (inFlight)
+    return inFlight;
+  const probe = (async () => {
+    try {
+      const result = await probeMagmux(binary);
+      magmuxCache.set(key, result);
+      return result;
+    } finally {
+      magmuxProbes.delete(key);
+    }
+  })();
+  magmuxProbes.set(key, probe);
+  return probe;
+}
+async function probeMagmux(binary) {
   const found = binary ?? findMagmuxBinaryOrNull();
   if (!found)
     throw new MagmuxUnavailableError("magmux_unavailable: magmux not found (bundled package or PATH); install it: brew install MadAppGang/tap/magmux");
+  let version = await readMagmuxVersion(found);
+  if (!version)
+    version = await readMagmuxVersion(found);
+  if (!version || !versionAtLeast(version, MIN_MAGMUX_VERSION))
+    throw new MagmuxUnavailableError(`magmux_unavailable: ${found} is version ${version || "unknown"}; panes need >= ${MIN_MAGMUX_VERSION} (a socket at any path depth, and the Claude Code input gate bound to a named transcript); upgrade: brew upgrade MadAppGang/tap/magmux`);
+  return { binary: found, version };
+}
+async function readMagmuxVersion(found) {
   let out = "";
   try {
-    out = (await execFileAsync(found, ["--version"], { encoding: "utf8", timeout: 5000 })).stdout;
+    const r = await execFileAsync(found, ["--version"], { encoding: "utf8", timeout: 5000 });
+    out = `${r.stdout}
+${r.stderr}`;
   } catch (e) {
     throw new MagmuxUnavailableError(`magmux_unavailable: ${found} --version failed: ${e instanceof Error ? e.message : String(e)}`);
   }
-  const version = out.match(/(\d+\.\d+\.\d+)/)?.[1] ?? "";
-  if (!version || !versionAtLeast(version, MIN_MAGMUX_VERSION))
-    throw new MagmuxUnavailableError(`magmux_unavailable: ${found} is version ${version || "unknown"}; panes need >= ${MIN_MAGMUX_VERSION}`);
-  const result = { binary: found, version };
-  magmuxCache.set(binary ?? "", result);
-  return result;
+  return out.match(/(\d+\.\d+\.\d+)/)?.[1] ?? "";
 }
 function resolveClaudishLaunch(parentEnv) {
   const t = resolveClaudishSpawn(parentEnv);
@@ -64426,21 +64457,35 @@ function spawnPaneWatcher(args) {
   proc.stdin?.unref?.();
   return proc;
 }
-function spawnPaneMagmux(input) {
-  const proc = spawn(input.binary, [
+function paneMagmuxArgv(input) {
+  return [
     "--headless",
     "--no-status",
+    "--controller",
+    "claude-code",
+    "--session-id",
+    input.sessionUuid,
+    "--transcript",
+    resolve3(input.transcriptPath),
     "--id",
     input.paneId,
     "--sock-dir",
     input.sockRoot,
     "-e",
     paneCommand(input.ctlDir)
-  ], { cwd: input.cwd, env: input.env, stdio: ["ignore", "ignore", "pipe"], detached: true });
+  ];
+}
+function spawnPaneMagmux(input) {
+  const proc = spawn(input.binary, paneMagmuxArgv(input), {
+    cwd: input.cwd,
+    env: input.env,
+    stdio: ["ignore", "ignore", "pipe"],
+    detached: true
+  });
   proc.on("error", () => {});
   return proc;
 }
-var SOCK_ROOT, PaneRootError, OWNER_START36, TERMINAL_IDENTITY_VARS, TERMINAL_IDENTITY_PREFIXES, HOST_IDENTITY_VARS, LINUX_ENV_STRING_LIMIT = 131000, PaneEnvTooLargeError, OWN_ARGV, TRANSPORT_BREAKERS, IDENTITY_BREAKERS, PRINT_ONLY_FLAGS, MODE_FLAGS, SUBCOMMAND_WORDS, CLAUDE_CODE_VALUE_FLAGS, KNOWN_CLAUDISH_FLAGS, MIN_MAGMUX_VERSION = "0.14.0", MagmuxUnavailableError, magmuxCache, execFileAsync, ClaudishNotFoundError, SHELL_SHIM = `#!/bin/sh
+var SOCK_ROOT, PaneRootError, OWNER_START36, TERMINAL_IDENTITY_VARS, TERMINAL_IDENTITY_PREFIXES, HOST_IDENTITY_VARS, LINUX_ENV_STRING_LIMIT = 131000, PaneEnvTooLargeError, OWN_ARGV, TRANSPORT_BREAKERS, IDENTITY_BREAKERS, PRINT_ONLY_FLAGS, MODE_FLAGS, SUBCOMMAND_WORDS, CLAUDE_CODE_VALUE_FLAGS, KNOWN_CLAUDISH_FLAGS, MIN_MAGMUX_VERSION = "0.18.0", MagmuxUnavailableError, magmuxCache, magmuxProbes, execFileAsync, ClaudishNotFoundError, SHELL_SHIM = `#!/bin/sh
 [ "$1" = -l ] && shift
 exec /bin/sh "$@"
 `, FATAL_MAGMUX_STDERR;
@@ -64614,15 +64659,30 @@ var init_pane_launch = __esm(() => {
     code = "magmux_unavailable";
   };
   magmuxCache = new Map;
+  magmuxProbes = new Map;
   execFileAsync = promisify5(execFile2);
   ClaudishNotFoundError = class ClaudishNotFoundError extends Error {
     code = "pane_lost";
   };
-  FATAL_MAGMUX_STDERR = /ignoring --id|ignoring --sock-dir|magmux: socket/;
+  FATAL_MAGMUX_STDERR = /ignoring --id|magmux: (?:--sock-dir|MAGMUX_SOCK_DIR) |magmux: socket/;
 });
 
 // src/pane/magmux-client.ts
 import { Socket } from "net";
+function failureOf(m) {
+  const out = {
+    ok: false,
+    code: String(m.code ?? "error"),
+    error: String(m.error ?? "")
+  };
+  if (typeof m.reason === "string" && m.reason)
+    out.reason = m.reason;
+  if (typeof m.typed === "boolean")
+    out.typed = m.typed;
+  if (typeof m.maybeSubmitted === "boolean")
+    out.maybeSubmitted = m.maybeSubmitted;
+  return out;
+}
 function dialOnce(sockPath) {
   return new Promise((resolve, reject) => {
     const s = new Socket;
@@ -64749,7 +64809,7 @@ class MagmuxClient {
         return;
       clearTimeout(p.timer);
       this.pending.delete(m.id);
-      p.resolve(m.ok === true ? { ok: true, result: m.result ?? {} } : { ok: false, code: String(m.code ?? "error"), error: String(m.error ?? "") });
+      p.resolve(m.ok === true ? { ok: true, result: m.result ?? {} } : failureOf(m));
       return;
     }
     if (m.type === "shutdown")
@@ -65247,6 +65307,352 @@ var init_process_tree = __esm(() => {
   KILL_PROCESS_GROUP = process.platform !== "win32";
 });
 
+// src/pane/box-locate.ts
+function isRuleRow(line) {
+  if (!line || line.length < MIN_RULE_CELLS)
+    return false;
+  return /^\u2500+(?: [^\u2500]+ \u2500+)?$/.test(line);
+}
+function nearestRule(lines, from, step) {
+  for (let i = 1;i <= RULE_SEARCH_ROWS; i++) {
+    const r = from + i * step;
+    if (r < 0 || r >= lines.length)
+      return -1;
+    if (isRuleRow(lines[r]))
+      return r;
+  }
+  return -1;
+}
+function inspectBox(s) {
+  const lines = s.lines;
+  const y = s.cursor.y;
+  if (!Number.isInteger(y) || y < 0 || y >= s.rows || y >= lines.length) {
+    return { kind: "unknown", why: "cursor_off_screen" };
+  }
+  if (SELECTED_OPTION.test(lines[y] ?? ""))
+    return { kind: "dialog", why: "selected_option" };
+  const top = nearestRule(lines, y, -1);
+  if (top < 0)
+    return { kind: "unknown", why: "no_rule_above" };
+  const bottom = nearestRule(lines, y, 1);
+  if (bottom < 0)
+    return { kind: "unknown", why: "no_rule_below" };
+  const first = lines[top + 1] ?? "";
+  if (SELECTED_OPTION.test(first))
+    return { kind: "dialog", why: "selected_option" };
+  if (lines.slice(bottom + 1).some((l) => SELECT_FOOTER.test(l))) {
+    return { kind: "dialog", why: "select_footer" };
+  }
+  if (!PROMPT_ROW.test(first))
+    return { kind: "unknown", why: "no_prompt_row" };
+  return { kind: "box", box: { top, bottom, caretRow: y } };
+}
+function locateBox(s) {
+  const at = inspectBox(s);
+  return at.kind === "box" ? at.box : null;
+}
+function visibleText(line, spans) {
+  if (!spans?.length)
+    return line;
+  const chars = Array.from(line);
+  for (const [col, len, , , attr] of spans) {
+    if ((attr & ATTR_FAINT) === 0)
+      continue;
+    for (let c = col;c < col + len && c < chars.length; c++)
+      chars[c] = " ";
+  }
+  return chars.join("");
+}
+function locatedBoxText(s, box) {
+  const parts = [];
+  for (let i = box.top + 1;i < box.bottom; i++) {
+    const raw = visibleText(s.lines[i] ?? "", s.spans[i]);
+    const body = i === box.top + 1 ? raw.replace(/^[\u276F!]\s?/, "") : raw.replace(/^ {2}/, "");
+    parts.push(body.replace(/\s+$/, ""));
+  }
+  return parts.join(`
+`).trim();
+}
+var RULE_SEARCH_ROWS = 40, MIN_RULE_CELLS = 20, PROMPT_ROW, SELECTED_OPTION, SELECT_FOOTER, ATTR_FAINT = 2;
+var init_box_locate = __esm(() => {
+  PROMPT_ROW = /^(\u276F(\u00A0|$)|!)/;
+  SELECTED_OPTION = /^ *\u276F \d+\.\s+\S/;
+  SELECT_FOOTER = /Enter to select \u00B7 \u2191\/\u2193 to navigate/;
+});
+
+// src/pane/input-gate.ts
+function dialogKindOf(reason) {
+  if (!reason?.startsWith(DIALOG_PREFIX))
+    return null;
+  const kind = reason.slice(DIALOG_PREFIX.length);
+  return DIALOG_KINDS.has(kind) ? kind : null;
+}
+function str3(v) {
+  return typeof v === "string" && v !== "" ? v : null;
+}
+function record4(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function paneZero(listResult) {
+  const panes = record4(listResult)?.panes;
+  if (!Array.isArray(panes))
+    return null;
+  for (const p of panes) {
+    const row = record4(p);
+    if (row?.pane === 0)
+      return row;
+  }
+  return null;
+}
+function parseGateInput(listResult, now) {
+  const input = record4(paneZero(listResult)?.input);
+  if (!input || typeof input.ready !== "boolean")
+    return null;
+  const reason = input.ready ? null : str3(input.reason);
+  return {
+    ready: input.ready,
+    reason,
+    dialog: dialogKindOf(reason),
+    detail: str3(input.detail),
+    receivedAt: now
+  };
+}
+function gateBasisOf(listResult) {
+  const basis = paneZero(listResult)?.gateBasis;
+  return basis === "direct" || basis === "declared" ? basis : null;
+}
+function parseGateBinding(listResult) {
+  const row = paneZero(listResult);
+  if (!row)
+    return null;
+  const boundRaw = str3(row.bound);
+  const sessionId = str3(row.sessionId);
+  const transcriptPath = str3(row.transcriptPath);
+  let bound = "unbound";
+  if (sessionId && transcriptPath) {
+    if (boundRaw === "named" || boundRaw === "prompt" || boundRaw === "mtime")
+      bound = boundRaw;
+  }
+  return { bound, boundRaw, sessionId, transcriptPath };
+}
+function assertNever(x) {
+  throw new Error(`unreachable: ${JSON.stringify(x)}`);
+}
+function retypeOf(result) {
+  if (result.retyped !== true)
+    return { retyped: false, retypeCause: null };
+  const cause = result.retypeCause;
+  return {
+    retyped: true,
+    retypeCause: cause === "terminal_reset" || cause === "never_drawn" ? cause : "unknown"
+  };
+}
+function okOutcome(result) {
+  const { retyped, retypeCause } = retypeOf(result);
+  const waitedMs = typeof result.waitedMs === "number" ? result.waitedMs : 0;
+  const verified = str3(result.verified);
+  const accept = result.accept;
+  if (accept === "in_box")
+    return { kind: "in_box", retyped, retypeCause, waitedMs, verified };
+  if (accept === undefined) {
+    return {
+      kind: "unexpected",
+      code: "ungated_reply",
+      error: "ok with no accept: the pane is not gated"
+    };
+  }
+  if (accept !== "confirmed" && accept !== "resent_enter" && accept !== "submitted_by_other") {
+    return {
+      kind: "unexpected",
+      code: "unknown_accept",
+      error: `accept ${JSON.stringify(accept)}`
+    };
+  }
+  const evidence = result.evidence;
+  if (evidence !== "history" && evidence !== "transcript") {
+    return {
+      kind: "unexpected",
+      code: "unknown_evidence",
+      error: `accept ${accept} with evidence ${JSON.stringify(evidence)}`
+    };
+  }
+  const dismissed = Array.isArray(result.dismissed) ? result.dismissed.filter((d) => typeof d === "string") : [];
+  return {
+    kind: "accepted",
+    accept,
+    evidence,
+    enterByMagmux: result.enter === true,
+    retyped,
+    retypeCause,
+    dismissed,
+    waitedMs,
+    verified
+  };
+}
+function notAcceptedOutcome(r) {
+  const typed = r.typed === true;
+  switch (r.reason) {
+    case "text_mismatch":
+      return {
+        kind: "not_accepted",
+        reason: "text_mismatch",
+        maybeSubmitted: r.maybeSubmitted === true || r.error.includes(MAYBE_SUBMITTED_MARKER),
+        typed,
+        detail: r.error
+      };
+    case "empty_box":
+    case "still_in_box":
+    case "unconfirmed":
+      return {
+        kind: "not_accepted",
+        reason: r.reason,
+        maybeSubmitted: false,
+        typed,
+        detail: r.error
+      };
+    default:
+      return {
+        kind: "unexpected",
+        code: `not_accepted:${r.reason ?? ""}`,
+        error: r.error
+      };
+  }
+}
+function classifySendReply(r) {
+  if (r.ok)
+    return okOutcome(record4(r.result) ?? {});
+  switch (r.code) {
+    case "busy": {
+      const reason = r.reason ?? "";
+      return { kind: "busy", reason, dialog: dialogKindOf(reason), typed: r.typed === true };
+    }
+    case "not_accepted":
+      return notAcceptedOutcome(r);
+    case "bad_request":
+      return { kind: "bad_request", error: r.error };
+    case "client_timeout":
+    case "client_lost":
+    case "timeout":
+      return { kind: "reply_lost", code: r.code };
+    case "client_closed":
+    case "no_client":
+      return { kind: "unsent", code: r.code };
+    case "pane_dead":
+    case "no_such_pane":
+      return { kind: "pane_gone", code: r.code, typed: r.typed === true };
+    default:
+      return { kind: "unexpected", code: r.code, error: r.error };
+  }
+}
+function readyWaitMs(readyTimeoutMs) {
+  if (readyTimeoutMs <= 0)
+    return SEND_READY_WAIT_DEFAULT_MS;
+  return Math.min(readyTimeoutMs, SEND_READY_WAIT_MAX_MS);
+}
+function typedWriteCount(text) {
+  const rs = Array.from(text);
+  let n = 0;
+  let run = 0;
+  for (let i = 0;i < rs.length; i++) {
+    const r = rs[i];
+    if (r === "\r" || r === `
+`) {
+      if (r === "\r" && rs[i + 1] === `
+`)
+        i++;
+      if (run > 0) {
+        n++;
+        run = 0;
+      }
+      n++;
+    } else {
+      run++;
+      if (run === SEND_TYPED_CHUNK_RUNES) {
+        n++;
+        run = 0;
+      }
+    }
+  }
+  return run > 0 ? n + 1 : n;
+}
+function sendBudgetMs(s) {
+  let attempt = 0;
+  if (s.typed ?? true)
+    attempt += typedWriteCount(s.text) * (SEND_TYPED_CHUNK_GAP_MS + SEND_GATE_CHECK_COST_MS);
+  attempt += s.keys * (SEND_KEY_GAP_MS + SEND_GATE_CHECK_COST_MS);
+  attempt += SEND_SETTLE_MS + SEND_VERIFY_MIN_MS + SEND_VERIFY_STEP_MS;
+  const accept = s.submit ? SEND_ACCEPT_WINDOWS * SEND_ACCEPT_WINDOW_MS : 0;
+  return readyWaitMs(s.readyTimeoutMs) + 2 * attempt + accept + SEND_BUDGET_SLACK_MS;
+}
+var DIALOG_KINDS, BOOT_DIALOG_KINDS, DIALOG_PREFIX = "dialog:", MAYBE_SUBMITTED_MARKER = "check the conversation before sending", SEND_READY_WAIT_DEFAULT_MS = 1e4, SEND_READY_WAIT_MAX_MS = 60000, SEND_TYPED_CHUNK_RUNES = 32, SEND_TYPED_CHUNK_GAP_MS = 8, SEND_KEY_GAP_MS = 20, SEND_SETTLE_MS = 150, SEND_VERIFY_MIN_MS = 1200, SEND_VERIFY_STEP_MS = 40, SEND_GATE_CHECK_COST_MS = 2, SEND_ACCEPT_WINDOW_MS = 2000, SEND_ACCEPT_WINDOWS = 3, SEND_BUDGET_SLACK_MS = 2000;
+var init_input_gate = __esm(() => {
+  DIALOG_KINDS = new Set([
+    "permission",
+    "question",
+    "plan",
+    "select",
+    "trust",
+    "bypass",
+    "api_key",
+    "onboarding"
+  ]);
+  BOOT_DIALOG_KINDS = new Set([
+    "trust",
+    "bypass",
+    "api_key",
+    "onboarding"
+  ]);
+});
+
+// src/pane/gate-binding.ts
+import { realpathSync as realpathSync2 } from "fs";
+import { basename as basename2, dirname as dirname14, join as join45, resolve as resolve4 } from "path";
+function normaliseTranscriptPath(p) {
+  const abs = resolve4(p);
+  const tail = [];
+  let cur = abs;
+  for (;; ) {
+    try {
+      return tail.length ? join45(realpathSync2(cur), ...tail.reverse()) : realpathSync2(cur);
+    } catch {
+      const parent = dirname14(cur);
+      if (parent === cur)
+        return abs;
+      tail.push(basename2(cur));
+      cur = parent;
+    }
+  }
+}
+function checkGateBinding(listResult, expected) {
+  const v = expected.magmuxVersion || "?";
+  const basis = gateBasisOf(listResult);
+  if (basis !== "declared" || !parseGateInput(listResult, 0)) {
+    return {
+      ok: false,
+      detail: `input_gate_unavailable: magmux ${v} did not gate pane 0 (gateBasis ${basis ?? "none"})`
+    };
+  }
+  const b = parseGateBinding(listResult);
+  const ours = normaliseTranscriptPath(expected.transcriptPath);
+  const theirs = b?.transcriptPath ? normaliseTranscriptPath(b.transcriptPath) : null;
+  const differs = [];
+  if (b?.bound !== "named" && b?.boundRaw !== "named")
+    differs.push(`bound ${b?.boundRaw ?? "none"}`);
+  if (b?.sessionId !== expected.sessionUuid)
+    differs.push(`sessionId ${b?.sessionId ?? "none"}, not ${expected.sessionUuid}`);
+  if (theirs !== ours)
+    differs.push(`transcriptPath ${theirs ?? "none"}, not ${ours}`);
+  if (b?.bound === "named" && differs.length === 0)
+    return { ok: true };
+  return {
+    ok: false,
+    detail: `input_gate_unbound: magmux ${v} bound pane 0 to ${theirs ?? "none"} (${b?.boundRaw ?? "none"}), not ${ours}: ${differs.join("; ")}`
+  };
+}
+var init_gate_binding = __esm(() => {
+  init_input_gate();
+});
+
 // src/pane/screen-model.ts
 function emptyScreen(cols, rows) {
   return {
@@ -65264,7 +65670,7 @@ function emptyScreen(cols, rows) {
 function isBoxRule(line, cols) {
   if (!line || !/^\u2500+(?: [^\u2500]+ \u2500+)?$/.test(line))
     return false;
-  return line.length >= Math.max(20, Math.min(cols, 160) - 1);
+  return line.length >= Math.max(20, cols - 1);
 }
 function boxTopRow(lines, cols) {
   for (let i = lines.length - 2;i >= 0; i--) {
@@ -65288,22 +65694,26 @@ function withSize(s, rows) {
     spans.push([]);
   return { lines, spans };
 }
-function aboveBoxText(lines, cols) {
-  const top = boxTopRow(lines, cols);
-  return (top >= 0 ? lines.slice(0, top) : lines).join(`
-`);
+function aboveBoxText(s) {
+  const box = locateBox(s);
+  return box ? s.lines.slice(0, box.top).join(`
+`) : null;
 }
 function finish(prev, next, now) {
   const visible = prev.seq === 0 || prev.cols !== next.cols || prev.rows !== next.rows || prev.alt !== next.alt || prev.cursor.x !== next.cursor.x || prev.cursor.y !== next.cursor.y || next.lines.some((l, i) => l !== prev.lines[i]) || next.spans.some((r, i) => !sameSpans(r, prev.spans[i]));
   if (!visible)
     return prev;
-  const aboveChanged = prev.seq === 0 || aboveBoxText(prev.lines, prev.cols) !== aboveBoxText(next.lines, next.cols);
-  return {
+  const out = {
     ...next,
     seq: prev.seq + 1,
     changedAt: now,
-    aboveBoxChangedAt: aboveChanged ? now : prev.aboveBoxChangedAt
+    aboveBoxChangedAt: prev.aboveBoxChangedAt
   };
+  const before = prev.seq === 0 ? null : aboveBoxText(prev);
+  const after = aboveBoxText(out);
+  if (before === null || after === null || before !== after)
+    out.aboveBoxChangedAt = now;
+  return out;
 }
 function applyFrame(s, frame, now = Date.now()) {
   const rows = frame.rows;
@@ -65328,6 +65738,9 @@ function applyFrame(s, frame, now = Date.now()) {
     alt: frame.alt ?? s.alt
   }, now);
 }
+var init_screen_model = __esm(() => {
+  init_box_locate();
+});
 
 // src/pane/screen-classifier.ts
 function screenText(s) {
@@ -65337,18 +65750,44 @@ function screenText(s) {
   return lines.join(`
 `);
 }
-function visibleText(line, spans) {
+function flatText(lines) {
+  return lines.join(" ").replace(/\s+/g, " ").trim();
+}
+function squash(s) {
+  return s.replace(/\s+/g, "");
+}
+function echoHeadLength(cols) {
+  return Math.max(1, Math.min(40, cols - 4));
+}
+function echoHead(line, cols) {
+  return line.slice(0, echoHeadLength(cols));
+}
+function visibleText2(line, spans) {
   if (!spans?.length)
     return line;
   const chars = Array.from(line);
   for (const [col, len, , , attr] of spans) {
-    if ((attr & ATTR_FAINT) === 0)
+    if ((attr & ATTR_FAINT2) === 0)
       continue;
     for (let c = col;c < col + len && c < chars.length; c++)
       chars[c] = " ";
   }
   return chars.join("");
 }
+function echoAt(lines, i, head) {
+  const first = lines[i] ?? "";
+  if (!first.startsWith("\u276F "))
+    return false;
+  const want = squash(head);
+  let got = squash(first.slice(2));
+  for (let j = i + 1;got.length < want.length && j < lines.length; j++) {
+    const row = lines[j] ?? "";
+    if (!/^ {2}\S/.test(row))
+      break;
+    got += squash(row);
+  }
+  return got.startsWith(want);
+}
 function inputBox(s) {
   const top = boxTopRow(s.lines, s.cols);
   if (top < 0)
@@ -65367,7 +65806,7 @@ function boxBottomRow(s, top) {
 function boxText(s, top, bottom) {
   const parts = [];
   for (let i = top + 1;i < bottom; i++) {
-    const raw = visibleText(s.lines[i] ?? "", s.spans[i]);
+    const raw = visibleText2(s.lines[i] ?? "", s.spans[i]);
     const body = i === top + 1 ? raw.replace(/^\u276F\s?/, "") : raw.replace(/^ {2}/, "");
     parts.push(body.replace(/\s+$/, ""));
   }
@@ -65400,7 +65839,8 @@ function choiceDialog(s) {
   const lines = s.lines;
   const start = lastBulletRow(lines) + 1;
   const below = lines.slice(start);
-  const kind = CHOICE_DIALOGS.find((d) => below.some((l) => d.header.test(l)))?.kind;
+  const flat = flatText(below);
+  const kind = CHOICE_DIALOGS.find((d) => d.header.test(flat))?.kind;
   if (!kind)
     return null;
   if (!below.some((l) => FIRST_OPTION.test(l)))
@@ -65408,14 +65848,19 @@ function choiceDialog(s) {
   return { kind, text: below.filter((l) => l.trim()).join(`
 `) };
 }
-function hasChoiceDialog(s) {
-  return choiceDialog(s) !== null;
+function dialogText(s) {
+  return s.lines.slice(lastBulletRow(s.lines) + 1).filter((l) => l.trim()).join(`
+`);
 }
 function isWorking(s) {
   const top = boxTopRow(s.lines, s.cols);
   const region = top >= 0 ? s.lines.slice(0, top) : s.lines;
   return region.some((l) => WORKING_ROW.test(l));
 }
+function workingAboveBox(s) {
+  const box = locateBox(s);
+  return box ? s.lines.slice(0, box.top).some((l) => WORKING_ROW.test(l)) : null;
+}
 function stopHookRunning(s) {
   return s.lines.some((l) => /\(running Stop hook\b/.test(l));
 }
@@ -65447,7 +65892,7 @@ function screenAnswer(s, echo) {
   const lines = s.lines;
   const top = boxTopRow(lines, s.cols);
   const end = top >= 0 ? top : lines.length;
-  const start = echoRow(lines, end, `\u276F ${echo.slice(0, 40)}`) + 1;
+  const start = echoRow(lines, end, echoHead(echo, s.cols)) + 1;
   if (start <= 0)
     return "";
   const out = [];
@@ -65462,8 +65907,9 @@ function screenAnswer(s, echo) {
 `).trim();
 }
 function echoRow(lines, end, head) {
+  const above = lines.slice(0, end);
   for (let i = end - 1;i >= 0; i--)
-    if ((lines[i] ?? "").startsWith(head))
+    if (echoAt(above, i, head))
       return i;
   return -1;
 }
@@ -65485,9 +65931,9 @@ function agentRejectedLine(text) {
   const m = text.match(/--agent '([^']+)' not found\.(?: Available agents:[^\n]*)?/);
   return m ? m[0] : null;
 }
-function namedDialog(text) {
+function namedDialog(flat) {
   for (const d of NAMED_DIALOGS)
-    if (text.includes(d.marker))
+    if (flat.includes(d.marker))
       return d.name;
   return null;
 }
@@ -65496,22 +65942,20 @@ function isUnnamedChoice(lines) {
   const yesNo = lines.some((l) => /^\s*(\u276F\s*)?(\d+\.\s+)?(Yes|No)\b|\(esc\)/.test(l));
   if (numbered && yesNo)
     return true;
-  return lines.some((l) => /Press Enter to continue/.test(l) || SELECT_FOOTER.test(l));
-}
-function readBoot(s) {
-  const text = screenText(s);
-  const box = inputBox(s);
-  const named = namedDialog(text);
-  if (box && !named)
-    return box.text === "" ? { kind: "repl" } : { kind: "booting" };
+  return lines.some((l) => /Press Enter to continue/.test(l) || SELECT_FOOTER2.test(l));
+}
+function nameBootScreen(s) {
+  const named = namedDialog(flatText(s.lines));
   if (named)
-    return { kind: "dialog", name: named, text };
+    return { kind: "dialog", name: named, text: screenText(s) };
   if (isUnnamedChoice(s.lines))
-    return { kind: "choice", text };
+    return { kind: "choice", text: screenText(s) };
   return { kind: "booting" };
 }
-var NAMED_DIALOGS, CHOICE_DIALOGS, NUMBERED_OPTION, FIRST_OPTION, SELECT_FOOTER, WORKING_ROW, BULLET, ERROR_ROW, ATTR_FAINT = 2, MENU_ROW, NON_ANSWER_ROW;
+var NAMED_DIALOGS, CHOICE_DIALOGS, NUMBERED_OPTION, FIRST_OPTION, SELECT_FOOTER2, WORKING_ROW, BULLET, ERROR_ROW, ATTR_FAINT2 = 2, MENU_ROW, NON_ANSWER_ROW;
 var init_screen_classifier = __esm(() => {
+  init_box_locate();
+  init_screen_model();
   NAMED_DIALOGS = [
     { name: "onboarding", marker: "Choose the text style" },
     { name: "trust", marker: "Is this a project you created or one you trust" },
@@ -65522,15 +65966,15 @@ var init_screen_classifier = __esm(() => {
     { kind: "permission", header: /\bDo you want to proceed\?/ },
     {
       kind: "permission",
-      header: /\bDo you want to (create|make this edit to|overwrite|delete) .+\?/
+      header: /\bDo you want to (create|make this edit to|overwrite|delete) .{1,300}?\?/
     },
     { kind: "plan", header: /\bWould you like to proceed\?/ },
     { kind: "question", header: /Enter to select \u00B7 \u2191\/\u2193 to navigate/ }
   ];
   NUMBERED_OPTION = /^\s*(\u276F\s*)?\d+\.\s+\S/;
   FIRST_OPTION = /^\s*(\u276F\s*)?1\.\s+\S/;
-  SELECT_FOOTER = /Enter to (confirm|select)\b.*Esc to cancel/;
-  WORKING_ROW = /^\s*[\u00B7\u2722\u2733\u2736\u273B\u273D*\u25CF\u2217]\s+[A-Z][\w'-]*\u2026(\s+\(.*\))?\s*$/;
+  SELECT_FOOTER2 = /Enter to (confirm|select)\b.*Esc to cancel/;
+  WORKING_ROW = /^\s*[\u00B7\u2722\u2733\u2736\u273B\u273D*\u25CF\u2217]\s+[A-Z][\w'-]*\u2026(\s+\((?:.*\)|[^)]*))?\s*$/;
   BULLET = /^\u23FA(\s|$)/;
   ERROR_ROW = /^\u23FA\s.*(API Error\b|Please run \/login|Not logged in|You've hit your|session limit)|^\s*\u23BF\s+API Error\b/;
   MENU_ROW = /^\s{2}\u276F \/\S|^\s{4}\/\S|^\s{4}[*+] \S/;
@@ -65539,7 +65983,7 @@ var init_screen_classifier = __esm(() => {
 
 // src/pane/session-registry.ts
 import { readFileSync as readFileSync29, readdirSync as readdirSync6 } from "fs";
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 function parseRegistryRecord(raw) {
   let parsed;
   try {
@@ -65584,7 +66028,7 @@ class SessionRegistry {
   isAlive;
   constructor(o) {
     this.o = o;
-    this.dir = join45(o.configDir, "sessions");
+    this.dir = join46(o.configDir, "sessions");
     this.now = o.now ?? Date.now;
     this.isAlive = o.isAlive ?? pidAlive;
   }
@@ -65620,7 +66064,7 @@ class SessionRegistry {
   readPid(pid) {
     let raw;
     try {
-      raw = readFileSync29(join45(this.dir, `${pid}.json`), "utf8");
+      raw = readFileSync29(join46(this.dir, `${pid}.json`), "utf8");
     } catch {
       return null;
     }
@@ -65665,14 +66109,28 @@ function activityOf(t) {
     return "finishing";
   return "thinking";
 }
+function unconfirmedBy(f) {
+  const g = f.gate;
+  if (g === null)
+    return "gate_unknown";
+  if (!g.ready || g.dialog !== null)
+    return (g.reason ?? "not_ready").slice(0, 48);
+  if (f.working === true)
+    return "working";
+  return null;
+}
 function corroborated(input) {
   const quiet = input.corroborationMs ?? CORROBORATION_MS;
   if (input.chatQuietMs < quiet)
     return { ok: false };
-  if (!input.screen)
+  if (!input.facts)
     return { ok: true, anomaly: "screen_unverified" };
-  const s = input.screen;
-  return { ok: s.boxEmpty && !s.choiceDialog && !s.working };
+  const why = unconfirmedBy(input.facts);
+  if (why === null)
+    return { ok: true };
+  if (input.chatQuietMs >= (input.corroborationGraceMs ?? CORROBORATION_GRACE_MS))
+    return { ok: true, anomaly: `settle_gate_unconfirmed:${why}` };
+  return { ok: false };
 }
 function settledAs(by, stopReason, c, extra = []) {
   return {
@@ -65705,10 +66163,13 @@ function pathPrimary(t, input) {
 function pathSecondary(t, input) {
   if (!endingStop(t) || !stopHooksFinished(t, input.session))
     return null;
-  if (!input.screen)
+  if (!input.facts)
     return null;
   const window2 = input.secondaryQuietMs ?? SECONDARY_QUIET_MS;
-  if (input.transcriptQuietMs < window2 || input.screen.aboveBoxQuietMs < window2)
+  if (input.transcriptQuietMs < window2)
+    return null;
+  const above = input.facts.aboveBoxQuietMs;
+  if (above !== null && above < window2)
     return null;
   const c = corroborated(input);
   return c.ok ? settledAs("quiet", t.lastAssistant?.stopReason ?? null, c, ["settled_without_turn_duration"]) : null;
@@ -65739,9 +66200,10 @@ function decideSettle(input) {
     return endingStop(t) ? settledAs("exit", t.lastAssistant.stopReason, {}) : notYet;
   return pathSecondary(t, input) ?? notYet;
 }
-var SECONDARY_QUIET_MS = 32000, CORROBORATION_MS = 500, CONTINUING;
+var SECONDARY_QUIET_MS = 32000, CORROBORATION_MS = 500, CONTINUING, CORROBORATION_GRACE_MS;
 var init_settle_rule = __esm(() => {
   CONTINUING = new Set(["tool_use", "pause_turn"]);
+  CORROBORATION_GRACE_MS = SECONDARY_QUIET_MS;
 });
 
 // src/pane/slot-state.ts
@@ -65882,10 +66344,10 @@ import {
   openSync as openSync8,
   readSync as readSync3,
   readdirSync as readdirSync7,
-  realpathSync as realpathSync2,
+  realpathSync as realpathSync3,
   statSync as statSync9
 } from "fs";
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 function initialFollowerState(resolvePath = safeRealpath) {
   return {
     turns: [],
@@ -65900,7 +66362,7 @@ function initialFollowerState(resolvePath = safeRealpath) {
 }
 function safeRealpath(p) {
   try {
-    return realpathSync2(p);
+    return realpathSync3(p);
   } catch {
     return p;
   }
@@ -66413,7 +66875,7 @@ class TranscriptFollower {
     for (const f of this.subagentFiles()) {
       let tail = this.subs.get(f);
       if (!tail) {
-        tail = new Tail(join46(this.subagentsDir, f));
+        tail = new Tail(join47(this.subagentsDir, f));
         this.subs.set(f, tail);
       }
       for (const { line } of tail.read()) {
@@ -66496,8 +66958,8 @@ var init_transcript_follower = __esm(() => {
 });
 
 // src/pane/pane-session.ts
-import { readFileSync as readFileSync30, realpathSync as realpathSync3, rmSync as rmSync6, statSync as statSync10, writeFileSync as writeFileSync21 } from "fs";
-import { join as join47 } from "path";
+import { readFileSync as readFileSync30, realpathSync as realpathSync4, rmSync as rmSync6, statSync as statSync10, writeFileSync as writeFileSync21 } from "fs";
+import { join as join48 } from "path";
 function iso(ms) {
   return new Date(ms).toISOString();
 }
@@ -66534,7 +66996,7 @@ class PaneSessionImpl {
   initialPending;
   shape;
   queue = [];
-  screen = emptyScreen(160, 50);
+  screen;
   final = false;
   turnIndex = 0;
   admission = null;
@@ -66570,8 +67032,25 @@ class PaneSessionImpl {
   disagreeCounted = new Set;
   exitScrollback = "";
   exitLastLine = "";
-  bootKind = null;
-  bootKindSince = 0;
+  desiredSize;
+  appliedSize;
+  supportsResize = false;
+  resizeWaiters = [];
+  resizeDraining = false;
+  lastSentSize = null;
+  resizeQuietFrom = 0;
+  resizeQuietUntil = 0;
+  activityChangedAt = 0;
+  gate = null;
+  gateTrusted = false;
+  gateInFlight = false;
+  gateTimer = null;
+  gateDeadSince = 0;
+  lastSend = null;
+  turnAcceptedAt = null;
+  turnErrorLogSize = 0;
+  witnessMissingCounted = false;
+  abandonedIndex = null;
   magmux = null;
   watcher = null;
   client = null;
@@ -66602,12 +67081,16 @@ class PaneSessionImpl {
     this.turnDir = ids.turnDir;
     this.identity = { paneId: ids.paneId, sessionUuid: o.sessionUuid, ctlDir: ids.ctlDir };
     this.shape = o.shape;
+    const size = launchSize(o);
+    this.desiredSize = size;
+    this.appliedSize = { ...size };
+    this.screen = emptyScreen(size.cols, size.rows);
     this.initialPending = !!o.initialPrompt;
     if (o.initialPrompt)
       this.queue.push(o.initialPrompt);
     this.secondaryQuietMs = o.timings?.secondaryQuietMs ?? SECONDARY_QUIET_MS;
     this.corroborationMs = o.timings?.corroborationMs ?? CORROBORATION_MS;
-    this.follower = new TranscriptFollower(o.transcriptPath, join47(o.transcriptPath.replace(/\.jsonl$/, ""), "subagents"));
+    this.follower = new TranscriptFollower(o.transcriptPath, join48(o.transcriptPath.replace(/\.jsonl$/, ""), "subagents"));
     this.registry = new SessionRegistry({
       configDir: claudeConfigDir(o.parentEnv ?? process.env),
       sessionUuid: o.sessionUuid
@@ -66643,7 +67126,9 @@ class PaneSessionImpl {
         sockRoot: this.root,
         ctlDir: this.ctlDir,
         cwd: input.cwd,
-        env: input.env
+        env: input.env,
+        sessionUuid: this.o.sessionUuid,
+        transcriptPath: this.o.transcriptPath
       });
     } catch (e) {
       return this.spawnFailed(e);
@@ -66652,7 +67137,7 @@ class PaneSessionImpl {
       return this.spawnFailed(new Error("magmux did not start"));
     this.magmux = proc;
     try {
-      writeFileSync21(join47(this.ctlDir, "magmux.pid"), `${proc.pid}
+      writeFileSync21(join48(this.ctlDir, "magmux.pid"), `${proc.pid}
 `, { mode: 384 });
     } catch {}
     updateRecord(this.root, this.paneId, { magmuxPid: proc.pid });
@@ -66660,6 +67145,7 @@ class PaneSessionImpl {
     proc.stderr?.on("data", (d) => this.onStderr(d));
     proc.on("exit", (code, sig) => this.onMagmuxExit(code, sig));
     this.ticker = setInterval(() => this.step(() => this.evaluate()), TICK_MS);
+    this.gateTimer = setInterval(() => this.pollGate(), GATE_POLL_MS);
     if (this.o.timeoutMs !== undefined)
       this.timeoutTimer = setTimeout(() => this.step(() => this.fire("timeout")), Math.max(0, this.o.timeoutMs));
     await this.connectFirst();
@@ -66689,7 +67175,6 @@ class PaneSessionImpl {
       client.close();
       return;
     }
-    this.client = client;
     client.on("snapshot", (e) => this.onSnapshot(e));
     client.on("frame", (f) => this.onFrame(f));
     client.on("exit", (e) => void this.onPaneExit(e));
@@ -66701,8 +67186,15 @@ class PaneSessionImpl {
     const caps = await client.request({
       type: "capabilities"
     });
+    this.supportsResize = caps.ok && Array.isArray(caps.result.verbs) && caps.result.verbs.includes("resize");
+    if (client.isClosed)
+      return;
+    this.client = client;
+    this.gateTrusted = false;
+    this.gate = null;
+    const magmuxVersion = caps.ok ? String(caps.result.version ?? "") : "";
     if (caps.ok) {
-      const v = String(caps.result.version ?? "");
+      const v = magmuxVersion;
       if (caps.result.protocol !== 1 || !versionAtLeast(v, MIN_MAGMUX_VERSION)) {
         this.step(() => this.fire("pane_lost", {
           detail: `magmux_unavailable: magmux ${v || "?"} protocol ${caps.result.protocol ?? "?"}; panes need >= ${MIN_MAGMUX_VERSION}, protocol 1`
@@ -66710,6 +67202,9 @@ class PaneSessionImpl {
         return;
       }
     }
+    this.lastSentSize = null;
+    if (this.supportsResize && !samePaneSize(this.appliedSize, this.desiredSize))
+      this.kickResize();
     await client.request({ type: "watch", pane: 0, mode: "frames", fps: WATCH_FPS });
     const list = await client.request({ type: "list" });
     const p0 = list.ok ? list.result.panes?.find((p) => p.pane === 0) : undefined;
@@ -66719,7 +67214,76 @@ class PaneSessionImpl {
       if (!reconnect)
         await this.nextFrame(500);
       this.onPaneExit({ exitCode: p0.exitCode ?? null, lastLine: "" });
+      return;
+    }
+    if (!this.verifyGateBinding(client, list, magmuxVersion) || !list.ok)
+      return;
+    this.gateTrusted = true;
+    this.onGateList(client, list.result);
+  }
+  verifyGateBinding(client, list, magmuxVersion) {
+    if (client.isClosed || isTerminalPhase(this.phase))
+      return false;
+    if (!list.ok) {
+      this.step(() => this.fire("pane_lost", {
+        detail: `input_gate_unbound: magmux ${magmuxVersion || "?"} list failed (${list.code}: ${list.error}), so the binding of pane 0 is unknown`
+      }));
+      return false;
     }
+    if (!list.result.panes?.some((p) => p.pane === 0))
+      return false;
+    const check = checkGateBinding(list.result, {
+      sessionUuid: this.o.sessionUuid,
+      transcriptPath: this.o.transcriptPath,
+      magmuxVersion
+    });
+    if (!check.ok) {
+      this.step(() => this.fire("pane_lost", { detail: check.detail }));
+      return false;
+    }
+    return true;
+  }
+  pollGate() {
+    const c = this.client;
+    if (!c || !this.gateTrusted || this.gateInFlight)
+      return;
+    if (this.reaping || isTerminalPhase(this.phase))
+      return;
+    this.gateInFlight = true;
+    c.request({ type: "list" }, GATE_REPLY_MS).then((r) => {
+      this.gateInFlight = false;
+      if (r.ok)
+        this.onGateList(c, r.result);
+    });
+  }
+  onGateList(c, result) {
+    if (c !== this.client || !this.gateTrusted || isTerminalPhase(this.phase))
+      return;
+    const now = Date.now();
+    const p0 = result.panes?.find((p) => p.pane === 0);
+    if (typeof p0?.pid === "number" && !this.panePidValue)
+      this.setPanePid(p0.pid);
+    if (p0?.dead === true && !this.paneExited) {
+      if (this.gateDeadSince === 0)
+        this.gateDeadSince = now;
+      else if (now - this.gateDeadSince >= GATE_DEAD_BACKSTOP_MS) {
+        this.anomaly("exit_event_missing");
+        this.onPaneExit({ exitCode: p0.exitCode ?? null, lastLine: "" });
+        return;
+      }
+    } else
+      this.gateDeadSince = 0;
+    const prev = this.gate;
+    this.gate = parseGateInput(result, now);
+    const g = this.gate;
+    if (prev?.ready !== g?.ready || prev?.reason !== g?.reason)
+      this.step(() => this.evaluate());
+  }
+  gateNow() {
+    const g = this.gate;
+    if (!g || !this.client || !this.gateTrusted)
+      return null;
+    return Date.now() - g.receivedAt <= GATE_STALE_MS ? g : null;
   }
   onStderr(d) {
     if (this.stderrHead.length < 8192)
@@ -66742,7 +67306,10 @@ class PaneSessionImpl {
   onFrame(f) {
     if (f.pane !== undefined && f.pane !== 0)
       return;
+    const seq = this.screen.seq;
     this.screen = applyFrame(this.screen, f);
+    if (this.screen.seq !== seq && !this.inResizeQuiet(this.screen.changedAt))
+      this.activityChangedAt = this.screen.changedAt;
     this.framePending = true;
     if (!this.claudeCodeVersion) {
       const m = this.screen.lines.join(`
@@ -66753,8 +67320,11 @@ class PaneSessionImpl {
     this.step(() => this.evaluate());
   }
   onDisconnected(client) {
-    if (this.client === client)
+    if (this.client === client) {
       this.client = null;
+      this.gate = null;
+      this.gateTrusted = false;
+    }
     if (this.reaping || !alive(this.magmux))
       return;
     if (isTerminalPhase(this.phase))
@@ -66946,11 +67516,15 @@ class PaneSessionImpl {
     if (!this.client)
       return;
     const idle = status === "idle";
-    const dialog = hasChoiceDialog(this.screen);
-    this.disagree("registry_idle_screen_booting", this.phase === "BOOTING" && idle && readBoot(this.screen).kind !== "repl", now);
     this.disagree("registry_idle_screen_working", this.phase === "RUNNING" && idle && isWorking(this.screen), now);
-    this.disagree("registry_waiting_no_dialog", status === "waiting" && !dialog, now);
-    this.disagree("screen_dialog_registry_not_waiting", dialog && (status === "idle" || status === "busy"), now);
+    const g = this.gateNow();
+    if (!g)
+      return;
+    this.disagree("registry_idle_gate_starting", this.phase === "BOOTING" && idle && (g.reason === "starting" || g.reason === "no_input_box"), now, REGISTRY_GATE_BOOT_DISAGREE_MS);
+    this.disagree("registry_waiting_gate_no_dialog", status === "waiting" && g.ready, now);
+    this.disagree("gate_dialog_registry_not_waiting", g.dialog !== null && RUNTIME_DIALOG_KINDS.has(g.dialog) && (idle || status === "busy"), now);
+    this.disagree("gate_ready_box_not_located", g.ready && locateBox(this.screen) === null, now);
+    this.disagree("gate_dialog_screen_unrecognised", (g.dialog === "permission" || g.dialog === "plan" || g.dialog === "question") && choiceDialog(this.screen) === null, now);
   }
   disagree(key, holds, now, forMs = REGISTRY_DISAGREE_MS) {
     if (!holds) {
@@ -66986,33 +67560,42 @@ class PaneSessionImpl {
   }
   evalBoot() {
     const now = Date.now();
-    const r = readBoot(this.screen);
-    if (r.kind !== this.bootKind) {
-      this.bootKind = r.kind;
-      this.bootKindSince = now;
-    }
-    const staticFor = this.screen.seq === 0 ? 0 : now - this.screen.changedAt;
-    const staticMs = this.t("bootStaticMs", BOOT_STATIC_MS);
-    if (r.kind === "repl" && now - this.bootKindSince >= this.t("replStableMs", REPL_STABLE_MS)) {
+    const g = this.gateNow();
+    if (g?.ready) {
       this.bootReady();
       return;
     }
-    if (r.kind === "dialog" && staticFor >= staticMs) {
-      this.fire("boot_dialog", { detail: r.text });
-      return;
-    }
-    if (r.kind === "choice" && staticFor >= staticMs) {
-      this.fire("boot_blocked", { detail: r.text });
+    const staticFor = this.screen.seq === 0 ? 0 : now - this.screen.changedAt;
+    const settled = staticFor >= this.t("bootStaticMs", BOOT_STATIC_MS);
+    const block = g && settled ? this.bootBlock(g) : null;
+    if (block) {
+      this.fire(block.ev, { detail: block.detail });
       return;
     }
     if (now - this.startedAtMs >= (this.o.bootTimeoutMs ?? BOOT_TIMEOUT_MS)) {
-      const blocked = this.screen.seq > 0 && staticFor >= staticMs && r.kind !== "booting";
+      const blocked = this.screen.seq > 0 && settled && (g?.reason?.startsWith("dialog:") === true || nameBootScreen(this.screen).kind !== "booting");
+      const gate = g ? `gate: ${g.reason ?? "ready"}${g.detail ? ` (${g.detail})` : ""}` : "gate: unknown";
       this.fire("boot_deadline", {
         reason: blocked ? "boot_blocked" : "boot_timeout",
-        detail: screenTailOf(this.screen)
+        detail: `${screenTailOf(this.screen)}
+${gate}`
       });
     }
   }
+  bootBlock(g) {
+    if (g.dialog && BOOT_DIALOG_KINDS.has(g.dialog))
+      return { ev: "boot_dialog", detail: dialogText(this.screen) };
+    const named = nameBootScreen(this.screen);
+    if (named.kind === "dialog")
+      return { ev: "boot_dialog", detail: named.text };
+    if (g.reason === "vim_mode")
+      return { ev: "boot_blocked", detail: "vim editing mode is on (-- INSERT -- under the box)" };
+    if (g.reason?.startsWith("dialog:"))
+      return { ev: "boot_blocked", detail: screenText(this.screen) };
+    if (named.kind === "choice" && g.reason !== null && GATE_KINDLESS_REASONS.has(g.reason))
+      return { ev: "boot_blocked", detail: named.text };
+    return null;
+  }
   bootReady() {
     this.bootReadyAtMs = Date.now();
     if (this.queue.length === 0) {
@@ -67038,7 +67621,7 @@ class PaneSessionImpl {
       const head = this.queue.shift();
       if (isControl(head)) {
         this.exitRequested = true;
-        this.typeLine(head.trim(), true);
+        this.submitControl(head.trim());
         return;
       }
       this.fire("admit");
@@ -67062,6 +67645,9 @@ class PaneSessionImpl {
     this.screenTurn = null;
     this.rewakeOfSettled = false;
     this.settledChatOffset = null;
+    this.turnAcceptedAt = null;
+    this.witnessMissingCounted = false;
+    this.abandonedIndex = null;
     if (plan.mode === "refused" || plan.mode === "control") {
       this.anomaly(`delivery_refused:${plan.mode === "refused" ? plan.reason : "control"}`);
       this.admission = null;
@@ -67077,79 +67663,385 @@ class PaneSessionImpl {
     }
     const delivery = (plan.mode === "file" || plan.mode === "command") && plan.file && plan.fileContent !== undefined ? { file: plan.file, text: plan.fileContent } : null;
     this.follower.openTurn({ index, offset, witness: plan.witness, delivery });
-    this.admission = {
-      index,
-      text,
-      plan,
-      initial,
-      startedAt: Date.now(),
-      deliveredAt: null,
-      resent: false,
-      panelEscaped: false,
-      degraded: false
-    };
-    this.deliver(this.admission);
+    const bound = initial ? this.o.admitTimeoutMs ?? ADMIT_TIMEOUT_MS : ADMIT_TIMEOUT_MS;
+    const adm = newAdmission({ index, text, plan, initial, bound });
+    this.admission = adm;
+    this.runAdmission(adm);
   }
-  async deliver(adm) {
-    if (await this.typeAndSubmit(adm.plan))
-      adm.deliveredAt = Date.now();
+  admitting(adm) {
+    return this.admission === adm && this.phase === "ADMITTING";
   }
-  async typeAndSubmit(plan) {
-    if (plan.mode !== "typed" && plan.mode !== "file" && plan.mode !== "command")
+  async runAdmission(adm) {
+    try {
+      while (this.admitting(adm) && adm.submittedUnproven === null && !adm.stopped) {
+        if (Date.now() >= adm.deadline)
+          return;
+        if (adm.panel) {
+          await this.pause(adm, TICK_MS);
+          continue;
+        }
+        if (!this.client || !this.gateTrusted) {
+          await this.awaitTrustedClient(adm);
+          continue;
+        }
+        if (await this.beforeSend(adm) !== "send")
+          continue;
+        if (!this.admitting(adm) || !await this.attemptOnce(adm))
+          return;
+      }
+    } finally {
+      adm.inFlight = false;
+    }
+  }
+  awaitTrustedClient(adm) {
+    return this.waitFor(() => !this.admitting(adm) || !!this.client && this.gateTrusted, Math.max(0, adm.deadline - Date.now()));
+  }
+  async attemptOnce(adm) {
+    const c = this.client;
+    if (!c)
+      return true;
+    const step = adm.step;
+    const shape = sendShape(step, adm.line);
+    const rt = readyTimeoutFor(step, adm.line, adm.deadline - Date.now());
+    if (rt === null)
       return false;
-    if (plan.mode === "command") {
-      await this.typeLine(plan.line, false);
-      await this.nextFrame(500);
-      const box = inputBox(this.screen);
-      const name = plan.line.match(/^\/\S+/)?.[0] ?? "";
-      if (box?.menuOpen && box.menuItem !== name)
-        await this.key("escape");
-      await this.key("enter");
-    } else {
-      await this.typeLine(plan.line, true);
+    const timeout = sendBudgetMs({ ...shape.budget, readyTimeoutMs: rt }) + SEND_CLIENT_SLACK_MS;
+    const sentAt = Date.now();
+    adm.inFlight = true;
+    adm.attempts++;
+    let reply;
+    try {
+      reply = await c.request({ ...shape.msg, readyTimeoutMs: rt }, timeout);
+    } finally {
+      adm.inFlight = false;
     }
+    const out = classifySendReply(reply);
+    adm.last = out;
+    this.noteLastSend(out, adm.attempts);
+    if (!this.admitting(adm))
+      return false;
+    await this.onSendOutcome(adm, out, step, { client: c, until: sentAt + timeout });
     return true;
   }
-  async typeLine(text, enter) {
-    let why = "disconnected";
-    for (let attempt = 0;attempt < 2; attempt++) {
-      const c = this.client;
-      if (c) {
-        const r = await c.request({ type: "send", pane: 0, text, typed: true, enter }, 1e4);
-        if (r.ok)
-          return true;
-        why = r.code;
-        if (r.code === "client_timeout" || r.code === "client_lost") {
-          if (await this.landedAfterLostReply(text, enter))
-            return true;
+  async onSendOutcome(adm, out, step, sent) {
+    switch (out.kind) {
+      case "accepted":
+        this.onGateAccepted(adm, out);
+        return;
+      case "in_box":
+        if (step !== "type") {
+          this.anomaly("send_unexpected:in_box");
+          this.stopAdmission(adm, "magmux answered in_box to a send that carried an Enter");
+          return;
         }
+        if (out.retyped)
+          this.anomaly(`gate_retyped:${out.retypeCause ?? "unknown"}`);
+        await this.menuCheck(adm);
+        adm.step = "enter";
+        return;
+      case "busy":
+        await this.onBusy(adm, out, step);
+        return;
+      case "not_accepted":
+        await this.onNotAccepted(adm, out, step);
+        return;
+      case "bad_request":
+        this.anomaly("send_bad_request");
+        this.stopAdmission(adm, `send_bad_request: ${out.error}`);
+        return;
+      case "reply_lost":
+        this.anomaly("send_reply_lost");
+        if (step === "type") {
+          adm.lostType = sent;
+          markClearFirst(adm);
+          return;
+        }
+        adm.submittedUnproven = "reply_lost";
+        return;
+      case "unsent":
+        await this.pause(adm, BUSY_RETRY_MS);
+        return;
+      case "pane_gone":
+        adm.stopped = true;
+        return;
+      case "unexpected":
+        this.anomaly(`send_unexpected:${out.code}`);
+        this.stopAdmission(adm, `send_unexpected: ${out.code}${out.error ? `: ${out.error}` : ""}`);
+        return;
+      default:
+        assertNever(out);
+    }
+  }
+  onGateAccepted(adm, out) {
+    if (out.accept === "resent_enter")
+      this.anomaly("gate_resent_enter");
+    if (out.accept === "submitted_by_other")
+      this.anomaly("gate_submitted_by_other");
+    if (out.retyped)
+      this.anomaly(`gate_retyped:${out.retypeCause ?? "unknown"}`);
+    if (out.dismissed.length > 0)
+      this.anomaly("gate_dismissed_unexpected");
+    if (out.evidence === "transcript") {
+      this.anomaly("gate_transcript_evidence");
+      if (!this.witnessNow()) {
+        this.anomaly("gate_transcript_evidence_unwitnessed");
+        adm.submittedUnproven = "unconfirmed";
+        return;
       }
-      await Bun.sleep(500);
     }
-    this.anomaly(`delivery_failed:${why}`);
+    this.acceptAdmission(adm);
+  }
+  async onBusy(adm, out, step) {
+    const reason = out.reason || "unknown";
+    if (this.stopOnGateBlock(adm, reason, out.dialog))
+      return;
+    if (out.dialog === "select" && step === "enter") {
+      this.noteOnce(adm, "gate_dialog_at_admission:select");
+      adm.panel = { showingSince: null, escaped: false, entered: false };
+      return;
+    }
+    if (out.dialog) {
+      this.noteOnce(adm, `gate_dialog_at_admission:${out.dialog}`);
+    } else if (out.typed) {
+      this.anomaly("gate_typed_withheld");
+      markClearFirst(adm);
+    } else if (reason === "box_not_empty") {
+      this.anomaly("gate_box_not_empty");
+      markClearFirst(adm);
+    } else {
+      this.noteOnce(adm, `gate_busy:${reason}`);
+    }
+    await this.pause(adm, BUSY_RETRY_MS);
+  }
+  stopOnGateBlock(adm, reason, dialog) {
+    if (dialog && BOOT_DIALOG_KINDS.has(dialog)) {
+      this.anomaly(`gate_boot_dialog:${dialog}`);
+      this.stopAdmission(adm, dialogText(this.screen) || `busy ${reason}`, "first_run_dialog");
+      return true;
+    }
+    if (reason === "vim_mode") {
+      this.anomaly("gate_vim_mode");
+      this.stopAdmission(adm, "busy vim_mode: vim editing mode is on (-- INSERT -- under the box)");
+      return true;
+    }
     return false;
   }
-  async landedAfterLostReply(text, enter) {
-    await this.nextFrame(1000);
-    const head = text.slice(0, 40);
-    const box = inputBox(this.screen);
-    let landed = !!box && box.text.startsWith(head);
-    if (landed && enter)
-      await this.key("enter");
-    if (!landed && enter) {
-      this.follower.poll();
-      const cur = this.follower.view().current;
-      landed = !!cur && cur.index === this.turnIndex && cur.acceptedAt !== null || this.screen.lines.some((l) => l.startsWith(`\u276F ${head}`));
+  async precheckGate(adm) {
+    const g = this.gateNow();
+    if (!g || g.ready)
+      return "send";
+    if (this.stopOnGateBlock(adm, g.reason ?? "unknown", g.dialog))
+      return "stopped";
+    const kind = g.dialog;
+    if (kind !== "permission" && kind !== "question" && kind !== "plan")
+      return "send";
+    this.noteOnce(adm, `gate_dialog_at_admission:${kind}`);
+    await this.waitFor(() => !this.admitting(adm) || this.gateNow()?.dialog !== kind, Math.max(0, adm.deadline - Date.now()));
+    return "waited";
+  }
+  async beforeSend(adm) {
+    if (adm.step === "enter")
+      return "send";
+    await this.clearLeftover(adm);
+    if (!this.admitting(adm))
+      return "stopped";
+    return this.precheckGate(adm);
+  }
+  async onNotAccepted(adm, out, step) {
+    switch (out.reason) {
+      case "text_mismatch":
+        if (out.maybeSubmitted) {
+          this.anomaly("gate_maybe_submitted_by_other");
+          adm.submittedUnproven = "maybe_submitted_by_other";
+          return;
+        }
+        this.anomaly("gate_text_mismatch");
+        markClearFirst(adm);
+        if (adm.plan.mode === "command")
+          adm.step = "type";
+        await this.pause(adm, MISMATCH_SETTLE_MS);
+        return;
+      case "empty_box":
+        if (step === "enter") {
+          this.anomaly("gate_command_left_box");
+          adm.submittedUnproven = "maybe_submitted_by_other";
+          return;
+        }
+        this.anomaly("gate_empty_box");
+        await this.pause(adm, BUSY_RETRY_MS);
+        return;
+      case "still_in_box":
+        if (this.witnessNow()) {
+          this.acceptAdmission(adm);
+          return;
+        }
+        this.anomaly("gate_still_in_box");
+        if (adm.stuckRetried) {
+          adm.submittedUnproven = "still_in_box_twice";
+          return;
+        }
+        adm.stuckRetried = true;
+        await this.clearBox(adm);
+        if (adm.plan.mode === "command")
+          adm.step = "type";
+        return;
+      case "unconfirmed":
+        this.anomaly("gate_unconfirmed");
+        adm.submittedUnproven = "unconfirmed";
+        if (step === "enter")
+          adm.panel = { showingSince: null, escaped: false, entered: true };
+        return;
+      default:
+        assertNever(out.reason);
+    }
+  }
+  acceptAdmission(adm) {
+    this.step(() => {
+      if (this.admitting(adm))
+        this.accept();
+    });
+  }
+  stopAdmission(adm, detail, reason) {
+    adm.stopped = true;
+    this.step(() => {
+      if (!this.admitting(adm))
+        return;
+      this.admission = null;
+      if (adm.initial) {
+        this.fire("admit_deadline", { reason, detail: `${detail}
+${screenTailOf(this.screen)}` });
+        return;
+      }
+      this.anomaly("send_not_accepted");
+      this.abandonedIndex = adm.index;
+      this.fire("admit_abandoned");
+    });
+  }
+  witnessNow() {
+    return this.witnessed(this.pollFollower(true).current);
+  }
+  noteOnce(adm, key) {
+    if (adm.noted.has(key))
+      return;
+    adm.noted.add(key);
+    this.anomaly(key);
+  }
+  pause(adm, ms) {
+    return this.waitFor(() => !this.admitting(adm), ms);
+  }
+  freshReady(after) {
+    const g = this.gateNow();
+    return !!g && g.receivedAt > after && g.ready;
+  }
+  async clearBox(adm) {
+    const at = Date.now();
+    await this.key("ctrl-u");
+    await this.waitFor(() => !this.admitting(adm) || this.freshReady(at), CLEAR_WAIT_MS);
+  }
+  async clearLeftover(adm) {
+    const lost = adm.lostType;
+    if (lost) {
+      adm.lostType = null;
+      if (lost.client !== this.client || lost.client.isClosed)
+        await this.pause(adm, Math.max(0, lost.until - Date.now()));
+      if (!this.admitting(adm))
+        return;
+    }
+    if (adm.clearFirst)
+      await this.clearOwnLeftover(adm);
+    else if (this.gateNow()?.reason === "box_not_empty")
+      await this.clearBox(adm);
+  }
+  async clearOwnLeftover(adm) {
+    const after = adm.clearAfter + GATE_POLL_MS;
+    const newer = () => {
+      const g = this.gateNow();
+      return g && g.receivedAt > after ? g : null;
+    };
+    await this.waitFor(() => !this.admitting(adm) || newer() !== null, CLEAR_WAIT_MS + GATE_POLL_MS);
+    if (!this.admitting(adm))
+      return;
+    const g = newer();
+    if (g?.ready) {
+      adm.clearFirst = false;
+      return;
+    }
+    if (g && (g.dialog !== null || g.reason === "vim_mode"))
+      return;
+    adm.clearFirst = false;
+    await this.clearBox(adm);
+  }
+  async menuCheck(adm) {
+    const name = adm.line.match(/^\/\S+/)?.[0] ?? "";
+    await this.waitFor(() => {
+      if (!this.admitting(adm))
+        return true;
+      const box = locateBox(this.screen);
+      return !!box && locatedBoxText(this.screen, box).startsWith(name);
+    }, 2 * TICK_MS);
+    if (!this.admitting(adm))
+      return;
+    const box = locateBox(this.screen);
+    if (!box) {
+      this.anomaly("menu_unverified");
+      return;
+    }
+    const menu = menuAbove(this.screen.lines, box.top);
+    if (menu.menuOpen && menu.menuItem !== name)
+      await this.key("escape");
+  }
+  noteLastSend(out, attempts) {
+    const s = { kind: out.kind, attempts };
+    switch (out.kind) {
+      case "accepted":
+        s.accept = out.accept;
+        s.evidence = out.evidence;
+        if (out.retypeCause)
+          s.retypeCause = out.retypeCause;
+        break;
+      case "in_box":
+        s.accept = "in_box";
+        if (out.retypeCause)
+          s.retypeCause = out.retypeCause;
+        break;
+      case "busy":
+      case "not_accepted":
+        s.reason = out.reason;
+        break;
+      case "bad_request":
+        s.reason = "bad_request";
+        break;
+      case "reply_lost":
+      case "unsent":
+      case "pane_gone":
+      case "unexpected":
+        s.reason = out.code;
+        break;
+      default:
+        assertNever(out);
+    }
+    this.lastSend = s;
+    return s;
+  }
+  async submitControl(line) {
+    const c = this.client;
+    if (!c) {
+      this.anomaly("control_send:unsent");
+      return;
     }
-    if (landed)
-      this.anomaly("send_reply_lost");
-    return landed;
+    const rt = SEND_READY_WAIT_DEFAULT_MS;
+    const shape = sendShape("submit", line);
+    const r = await c.request({ ...shape.msg, readyTimeoutMs: rt }, sendBudgetMs({ ...shape.budget, readyTimeoutMs: rt }) + SEND_CLIENT_SLACK_MS);
+    const out = classifySendReply(r);
+    const s = this.noteLastSend(out, 1);
+    if (out.kind !== "accepted")
+      this.anomaly(`control_send:${out.kind}${s.reason ? `:${s.reason}` : ""}`);
   }
   async key(k) {
     const c = this.client;
     if (!c)
       return false;
-    const r = await c.request({ type: "send", pane: 0, keys: [k], enter: false }, 1e4);
+    const r = await c.request({ type: "send", pane: 0, keys: [k], enter: false, noGate: true }, 1e4);
     return r.ok;
   }
   nextFrame(ms) {
@@ -67169,139 +68061,134 @@ class PaneSessionImpl {
     const adm = this.admission;
     if (!adm)
       return;
-    const cur = view.current;
-    if (cur && cur.index === adm.index && cur.acceptedAt !== null) {
+    if (this.witnessed(view.current)) {
       this.accept();
       return;
     }
-    const now = Date.now();
-    const since = adm.deliveredAt ? now - adm.deliveredAt : 0;
-    if (adm.deliveredAt && adm.plan.mode === "command" && this.panelCommand(adm, since))
-      return;
-    if (adm.deliveredAt && since >= this.t("resendAfterMs", RESEND_AFTER_MS))
-      this.nudge(adm);
-    if (adm.deliveredAt && (view.availability === "off" || since >= this.t("degradedEntryMs", DEGRADED_ENTRY_MS)))
-      this.maybeDegradedAccept(adm, view);
-    if (this.phase !== "ADMITTING")
+    if (adm.panel)
+      this.panelStep(adm);
+    if (!this.admitting(adm))
       return;
-    if (now - adm.startedAt >= (this.o.admitTimeoutMs ?? ADMIT_TIMEOUT_MS))
+    if (Date.now() >= adm.deadline && !adm.inFlight)
       this.admitExpired(adm);
   }
-  panelOpen() {
-    return !inputBox(this.screen) && !hasChoiceDialog(this.screen) && /Esc to cancel/.test(screenText(this.screen));
+  panelShowing(g) {
+    return !!g && (g.reason === "no_input_box" || g.dialog === "select") && /Esc to cancel/.test(flatText(this.screen.lines));
   }
-  panelCommand(adm, since) {
-    if (!adm.panelEscaped) {
-      if (since < PANEL_SETTLE_MS || !this.panelOpen())
-        return false;
-      adm.panelEscaped = true;
-      this.anomaly("panel_dismissed");
-      this.key("escape");
-      return true;
-    }
-    const box = inputBox(this.screen);
-    if (!box || box.text !== "" || this.panelOpen())
-      return false;
-    this.admission = null;
-    this.anomaly("panel_command");
-    if (adm.initial)
-      this.fire("admit_deadline", {
-        detail: `${adm.text.trim()} opened a panel and wrote no transcript record`
-      });
-    else
-      this.fire("admit_abandoned");
-    return true;
-  }
-  async awaitClearedBox(adm, head) {
-    const end = Date.now() + this.t("nudgeClearDeadlineMs", NUDGE_CLEAR_DEADLINE_MS);
-    for (;; ) {
-      if (this.admission !== adm || this.phase !== "ADMITTING")
-        return "gone";
-      const box = inputBox(this.screen);
-      if (box && box.text === "")
-        return "empty";
-      if (box && !box.text.startsWith(head))
-        return "other";
-      const left = end - Date.now();
-      if (left <= 0)
-        return box ? "line" : "other";
-      await this.nextFrame(left);
-    }
-  }
-  nudge(adm) {
-    const box = inputBox(this.screen);
-    const line = adm.plan.mode === "control" || adm.plan.mode === "refused" ? "" : adm.plan.line;
-    const head = line.slice(0, 40);
-    if (!adm.resent && box && line && box.text.startsWith(head)) {
-      adm.resent = true;
-      this.anomaly("resent_enter");
-      (async () => {
-        if (box.menuOpen)
-          await this.key("escape");
-        await this.key("ctrl-u");
-        const after = await this.awaitClearedBox(adm, head);
-        if (after === "gone")
-          return;
-        if (after === "empty") {
-          this.anomaly("retyped_prompt");
-          await this.typeAndSubmit(adm.plan);
-        } else if (after === "line") {
-          await this.key("enter");
-        } else {
-          this.anomaly("clear_failed");
-        }
-      })();
+  panelStep(adm) {
+    const p = adm.panel;
+    if (!p)
       return;
-    }
-    if (!adm.panelEscaped && !box && !hasChoiceDialog(this.screen) && /Esc to cancel/.test(screenText(this.screen))) {
-      adm.panelEscaped = true;
-      this.anomaly("panel_dismissed");
+    const g = this.gateNow();
+    if (!p.escaped) {
+      if (!this.panelShowing(g)) {
+        p.showingSince = null;
+        return;
+      }
+      const now = Date.now();
+      p.showingSince ??= now;
+      if (now - p.showingSince < PANEL_SETTLE_MS)
+        return;
+      p.escaped = true;
+      this.anomaly(g?.dialog === "select" ? "picker_dismissed" : "panel_dismissed");
       this.key("escape");
-    }
-  }
-  maybeDegradedAccept(adm, view) {
-    if (view.availability === "ok")
       return;
-    const box = inputBox(this.screen);
-    if (!box || box.text !== "")
+    }
+    if (!g)
       return;
-    const line = adm.plan.mode === "control" || adm.plan.mode === "refused" ? "" : adm.plan.line;
-    const echo = this.screen.lines.some((l) => l.startsWith(`\u276F ${line.slice(0, 40)}`));
-    const changed = adm.deliveredAt !== null && this.screen.aboveBoxChangedAt > adm.deliveredAt;
-    if (!echo && !changed)
+    if (g.ready) {
+      this.admission = null;
+      this.anomaly("panel_command");
+      if (adm.initial)
+        this.fire("admit_deadline", {
+          detail: `${adm.text.trim()} opened a panel and wrote no transcript record`
+        });
+      else
+        this.fire("admit_abandoned");
       return;
-    this.turnSource = "screen";
-    this.anomaly("degraded_mode");
-    this.screenTurn = { echo: line, acceptedAt: Date.now(), errorLogSize: this.errorLogSize() };
-    this.accept();
+    }
+    if (!p.entered && g.reason === "box_not_empty")
+      adm.panel = null;
   }
   accept() {
     this.admission = null;
     this.initialDelivery = false;
-    this.lastChatSeenAt = Date.now();
+    const now = Date.now();
+    this.lastChatSeenAt = now;
+    this.turnAcceptedAt = now;
+    this.turnErrorLogSize = this.errorLogSize();
     this.fire("prompt_accepted");
   }
   admitExpired(adm) {
     this.admission = null;
     if (adm.initial) {
-      this.fire("admit_deadline", { detail: screenTailOf(this.screen) });
+      this.fire("admit_deadline", {
+        detail: `${this.notAcceptedLine(adm)}
+${screenTailOf(this.screen)}`
+      });
       return;
     }
     this.anomaly("send_not_accepted");
+    this.abandonedIndex = adm.index;
     this.fire("admit_abandoned");
   }
-  screenFacts() {
+  notAcceptedLine(adm) {
+    const secs = Math.round((Date.now() - adm.startedAt) / 1000);
+    switch (adm.submittedUnproven) {
+      case "maybe_submitted_by_other":
+        return "magmux could not tell whether the prompt was submitted (the box emptied without its Enter) and no transcript record of it appeared";
+      case "unconfirmed":
+        return `magmux not_accepted unconfirmed: Enter was pressed with no evidence it was submitted, and no transcript record appeared in ${secs} s`;
+      case "reply_lost": {
+        const code = adm.last?.kind === "reply_lost" ? adm.last.code : "client_lost";
+        return `the magmux send reply was lost (${code}) and no transcript record of the prompt appeared in ${secs} s`;
+      }
+      case "still_in_box_twice":
+        return "magmux not_accepted still_in_box: the prompt stayed in the input box after Enter, twice";
+      case null:
+        return `prompt not accepted in ${secs} s; ${describeLastReply(adm, this.gateNow())}`;
+      default:
+        return assertNever(adm.submittedUnproven);
+    }
+  }
+  corroborationFacts() {
     if (!this.client)
       return null;
-    const box = inputBox(this.screen);
+    const g = this.gateNow();
     return {
-      boxEmpty: !!box && box.text === "",
-      choiceDialog: hasChoiceDialog(this.screen),
-      working: isWorking(this.screen),
-      aboveBoxQuietMs: Date.now() - this.screen.aboveBoxChangedAt
+      gate: g ? { ready: g.ready, dialog: g.dialog, reason: g.reason } : null,
+      working: workingAboveBox(this.screen),
+      aboveBoxQuietMs: this.aboveBoxQuietMs()
     };
   }
+  aboveBoxQuietMs() {
+    return locateBox(this.screen) ? Date.now() - this.screen.aboveBoxChangedAt : null;
+  }
+  checkUnwitnessed(view) {
+    const at = this.turnAcceptedAt;
+    if (at === null || this.rewakeOfSettled || this.witnessed(view.current))
+      return;
+    const since = Date.now() - at;
+    const missing = view.availability === "absent" || view.availability === "empty";
+    if (view.availability === "off" || missing && since >= this.t("degradedEntryMs", DEGRADED_ENTRY_MS)) {
+      const d = this.currentDelivery;
+      this.turnSource = "screen";
+      this.anomaly("degraded_mode");
+      this.screenTurn = {
+        echo: d && d.mode !== "refused" ? d.line : "",
+        acceptedAt: at,
+        errorLogSize: this.turnErrorLogSize
+      };
+      return;
+    }
+    if (view.availability === "ok" && since >= ADMIT_TIMEOUT_MS && !this.witnessMissingCounted) {
+      this.witnessMissingCounted = true;
+      this.anomaly("witness_missing");
+    }
+  }
   evalRunning(view) {
+    if (this.turnSource === "transcript")
+      this.checkUnwitnessed(view);
     if (this.turnSource === "screen") {
       this.evalScreenTurn(view);
       return;
@@ -67321,22 +68208,24 @@ class PaneSessionImpl {
     if (this.detectBlocked(t))
       return;
     const now = Date.now();
+    const transcriptQuietMs = now - (view.lastAppendAt ?? this.startedAtMs);
     const decision = decideSettle({
       turn: t,
       session: view.session,
-      transcriptQuietMs: now - (view.lastAppendAt ?? this.startedAtMs),
+      transcriptQuietMs,
       chatQuietMs: now - this.lastChatSeenAt,
-      screen: this.screenFacts(),
+      facts: this.corroborationFacts(),
       paneExited: false,
       secondaryQuietMs: this.secondaryQuietMs,
-      corroborationMs: this.corroborationMs
+      corroborationMs: this.corroborationMs,
+      corroborationGraceMs: this.t("gateGraceMs", GATE_GRACE_MS)
     });
     if (decision.settled) {
       this.settle(t, decision, null);
       return;
     }
     this.activity = decision.activity;
-    this.checkTurnEndMissing();
+    this.checkTurnEndMissing(t, transcriptQuietMs);
     this.checkAgentCountMismatch(t);
   }
   checkEscape() {
@@ -67347,14 +68236,14 @@ class PaneSessionImpl {
     this.anomaly("escape_not_effective");
     this.escapeSentAt = null;
   }
-  checkTurnEndMissing() {
-    if (this.activity !== "finishing") {
+  checkTurnEndMissing(t, transcriptQuietMs) {
+    if (this.activity !== "finishing" || t.turnDurationAfterLast || t.interruptAfterLast) {
       this.turnEndMissing = false;
       return;
     }
     if (!this.client)
       return;
-    const quiet = Date.now() - this.screen.aboveBoxChangedAt;
+    const quiet = this.aboveBoxQuietMs() ?? transcriptQuietMs;
     const missing = quiet >= TURN_END_MISSING_FACTOR * this.secondaryQuietMs && !stopHookRunning(this.screen);
     if (missing && !this.turnEndMissing)
       this.anomaly("turn_end_record_missing");
@@ -67374,14 +68263,19 @@ class PaneSessionImpl {
     let kind = null;
     if (pending.name === "AskUserQuestion")
       kind = "question";
-    else if (this.client && hasChoiceDialog(this.screen))
-      kind = "permission";
+    else {
+      const dialog = this.gateNow()?.dialog ?? null;
+      if (dialog === "permission" || dialog === "plan")
+        kind = "permission";
+      else if (dialog === "question")
+        kind = "question";
+    }
     if (!kind)
       return false;
     this.blockedToolId = pending.id;
     this.fire(kind === "question" ? "blocked_question" : "blocked_permission");
     this.activity = pending.name;
-    const text = blockText3(pending, choiceDialog(this.screen)?.text ?? null);
+    const text = blockText3(pending, this.screen.seq > 0 ? dialogText(this.screen) || null : null);
     let v;
     try {
       v = this.o.onBlocked({ kind, tool: pending.name, text });
@@ -67394,6 +68288,16 @@ class PaneSessionImpl {
   }
   evalIdle(view) {
     const t = view.current;
+    if (t && this.abandonedIndex !== null && t.index === this.abandonedIndex && t.acceptedAt !== null && !this.exitRequested) {
+      this.abandonedIndex = null;
+      this.anomaly("late_witness");
+      this.turnAcceptedAt = Date.now();
+      this.turnErrorLogSize = this.errorLogSize();
+      this.lastChatSeenAt = Date.now();
+      this.fire("rewake");
+      this.activity = "thinking";
+      return;
+    }
     if (!t || this.settledChatOffset === null || this.exitRequested)
       return;
     if (t.lastChatOffset !== null && t.lastChatOffset > this.settledChatOffset) {
@@ -67472,10 +68376,10 @@ class PaneSessionImpl {
     return !!t && t.index === this.turnIndex && t.acceptedAt !== null;
   }
   screenSettleReady(view, answer, apiError) {
-    const box = inputBox(this.screen);
-    if (!box || box.text !== "" || hasChoiceDialog(this.screen) || isWorking(this.screen))
+    const g = this.gateNow();
+    if (!g || !g.ready || g.dialog !== null || workingAboveBox(this.screen) === true)
       return false;
-    const quiet = Date.now() - this.screen.aboveBoxChangedAt;
+    const quiet = this.aboveBoxQuietMs() ?? Date.now() - this.screen.changedAt;
     if (view.availability === "off" && quiet >= this.secondaryQuietMs)
       return true;
     return (!!answer || !!apiError) && quiet >= 2 * this.t("screenSettleQuietMs", SCREEN_SETTLE_QUIET_MS);
@@ -67554,7 +68458,7 @@ class PaneSessionImpl {
       session: view.session,
       transcriptQuietMs: Number.MAX_SAFE_INTEGER,
       chatQuietMs: Number.MAX_SAFE_INTEGER,
-      screen: null,
+      facts: null,
       paneExited: true,
       secondaryQuietMs: this.secondaryQuietMs,
       corroborationMs: 0
@@ -67604,7 +68508,7 @@ ${screenTailOf(this.screen)}`
   snapshot() {
     const view = this.follower.view();
     const terminal = isTerminalPhase(this.phase);
-    const lastAct = Math.max(this.screen.changedAt, view.lastAppendAt ?? 0);
+    const lastAct = Math.max(this.activityChangedAt, view.lastAppendAt ?? 0);
     const cur = view.current;
     const hasTranscript = view.availability === "ok" && view.usage.tokensIn + view.usage.tokensOut > 0;
     return {
@@ -67689,6 +68593,115 @@ ${screenTailOf(this.screen)}`
       return { ok: false, reason: "terminal" };
     return { ok: true, queued: this.queue.length };
   }
+  async resize(cols, rows) {
+    const size = clampPaneSize(cols, rows);
+    if (isTerminalPhase(this.phase))
+      return this.lastSizeOutcome();
+    if (!this.supportsResize)
+      throw new ContractErrorException("resize_unsupported", 'this magmux has no resize op (capabilities.verbs lacks "resize"); a newer magmux is needed');
+    if (!this.client)
+      return this.pendingOutcome(size);
+    if (samePaneSize(this.appliedSize, size) && samePaneSize(this.desiredSize, size) && !this.resizeDraining)
+      return { ...size, changed: false, seq: this.screen.seq };
+    this.desiredSize = size;
+    return new Promise((resolve, reject) => {
+      this.resizeWaiters.push({ resolve, reject });
+      this.kickResize();
+    });
+  }
+  pendingOutcome(size) {
+    this.desiredSize = { ...size };
+    return { ...size, changed: true, seq: this.screen.seq, pending: true };
+  }
+  lastSizeOutcome() {
+    return { cols: this.screen.cols, rows: this.screen.rows, changed: false, seq: this.screen.seq };
+  }
+  inResizeQuiet(at) {
+    return this.resizeQuietFrom > 0 && at >= this.resizeQuietFrom && at < this.resizeQuietUntil;
+  }
+  extendResizeQuiet() {
+    const now = Date.now();
+    if (now >= this.resizeQuietUntil)
+      this.resizeQuietFrom = now;
+    this.resizeQuietUntil = Math.max(this.resizeQuietUntil, now + RESIZE_QUIET_MS);
+  }
+  resizeOwed() {
+    return !!this.client && this.supportsResize && !isTerminalPhase(this.phase) && !samePaneSize(this.appliedSize, this.desiredSize) && !samePaneSize(this.lastSentSize, this.desiredSize);
+  }
+  kickResize() {
+    if (this.resizeDraining)
+      return;
+    this.resizeDraining = true;
+    this.drainResize().finally(() => {
+      this.resizeDraining = false;
+      if (this.resizeWaiters.length > 0 || this.resizeOwed())
+        this.kickResize();
+    });
+  }
+  async drainResize() {
+    let first = true;
+    while (first || this.resizeWaiters.length > 0 || this.resizeOwed()) {
+      first = false;
+      const batch = this.resizeWaiters.splice(0);
+      const answer = (r) => {
+        for (const w of batch)
+          w.resolve(r);
+      };
+      const fail = (e) => {
+        for (const w of batch)
+          w.reject(e);
+      };
+      if (isTerminalPhase(this.phase)) {
+        answer(this.lastSizeOutcome());
+        continue;
+      }
+      const want = { ...this.desiredSize };
+      const c = this.client;
+      if (!c) {
+        answer(this.pendingOutcome(want));
+        continue;
+      }
+      if (!this.supportsResize) {
+        fail(new ContractErrorException("resize_unsupported", "this magmux has no resize op"));
+        continue;
+      }
+      this.lastSentSize = want;
+      this.extendResizeQuiet();
+      const r = await c.request({ type: "resize", pane: 0, cols: want.cols, rows: want.rows }, RESIZE_REPLY_MS);
+      if (isTerminalPhase(this.phase)) {
+        answer(this.lastSizeOutcome());
+        continue;
+      }
+      if (!r.ok) {
+        if (r.code === "client_lost" || r.code === "client_timeout") {
+          this.appliedSize = null;
+          this.extendResizeQuiet();
+        }
+        if (r.code === "client_lost" || r.code === "client_closed") {
+          answer(this.pendingOutcome(this.desiredSize));
+          continue;
+        }
+        fail(new ContractErrorException("delivery_unavailable", `magmux did not resize the pane: ${r.code}${r.error ? `: ${r.error}` : ""}`));
+        continue;
+      }
+      const set = {
+        cols: typeof r.result.cols === "number" ? r.result.cols : want.cols,
+        rows: typeof r.result.rows === "number" ? r.result.rows : want.rows
+      };
+      this.appliedSize = set;
+      if (r.result.changed !== true) {
+        answer({ ...set, changed: false, seq: this.screen.seq });
+        continue;
+      }
+      this.extendResizeQuiet();
+      await this.waitFor(() => isTerminalPhase(this.phase) || this.screen.cols === set.cols && this.screen.rows === set.rows, RESIZE_SCREEN_MS);
+      if (isTerminalPhase(this.phase)) {
+        answer(this.lastSizeOutcome());
+        continue;
+      }
+      answer({ ...set, changed: true, seq: this.screen.seq });
+    }
+  }
   turnAnswer(index) {
     const done = this.answers.get(index);
     if (done !== undefined)
@@ -67704,6 +68717,7 @@ ${screenTailOf(this.screen)}`
   diagnostics() {
     const cur = this.follower.view().current;
     const rec = this.registryRec;
+    const g = this.gate;
     return {
       magmuxStderr: this.stderrHead,
       registry: rec ? { status: rec.status, waitingFor: rec.waitingFor, version: rec.version } : null,
@@ -67713,7 +68727,9 @@ ${screenTailOf(this.screen)}`
         linesReturned: cur.readCoverage.linesReturned,
         complete: cur.readCoverage.complete,
         reads: cur.readCoverage.reads
-      } : null
+      } : null,
+      gate: g && this.client ? { ready: g.ready, reason: g.reason, detail: g.detail, ageMs: Date.now() - g.receivedAt } : null,
+      lastSend: this.lastSend ? { ...this.lastSend } : null
     };
   }
   cancel() {
@@ -67770,6 +68786,9 @@ ${screenTailOf(this.screen)}`
     if (this.ticker)
       clearInterval(this.ticker);
     this.ticker = null;
+    if (this.gateTimer)
+      clearInterval(this.gateTimer);
+    this.gateTimer = null;
     await this.captureGroupBeforeReap();
     const c = this.client;
     if (c && !c.isClosed && !this.paneClosed) {
@@ -67881,6 +68900,94 @@ function signalQuietly(target, sig) {
     process.kill(target, sig);
   } catch {}
 }
+function launchSize(o) {
+  return o.initialSize ? clampPaneSize(o.initialSize.cols, o.initialSize.rows) : { cols: DEFAULT_PANE_COLS, rows: DEFAULT_PANE_ROWS };
+}
+function newAdmission(a) {
+  const now = Date.now();
+  return {
+    index: a.index,
+    text: a.text,
+    plan: a.plan,
+    line: a.plan.line,
+    initial: a.initial,
+    startedAt: now,
+    deadline: now + a.bound,
+    step: a.plan.mode === "command" ? "type" : "submit",
+    inFlight: false,
+    attempts: 0,
+    submittedUnproven: null,
+    stuckRetried: false,
+    panel: null,
+    stopped: false,
+    clearFirst: false,
+    clearAfter: 0,
+    lostType: null,
+    last: null,
+    noted: new Set
+  };
+}
+function markClearFirst(adm) {
+  adm.clearFirst = true;
+  adm.clearAfter = Date.now();
+}
+function sendShape(step, line) {
+  switch (step) {
+    case "submit":
+      return {
+        msg: { type: "send", pane: 0, text: line, typed: true, enter: true },
+        budget: { text: line, keys: 1, submit: true }
+      };
+    case "type":
+      return {
+        msg: { type: "send", pane: 0, text: line, typed: true, enter: false },
+        budget: { text: line, keys: 0, submit: false }
+      };
+    case "enter":
+      return {
+        msg: { type: "send", pane: 0, keys: ["enter"], enter: false },
+        budget: { text: "", keys: 1, submit: true }
+      };
+    default:
+      return assertNever(step);
+  }
+}
+function fixedSendMs(step, line) {
+  const rt = SEND_READY_WAIT_DEFAULT_MS;
+  return sendBudgetMs({ ...sendShape(step, line).budget, readyTimeoutMs: rt }) - rt;
+}
+function readyTimeoutFor(step, line, leftMs) {
+  const reserve = step === "type" ? fixedSendMs("enter", line) + SEND_CLIENT_SLACK_MS + MIN_READY_TIMEOUT_MS : 0;
+  const rt = Math.min(SEND_READY_WAIT_DEFAULT_MS, leftMs - fixedSendMs(step, line) - SEND_CLIENT_SLACK_MS - reserve);
+  return rt < MIN_READY_TIMEOUT_MS ? null : Math.floor(rt);
+}
+function describeLastReply(adm, gate) {
+  const o = adm.last;
+  if (!o) {
+    const g = gate ? gate.ready ? "ready" : gate.reason ?? "not ready" : "unknown";
+    return adm.attempts === 0 ? `no gated send fitted before the deadline (gate: ${g})` : `no magmux reply (gate: ${g})`;
+  }
+  switch (o.kind) {
+    case "busy":
+      return `last magmux reply: busy ${o.reason || "unknown"}${o.typed ? " (typed, Enter withheld)" : ""}${gate?.detail ? ` (${gate.detail})` : ""}`;
+    case "not_accepted":
+      return `last magmux reply: not_accepted ${o.reason}`;
+    case "accepted":
+      return `last magmux reply: ok ${o.accept} (${o.evidence})`;
+    case "in_box":
+      return "last magmux reply: in_box (the command was typed, its Enter never sent)";
+    case "bad_request":
+      return `last magmux reply: bad_request ${o.error}`;
+    case "reply_lost":
+    case "unsent":
+    case "pane_gone":
+      return `last magmux reply: ${o.code}`;
+    case "unexpected":
+      return `last magmux reply: ${o.code}`;
+    default:
+      return assertNever(o);
+  }
+}
 function isControl(text) {
   const t = text.trim();
   return t === "/exit" || t === "/quit";
@@ -67899,13 +69006,19 @@ function preparePane(o, root, parentEnv) {
   let dirs = null;
   try {
     const paneId = mintPaneId(o.kind, o.label);
-    const sockPath = sockPathFor(root, paneId);
-    const cwd = realpathSync3(o.cwd);
+    const sockPath = sockPathOf(root, paneId);
+    const cwd = realpathSync4(o.cwd);
     const launch = o.claudishSpawn ?? resolveClaudishLaunch(parentEnv);
     dirs = createLaunchDirs(root);
     const argv = buildClaudishPaneArgv(o.spawnModel, o.sessionUuid, dirs.turnDir, o.callerFlags);
     writeLauncherFiles(dirs.ctlDir, launcherScript(cwd, launch, argv));
-    const { magmuxEnv } = buildPaneEnv({ parentEnv, slotEnv: o.slotEnv, cwd, ctlDir: dirs.ctlDir });
+    const { magmuxEnv } = buildPaneEnv({
+      parentEnv,
+      slotEnv: o.slotEnv,
+      cwd,
+      ctlDir: dirs.ctlDir,
+      ...launchSize(o)
+    });
     return { paneId, sockPath, cwd, ...dirs, magmuxEnv };
   } catch (e) {
     for (const d of dirs ? [dirs.ctlDir, dirs.turnDir] : [])
@@ -67974,21 +69087,38 @@ async function startPaneSession(o) {
   await session.start({ magmuxBinary: magmux.binary, env: p.magmuxEnv, cwd: p.cwd });
   return session;
 }
-var BOOT_TIMEOUT_MS = 90000, ADMIT_TIMEOUT_MS = 30000, RESEND_AFTER_MS = 1e4, DEGRADED_ENTRY_MS = 1e4, SCREEN_SETTLE_QUIET_MS = 3000, PANEL_SETTLE_MS = 500, REPL_STABLE_MS = 3000, NUDGE_CLEAR_DEADLINE_MS = 3000, BOOT_STATIC_MS = 5000, TICK_MS = 250, WATCH_FPS = 4, POLL_BACKSTOP_MS = 1000, TURN_END_MISSING_FACTOR = 3, REGISTRY_READ_MS = 250, REGISTRY_DISAGREE_MS = 2000, REGISTRY_MISSING_MS = 5000, MAX_ANOMALY_KEYS = 64, KEPT_ANSWERS = 4, EVENT_REASON, VERDICT_EVENT, PaneStartError;
+var BOOT_TIMEOUT_MS = 90000, ADMIT_TIMEOUT_MS = 30000, DEGRADED_ENTRY_MS = 1e4, SCREEN_SETTLE_QUIET_MS = 3000, PANEL_SETTLE_MS = 500, SEND_CLIENT_SLACK_MS = 2000, MIN_READY_TIMEOUT_MS = 1000, BUSY_RETRY_MS = 250, MISMATCH_SETTLE_MS = 1000, CLEAR_WAIT_MS = 1000, BOOT_STATIC_MS = 5000, TICK_MS = 250, WATCH_FPS = 4, POLL_BACKSTOP_MS = 1000, TURN_END_MISSING_FACTOR = 3, RESIZE_REPLY_MS = 1e4, RESIZE_SCREEN_MS = 1000, GATE_POLL_MS = 250, GATE_REPLY_MS = 1000, GATE_STALE_MS = 1000, GATE_GRACE_MS, GATE_DEAD_BACKSTOP_MS = 1000, GATE_KINDLESS_REASONS, RUNTIME_DIALOG_KINDS, REGISTRY_READ_MS = 250, REGISTRY_DISAGREE_MS = 2000, REGISTRY_GATE_BOOT_DISAGREE_MS = 5000, REGISTRY_MISSING_MS = 5000, MAX_ANOMALY_KEYS = 64, KEPT_ANSWERS = 4, EVENT_REASON, VERDICT_EVENT, PaneStartError;
 var init_pane_session = __esm(() => {
   init_parent_session();
   init_process_tree();
   init_redact();
+  init_box_locate();
+  init_contract();
+  init_gate_binding();
+  init_input_gate();
   init_magmux_client();
   init_pane_launch();
   init_pane_registry();
   init_process_identity();
   init_prompt_delivery();
   init_screen_classifier();
+  init_screen_model();
   init_session_registry();
   init_settle_rule();
   init_slot_state();
   init_transcript_follower();
+  GATE_GRACE_MS = SECONDARY_QUIET_MS;
+  GATE_KINDLESS_REASONS = new Set([
+    "starting",
+    "terminal_not_ready",
+    "no_input_box"
+  ]);
+  RUNTIME_DIALOG_KINDS = new Set([
+    "permission",
+    "question",
+    "plan",
+    "select"
+  ]);
   EVENT_REASON = {
     boot_dialog: "first_run_dialog",
     boot_blocked: "boot_blocked",
@@ -68040,10 +69170,10 @@ __export(exports_session_discovery, {
   transcriptPathFor: () => transcriptPathFor
 });
 import { execFile as execFile3, execFileSync as execFileSync3 } from "child_process";
-import { closeSync as closeSync9, openSync as openSync9, readSync as readSync4, readdirSync as readdirSync8, realpathSync as realpathSync4, statSync as statSync11 } from "fs";
-import { basename as basename2, join as join48 } from "path";
+import { closeSync as closeSync9, openSync as openSync9, readSync as readSync4, readdirSync as readdirSync8, realpathSync as realpathSync5, statSync as statSync11 } from "fs";
+import { basename as basename3, join as join49 } from "path";
 function projectsDir(env = process.env) {
-  return join48(claudeConfigDir(env), "projects");
+  return join49(claudeConfigDir(env), "projects");
 }
 function slugForPath(absPath) {
   return projectDirNameFor(absPath);
@@ -68051,9 +69181,9 @@ function slugForPath(absPath) {
 function transcriptPathFor(cwd, sessionUuid, projectsRoot = projectsDir()) {
   let real = cwd;
   try {
-    real = realpathSync4(cwd);
+    real = realpathSync5(cwd);
   } catch {}
-  return join48(projectsRoot, slugForPath(real), `${sessionUuid}.jsonl`);
+  return join49(projectsRoot, slugForPath(real), `${sessionUuid}.jsonl`);
 }
 function isAgentSession(row) {
   return row.entrypoint !== undefined && row.entrypoint !== "cli";
@@ -68100,7 +69230,7 @@ function projectDirs() {
   }
 }
 function sessionsIn(dirName) {
-  const dir = join48(projectsDir(), dirName);
+  const dir = join49(projectsDir(), dirName);
   let names;
   try {
     names = readdirSync8(dir).filter((n) => n.endsWith(".jsonl"));
@@ -68109,13 +69239,13 @@ function sessionsIn(dirName) {
   }
   const rows = [];
   for (const n of names) {
-    const file = join48(dir, n);
+    const file = join49(dir, n);
     try {
       const st = statSync11(file);
       if (st.size === 0)
         continue;
       const row = {
-        id: basename2(n, ".jsonl"),
+        id: basename3(n, ".jsonl"),
         file,
         mtimeMs: st.mtimeMs,
         birthtimeMs: st.birthtimeMs,
@@ -68217,7 +69347,7 @@ function discoverWorktreeGroups(repo) {
     if (hit) {
       path = hit.path;
       live = true;
-      name = hit.path === repo.root ? "(root)" : basename2(hit.path);
+      name = hit.path === repo.root ? "(root)" : basename3(hit.path);
     } else if (at !== -1 && dir.startsWith(rootSlug)) {
       path = null;
       live = false;
@@ -68487,7 +69617,7 @@ var init_session_discovery = __esm(() => {
 // src/team-orchestrator.ts
 import { randomBytes as randomBytes8, randomUUID as randomUUID5 } from "crypto";
 import { existsSync as existsSync31, mkdirSync as mkdirSync21, readFileSync as readFileSync31, readdirSync as readdirSync9, statSync as statSync12, writeFileSync as writeFileSync22 } from "fs";
-import { basename as basename3, join as join49, resolve as resolve4 } from "path";
+import { basename as basename4, join as join50, resolve as resolve5 } from "path";
 function slotTerminal(e) {
   if (!e.session)
     return true;
@@ -68524,13 +69654,13 @@ function addressRun(path, runId) {
   pruneRuns();
   if (runId) {
     const run = teamRuns.get(runId) ?? null;
-    if (run && path !== undefined && resolve4(path) !== run.path)
+    if (run && path !== undefined && resolve5(path) !== run.path)
       return null;
     return run;
   }
   if (path === undefined)
     return null;
-  const id = newestRunByPath.get(resolve4(path));
+  const id = newestRunByPath.get(resolve5(path));
   return id ? teamRuns.get(id) ?? null : null;
 }
 function activeRunAt(path) {
@@ -68556,7 +69686,7 @@ function notableAnomalies(snap) {
   return snap.anomalies.filter((a) => a.startsWith("background_shell_open") || a.startsWith("turn_end_record_missing") || a.startsWith("agent_count_mismatch") || a.startsWith("prompt_not_read"));
 }
 function upstreamLogPath(path, id) {
-  return join49(path, "errors", `${id}-upstream.jsonl`);
+  return join50(path, "errors", `${id}-upstream.jsonl`);
 }
 function neverSpawnedRow(e, m) {
   return {
@@ -68649,9 +69779,9 @@ function teamRunRowFromDisk(path, status) {
   const settled = slots.length > 0 && slots.every((s) => isTerminalState(s.state));
   const completions = Object.values(status.models ?? {}).map((m) => m?.completedAt ? Date.parse(m.completedAt) : Number.NaN).filter(Number.isFinite);
   return {
-    run_id: status.runId ?? basename3(path),
+    run_id: status.runId ?? basename4(path),
     path,
-    kind: status.kind ?? (basename3(path) === "judging" ? "judge" : "run"),
+    kind: status.kind ?? (basename4(path) === "judging" ? "judge" : "run"),
     started_at: status.startedAt,
     finished_at: settled ? new Date(completions.length ? Math.max(...completions) : statusMtimeMs(path) ?? Date.parse(status.startedAt)).toISOString() : null,
     state: settled ? "SETTLED" : "ACTIVE",
@@ -68661,14 +69791,14 @@ function teamRunRowFromDisk(path, status) {
 }
 function statusMtimeMs(path) {
   try {
-    return statSync12(join49(path, "status.json")).mtimeMs;
+    return statSync12(join50(path, "status.json")).mtimeMs;
   } catch {
     return null;
   }
 }
 function readManifestOrNull(path) {
   try {
-    return JSON.parse(readFileSync31(join49(path, "manifest.json"), "utf-8"));
+    return JSON.parse(readFileSync31(join50(path, "manifest.json"), "utf-8"));
   } catch {
     return null;
   }
@@ -68702,10 +69832,10 @@ async function cancelTeamRun(path, slot, runId) {
 function neverSpawnedCapture() {
   return {
     seq: 0,
-    cols: 160,
-    rows: 50,
+    cols: DEFAULT_PANE_COLS,
+    rows: DEFAULT_PANE_ROWS,
     cursor: { x: 0, y: 0 },
-    lines: Array.from({ length: 50 }, () => ""),
+    lines: Array.from({ length: DEFAULT_PANE_ROWS }, () => ""),
     final: true
   };
 }
@@ -68722,6 +69852,18 @@ function captureTeamSlot(path, slot, sinceSeq, spans, runId) {
   }
   return e.session.capture(sinceSeq, { spans: spans === true });
 }
+async function resizeTeamSlot(path, slot, cols, rows, runId) {
+  const run = addressRun(path, runId);
+  if (!run)
+    throw unknownRun(path, runId);
+  const e = run.slots.get(slot);
+  if (!e)
+    throw new ContractErrorException("unknown_slot", `run ${run.runId} has no slot ${JSON.stringify(slot)}`);
+  const where = { run_id: run.runId, path: run.path, slot };
+  if (!e.session)
+    return { ...where, cols: DEFAULT_PANE_COLS, rows: DEFAULT_PANE_ROWS, changed: false, seq: 0 };
+  return { ...where, ...await e.session.resize(cols, rows) };
+}
 function teamLiveMaps(path, runId) {
   const run = addressRun(path, runId);
   if (!run)
@@ -68860,7 +70002,7 @@ function persistErrorLog(errorLogPath, header, sections) {
   } catch {}
 }
 function validateSessionPath(sessionPath) {
-  const resolved = resolve4(sessionPath);
+  const resolved = resolve5(sessionPath);
   const cwd = process.cwd();
   if (!resolved.startsWith(`${cwd}/`) && resolved !== cwd) {
     throw new Error(`Session path must be within current directory: ${sessionPath}`);
@@ -68868,7 +70010,7 @@ function validateSessionPath(sessionPath) {
   return resolved;
 }
 function readTeamInputFile(inputPath) {
-  const resolved = resolve4(inputPath);
+  const resolved = resolve5(inputPath);
   const cwd = process.cwd();
   if (!resolved.startsWith(`${cwd}/`) && resolved !== cwd) {
     throw new Error(`Input file must be within current directory: ${inputPath}`);
@@ -68886,14 +70028,14 @@ function setupSession(sessionPath, models, input) {
   if (models.length === 0) {
     throw new Error("At least one model is required");
   }
-  if (existsSync31(join49(sessionPath, "manifest.json"))) {
+  if (existsSync31(join50(sessionPath, "manifest.json"))) {
     throw new Error(`Session already exists at ${sessionPath}. Use a new directory path or delete the existing session first.`);
   }
-  mkdirSync21(join49(sessionPath, "work"), { recursive: true });
-  mkdirSync21(join49(sessionPath, "errors"), { recursive: true });
+  mkdirSync21(join50(sessionPath, "work"), { recursive: true });
+  mkdirSync21(join50(sessionPath, "errors"), { recursive: true });
   if (input !== undefined) {
-    writeFileSync22(join49(sessionPath, "input.md"), input, "utf-8");
-  } else if (!existsSync31(join49(sessionPath, "input.md"))) {
+    writeFileSync22(join50(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync31(join50(sessionPath, "input.md"))) {
     throw new Error(`No input.md found at ${sessionPath} and no input provided`);
   }
   const ids = models.map((_, i) => String(i + 1).padStart(2, "0"));
@@ -68910,9 +70052,9 @@ function setupSession(sessionPath, models, input) {
       model: models[i],
       assignedAt: now
     };
-    mkdirSync21(join49(sessionPath, "work", anonId), { recursive: true });
+    mkdirSync21(join50(sessionPath, "work", anonId), { recursive: true });
   }
-  writeFileSync22(join49(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync22(join50(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
   const status = {
     startedAt: now,
     models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
@@ -68927,7 +70069,7 @@ function setupSession(sessionPath, models, input) {
       }
     ]))
   };
-  writeFileSync22(join49(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+  writeFileSync22(join50(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
   return manifest;
 }
 function assertValidRequirePattern(pattern) {
@@ -68955,14 +70097,14 @@ async function preflightTeamRun(opts) {
       throw new Error(`invalid_args: ${refusal}`);
   }
   await assertMagmuxAvailable();
-  assertNoActiveRun(resolve4(opts.path));
+  assertNoActiveRun(resolve5(opts.path));
   const root = sockRootFor(opts.parentEnv ?? process.env);
   const live = livePaneCount(root);
   if (live + opts.slots > MAX_LIVE_PANES)
     throw new Error(`pane_limit: ${live} live panes for this user, ${opts.slots} more would exceed ${MAX_LIVE_PANES}`);
 }
 function mintRunId(path, startMs) {
-  return `${basename3(path)}-${startMs.toString(36)}-${randomBytes8(3).toString("hex")}`;
+  return `${basename4(path)}-${startMs.toString(36)}-${randomBytes8(3).toString("hex")}`;
 }
 function startModels(sessionPath, opts = {}) {
   const flight = { aborted: false };
@@ -68986,10 +70128,10 @@ async function startModelsIn(flight, sessionPath, opts) {
   const flagCheck = checkChildFlags(claudeFlags);
   if (!flagCheck.ok)
     throw new Error(`invalid_args: ${flagCheck.message}`);
-  const path = resolve4(sessionPath);
-  const manifest = JSON.parse(readFileSync31(join49(path, "manifest.json"), "utf-8"));
-  const statusPath = join49(path, "status.json");
-  const inputContent = readFileSync31(join49(path, "input.md"), "utf-8");
+  const path = resolve5(sessionPath);
+  const manifest = JSON.parse(readFileSync31(join50(path, "manifest.json"), "utf-8"));
+  const statusPath = join50(path, "status.json");
+  const inputContent = readFileSync31(join50(path, "input.md"), "utf-8");
   const readAvailable = !flagsRemoveRead(claudeFlags);
   const refusal = deliveryRefusal(inputContent, readAvailable);
   if (refusal)
@@ -69027,13 +70169,13 @@ async function startModelsIn(flight, sessionPath, opts) {
   mkdirSync21(statsDir(path), { recursive: true });
   const entries = new Map;
   let run = null;
-  const errorLogPathOf = (id) => join49(path, "errors", `${id}.log`);
+  const errorLogPathOf = (id) => join50(path, "errors", `${id}.log`);
   const upstreamLogOf = (id) => upstreamLogPath(path, id);
   const commandOf = (e) => ["claudish", "-i", "--model", e.spawnModel ?? e.model, "-y", "--quiet", ...claudeFlags].join(" ");
   function writeResponse(e, text) {
     e.answer = text;
     try {
-      writeFileSync22(join49(path, `response-${e.id}.md`), text, "utf-8");
+      writeFileSync22(join50(path, `response-${e.id}.md`), text, "utf-8");
     } catch (err) {
       persistErrorLog(errorLogPathOf(e.id), `response file not written: ${String(err)}`, []);
     }
@@ -69350,7 +70492,7 @@ async function startModelsIn(flight, sessionPath, opts) {
   done.catch(() => {});
   return {
     runId,
-    teamSessionId: basename3(path),
+    teamSessionId: basename4(path),
     sessionPath: path,
     slots: Object.fromEntries(Object.entries(manifest.models).map(([anonId, entry]) => [entry.model, anonId])),
     done
@@ -69361,9 +70503,9 @@ async function runModels(sessionPath, opts = {}) {
   return handle.done;
 }
 async function judgeResponses(sessionPath, opts = {}) {
-  const active = activeRunAt(resolve4(sessionPath));
+  const active = activeRunAt(resolve5(sessionPath));
   if (active)
-    throw new Error(`invalid_args: the team run at ${resolve4(sessionPath)} is still ACTIVE (run_id ${active.runId}); judge it once it has settled`);
+    throw new Error(`invalid_args: the team run at ${resolve5(sessionPath)} is still ACTIVE (run_id ${active.runId}); judge it once it has settled`);
   const responseFiles = readdirSync9(sessionPath).filter((f) => f.startsWith("response-") && f.endsWith(".md")).sort();
   if (responseFiles.length < 2) {
     throw new Error(`Need at least 2 responses to judge, found ${responseFiles.length}`);
@@ -69371,13 +70513,13 @@ async function judgeResponses(sessionPath, opts = {}) {
   const responses = {};
   for (const file of responseFiles) {
     const id = file.replace(/^response-/, "").replace(/\.md$/, "");
-    responses[id] = readFileSync31(join49(sessionPath, file), "utf-8");
+    responses[id] = readFileSync31(join50(sessionPath, file), "utf-8");
   }
-  const input = readFileSync31(join49(sessionPath, "input.md"), "utf-8");
+  const input = readFileSync31(join50(sessionPath, "input.md"), "utf-8");
   const judgePrompt = buildJudgePrompt(input, responses);
-  writeFileSync22(join49(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  writeFileSync22(join50(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
   const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
-  const judgePath = join49(sessionPath, "judging");
+  const judgePath = join50(sessionPath, "judging");
   mkdirSync21(judgePath, { recursive: true });
   setupSession(judgePath, judgeModels, judgePrompt);
   await runModels(judgePath, {
@@ -69388,11 +70530,11 @@ async function judgeResponses(sessionPath, opts = {}) {
   });
   const votes = parseJudgeVotes(judgePath, Object.keys(responses));
   const verdict = aggregateVerdict(votes, Object.keys(responses));
-  writeFileSync22(join49(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  writeFileSync22(join50(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
   return verdict;
 }
 function getStatus(sessionPath) {
-  return JSON.parse(readFileSync31(join49(sessionPath, "status.json"), "utf-8"));
+  return JSON.parse(readFileSync31(join50(sessionPath, "status.json"), "utf-8"));
 }
 function readTeamStatus(sessionPath) {
   try {
@@ -69428,7 +70570,7 @@ function fisherYatesShuffle(arr) {
   return arr;
 }
 function getDefaultJudgeModels(sessionPath) {
-  const manifest = JSON.parse(readFileSync31(join49(sessionPath, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync31(join50(sessionPath, "manifest.json"), "utf-8"));
   return Object.values(manifest.models).map((e) => e.model);
 }
 function buildJudgePrompt(input, responses) {
@@ -69491,7 +70633,7 @@ function parseJudgeVotes(judgePath, responseIds) {
     const judgeId = file.replace(/^response-/, "").replace(/\.md$/, "");
     let content;
     try {
-      content = readFileSync31(join49(judgePath, file), "utf-8");
+      content = readFileSync31(join50(judgePath, file), "utf-8");
     } catch {
       continue;
     }
@@ -69543,7 +70685,7 @@ function aggregateVerdict(votes, responseIds) {
 function formatVerdict(verdict, sessionPath) {
   let manifest = null;
   try {
-    manifest = JSON.parse(readFileSync31(join49(sessionPath, "manifest.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync31(join50(sessionPath, "manifest.json"), "utf-8"));
   } catch {}
   let output = `# Team Verdict
 
@@ -69605,7 +70747,7 @@ import {
   statSync as statSync13,
   writeFileSync as writeFileSync23
 } from "fs";
-import { join as join50, resolve as resolve5, sep } from "path";
+import { join as join51, resolve as resolve6, sep } from "path";
 function normaliseTimeoutSeconds(raw) {
   const n = typeof raw === "string" && raw.trim() !== "" ? Number(raw) : raw;
   if (typeof n !== "number" || !Number.isFinite(n))
@@ -69771,7 +70913,7 @@ function dropLeadingFragment(tail) {
   return firstBreak === -1 ? tail.text : tail.text.slice(firstBreak + 1);
 }
 function diskAccounting(sessionDir) {
-  const stats = readTokenStatsAt(join50(sessionDir, "tokens.json"));
+  const stats = readTokenStatsAt(join51(sessionDir, "tokens.json"));
   return {
     tokensIn: stats?.billed_input_tokens ?? null,
     tokensOut: stats?.output_tokens ?? null,
@@ -69794,10 +70936,10 @@ function diskProseBytes(tail, fileBytes) {
 function blankFinalCapture() {
   return {
     seq: 0,
-    cols: 160,
-    rows: 50,
+    cols: DEFAULT_PANE_COLS,
+    rows: DEFAULT_PANE_ROWS,
     cursor: { x: 0, y: 0 },
-    lines: Array.from({ length: 50 }, () => ""),
+    lines: Array.from({ length: DEFAULT_PANE_ROWS }, () => ""),
     final: true
   };
 }
@@ -69842,7 +70984,7 @@ class SessionManager {
     let dir = "";
     for (let attempt = 0;; attempt++) {
       id = `team-${randomUUID6().replace(/-/g, "").slice(0, 8)}`;
-      dir = join50(this.sessionsDir, id);
+      dir = join51(this.sessionsDir, id);
       try {
         mkdirSync22(dir);
         break;
@@ -69857,7 +70999,7 @@ class SessionManager {
       sessionId: id,
       parentClaudeSessionId: opts.parentClaudeSessionId,
       startedAt,
-      teamPath: resolve5(opts.teamPath),
+      teamPath: resolve6(opts.teamPath),
       slots: opts.slots
     });
     this.teamRunStarts.set(id, startedAt);
@@ -69874,9 +71016,9 @@ class SessionManager {
       if (dir === null)
         throw new Error("not a record id");
       const completedAt = new Date().toISOString();
-      const startedAt = this.teamRunStarts.get(record) ?? metaString(readJsonObject(join50(dir, "spawn.json"), META_READ_LIMIT)?.startedAt) ?? completedAt;
+      const startedAt = this.teamRunStarts.get(record) ?? metaString(readJsonObject(join51(dir, "spawn.json"), META_READ_LIMIT)?.startedAt) ?? completedAt;
       const elapsedMs = Date.parse(completedAt) - Date.parse(startedAt);
-      writeJsonAtomic(join50(dir, "meta.json"), {
+      writeJsonAtomic(join51(dir, "meta.json"), {
         kind: "team",
         status: outcome.status,
         startedAt,
@@ -69908,7 +71050,7 @@ class SessionManager {
       startedAt,
       ...rest
     };
-    writeJsonAtomic(join50(dir, "spawn.json"), body);
+    writeJsonAtomic(join51(dir, "spawn.json"), body);
   }
   async createSession(opts) {
     if (this.activeSessions + this.starting >= this.maxSessions) {
@@ -69967,10 +71109,10 @@ class SessionManager {
     const claudeSessionId = randomUUID6();
     const timeout = normaliseTimeoutSeconds(opts.timeoutSeconds);
     const startedAt = new Date().toISOString();
-    const sessionDir = opts.sessionDir ?? join50(this.sessionsDir, sessionId);
+    const sessionDir = opts.sessionDir ?? join51(this.sessionsDir, sessionId);
     mkdirSync22(sessionDir, { recursive: true });
     if (opts.prompt)
-      writeFileSync23(join50(sessionDir, "prompt.md"), opts.prompt, "utf-8");
+      writeFileSync23(join51(sessionDir, "prompt.md"), opts.prompt, "utf-8");
     this.writeSpawnRecord(sessionDir, {
       kind: "session",
       sessionId,
@@ -69983,7 +71125,7 @@ class SessionManager {
     const cwd = opts.cwd ?? process.cwd();
     const parentEnv = opts.parentEnv ?? this.parentEnv;
     const spawnModel = opts.spawnModel ?? null;
-    const tokenFile = opts.tokenFile ?? join50(sessionDir, "tokens.json");
+    const tokenFile = opts.tokenFile ?? join51(sessionDir, "tokens.json");
     return {
       info: {
         sessionId,
@@ -70019,28 +71161,30 @@ class SessionManager {
       },
       session: null,
       scrollback: new ScrollbackBuffer(this.scrollbackCapacity),
-      outputLogStream: createWriteStream(join50(sessionDir, "output.log")),
+      outputLogStream: createWriteStream(join51(sessionDir, "output.log")),
       sessionDir,
       cwd,
       tokenFile,
-      eventLogPath: join50(sessionDir, "events.jsonl"),
+      eventLogPath: join51(sessionDir, "events.jsonl"),
       eventLogBytes: 0,
-      upstreamErrorLogPath: join50(sessionDir, "upstream-errors.jsonl"),
+      upstreamErrorLogPath: join51(sessionDir, "upstream-errors.jsonl"),
       eventRing: [],
       proseBytes: 0,
       answeredTurns: new Map,
-      waitLogPath: join50(sessionDir, "waits.jsonl"),
+      waitLogPath: join51(sessionDir, "waits.jsonl"),
       waitLogBytes: 0,
       waitSince: null,
       ended: false,
       evictHandle: null,
       lastLoggedTool: null,
       assistantIdsLogged: 0,
-      anomaliesLogged: new Set
+      anomaliesLogged: new Set,
+      requestedSize: null
     };
   }
   async startPane(entry, opts, p) {
     const info = entry.info;
+    const launch = entry.requestedSize;
     const paneOpts = {
       kind: "s",
       label: info.sessionId,
@@ -70055,6 +71199,7 @@ class SessionManager {
       },
       shape: info.shape,
       ...opts.prompt ? { initialPrompt: opts.prompt } : {},
+      ...launch ? { initialSize: launch } : {},
       readAvailable: p.readAvailable,
       decide: (turn) => this.decide(entry, turn),
       onBlocked: (b) => this.onBlocked(entry, b),
@@ -70070,6 +71215,12 @@ class SessionManager {
       this.failNeverSpawned(entry, err);
       throw err;
     }
+    const asked = entry.requestedSize;
+    entry.requestedSize = null;
+    if (asked && (asked.cols !== launch?.cols || asked.rows !== launch?.rows))
+      entry.session.resize(asked.cols, asked.rows).catch(() => {
+        return;
+      });
     if (!entry.ended)
       this.applySnapshot(entry, entry.session.snapshot());
   }
@@ -70163,7 +71314,7 @@ class SessionManager {
       try {
         const text = screenLines.join(`
 `).replace(/\s+$/, "");
-        writeFileSync23(join50(entry.sessionDir, "screen.txt"), `${redactSecrets2(text)}
+        writeFileSync23(join51(entry.sessionDir, "screen.txt"), `${redactSecrets2(text)}
 `, "utf-8");
       } catch {}
     }
@@ -70177,7 +71328,7 @@ class SessionManager {
       entry.waitSince = null;
     }
     try {
-      writeJsonAtomic(join50(entry.sessionDir, "meta.json"), toMetaRecord(entry.info, entry.cwd));
+      writeJsonAtomic(join51(entry.sessionDir, "meta.json"), toMetaRecord(entry.info, entry.cwd));
     } catch (err) {
       process.stderr.write(`[claudish] session ${entry.info.sessionId}: could not write meta.json: ` + `${err instanceof Error ? err.message : String(err)}
 `);
@@ -70321,6 +71472,8 @@ class SessionManager {
         registry: null,
         preambleBytes: 0,
         readCoverage: null,
+        gate: null,
+        lastSend: null,
         claudeCodeVersion: null,
         anomalies: entry.info.detail ? [entry.info.detail] : []
       };
@@ -70335,6 +71488,8 @@ class SessionManager {
       registry: pane.registry,
       preambleBytes: pane.preambleBytes,
       readCoverage: pane.readCoverage,
+      gate: pane.gate,
+      lastSend: pane.lastSend,
       claudeCodeVersion: snap.claudeCodeVersion,
       anomalies: snap.anomalies
     };
@@ -70348,6 +71503,26 @@ class SessionManager {
     const r = entry.session.cancel();
     return { session_id: sessionId, state: r.state, changed: r.changed };
   }
+  async resizeSession(sessionId, cols, rows) {
+    const entry = this.liveEntry(sessionId);
+    if (!entry)
+      throw unknownSession(sessionId);
+    if (!entry.session) {
+      if (isTerminalState(entry.info.state))
+        return {
+          session_id: sessionId,
+          cols: DEFAULT_PANE_COLS,
+          rows: DEFAULT_PANE_ROWS,
+          changed: false,
+          seq: 0
+        };
+      const size = clampPaneSize(cols, rows);
+      entry.requestedSize = size;
+      return { session_id: sessionId, ...size, changed: true, seq: 0, pending: true };
+    }
+    const r = await entry.session.resize(cols, rows);
+    return { session_id: sessionId, ...r };
+  }
   captureSession(sessionId, sinceSeq, spans) {
     const entry = this.liveEntry(sessionId);
     if (!entry)
@@ -70411,9 +71586,9 @@ class SessionManager {
   diskSessionDir(sessionId) {
     if (!SESSION_ID_RE.test(sessionId))
       return null;
-    const root = resolve5(this.sessionsDir);
-    const dir = resolve5(root, sessionId);
-    if (dir !== join50(root, sessionId))
+    const root = resolve6(this.sessionsDir);
+    const dir = resolve6(root, sessionId);
+    if (dir !== join51(root, sessionId))
       return null;
     if (!dir.startsWith(root + sep))
       return null;
@@ -70432,10 +71607,10 @@ class SessionManager {
     } catch {
       return null;
     }
-    const spawnRecord = readJsonObject(join50(sessionDir, "spawn.json"), META_READ_LIMIT);
+    const spawnRecord = readJsonObject(join51(sessionDir, "spawn.json"), META_READ_LIMIT);
     if (spawnRecord?.kind === "team")
       return null;
-    const meta = readJsonObject(join50(sessionDir, "meta.json"), META_READ_LIMIT);
+    const meta = readJsonObject(join51(sessionDir, "meta.json"), META_READ_LIMIT);
     if (meta?.kind === "team")
       return null;
     const partial = meta === null;
@@ -70457,7 +71632,7 @@ class SessionManager {
     return stored;
   }
   diskOutput(record, tailLines) {
-    const tail = readTailText(join50(record.sessionDir, "output.log"), OUTPUT_TAIL_BYTES);
+    const tail = readTailText(join51(record.sessionDir, "output.log"), OUTPUT_TAIL_BYTES);
     const buffer = new ScrollbackBuffer(this.scrollbackCapacity);
     if (tail?.text)
       buffer.append(dropLeadingFragment(tail));
@@ -70477,12 +71652,12 @@ class SessionManager {
   }
   diskDiagnostics(record, limit) {
     const { sessionDir, info } = record;
-    const eventLogPath = join50(sessionDir, "events.jsonl");
-    const upstreamErrorLogPath = join50(sessionDir, "upstream-errors.jsonl");
-    const outputLogPath = join50(sessionDir, "output.log");
+    const eventLogPath = join51(sessionDir, "events.jsonl");
+    const upstreamErrorLogPath = join51(sessionDir, "upstream-errors.jsonl");
+    const outputLogPath = join51(sessionDir, "output.log");
     const events = readTailLines2(eventLogPath, EVENT_TAIL_BYTES);
     const outputTail = readTailText(outputLogPath, OUTPUT_TAIL_BYTES);
-    const screen = readTailText(join50(sessionDir, "screen.txt"), SCREEN_READ_BYTES);
+    const screen = readTailText(join51(sessionDir, "screen.txt"), SCREEN_READ_BYTES);
     return {
       sessionId: info.sessionId,
       state: info.state,
@@ -70515,6 +71690,8 @@ class SessionManager {
       turnSource: info.turnSource,
       preambleBytes: 0,
       readCoverage: null,
+      gate: null,
+      lastSend: null,
       claudeCodeVersion: null,
       anomalies: record.partial ? [
         `no readable meta.json in ${sessionDir} \u2014 this record was reconstructed from ` + "the remaining artifacts, so state, exit code and timings are unknown. The " + "session's process died before it could write a verdict."
@@ -70867,7 +72044,7 @@ var init_progress_heartbeat = __esm(() => {
 import { spawn as spawn2 } from "child_process";
 import { mkdirSync as mkdirSync23, mkdtempSync as mkdtempSync3, rmSync as rmSync7, writeFileSync as writeFileSync24 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join51 } from "path";
+import { join as join52 } from "path";
 function claudeCodePrintArgv(model, systemPromptFile) {
   const head = [PRINT_FLAGS[0], "--model", model, ...PRINT_FLAGS.slice(1)];
   return systemPromptFile !== undefined ? [...head, "--system-prompt-file", systemPromptFile] : [...head, "--system-prompt", ""];
@@ -70985,13 +72162,13 @@ async function runPromptViaClaudeCode(model, prompt, systemPrompt, opts = {}) {
   } catch (e) {
     throw new Error(`cannot start claudish (${parentEnv.CLAUDISH_BIN?.trim() || "claudish"}): ${e instanceof Error ? e.message : String(e)}`);
   }
-  const root = mkdtempSync3(join51(tmpdir2(), "claudish-run-prompt-"));
+  const root = mkdtempSync3(join52(tmpdir2(), "claudish-run-prompt-"));
   try {
-    const cwd = join51(root, "cwd");
+    const cwd = join52(root, "cwd");
     mkdirSync23(cwd, { mode: 448 });
     let systemPromptFile;
     if (typeof systemPrompt === "string" && systemPrompt.length > 0) {
-      systemPromptFile = join51(root, "system-prompt.txt");
+      systemPromptFile = join52(root, "system-prompt.txt");
       writeFileSync24(systemPromptFile, systemPrompt, { mode: 384 });
     }
     const argv = claudeCodePrintArgv(model, systemPromptFile);
@@ -71099,7 +72276,7 @@ var init_run_prompt_claude_code = __esm(() => {
 // src/mcp-server.ts
 import { existsSync as existsSync33, mkdirSync as mkdirSync24, readFileSync as readFileSync33, readdirSync as readdirSync10, writeFileSync as writeFileSync25 } from "fs";
 import { homedir as homedir35 } from "os";
-import { dirname as dirname14, join as join52, resolve as resolve6 } from "path";
+import { dirname as dirname15, join as join53, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function loadAllModels(forceRefresh = false) {
   if (!forceRefresh && existsSync33(OPENROUTER_MODELS_CACHE_PATH)) {
@@ -71394,6 +72571,12 @@ function optionalInteger(raw, name) {
     throw new ContractErrorException("invalid_args", `'${name}' must be an integer`);
   return raw;
 }
+function requiredInteger(raw, name, mode) {
+  const n = optionalInteger(raw, name);
+  if (n === undefined)
+    throw new ContractErrorException("invalid_args", `'${name}' is required${mode ? ` for mode '${mode}'` : ""}`);
+  return n;
+}
 function teamStatusAnswer(path, runId) {
   let row = null;
   if (runId) {
@@ -71433,6 +72616,8 @@ async function teamContractVerb(mode, args) {
     const slot = optionalString(args.slot, "slot");
     const since = optionalInteger(args.since_seq, "since_seq");
     const spans = optionalBoolean(args.spans, "spans");
+    const cols = mode === "resize" ? requiredInteger(args.cols, "cols", mode) : undefined;
+    const rows = mode === "resize" ? requiredInteger(args.rows, "rows", mode) : undefined;
     switch (mode) {
       case "status":
         return contractAnswer(teamStatusAnswer(path, runId));
@@ -71443,6 +72628,11 @@ async function teamContractVerb(mode, args) {
           throw new ContractErrorException("invalid_args", "'slot' is required for mode 'capture'");
         return contractAnswer(captureTeamSlot(path, slot, since, spans, runId));
       }
+      case "resize": {
+        if (slot === undefined)
+          throw new ContractErrorException("invalid_args", "'slot' is required for mode 'resize'");
+        return contractAnswer(await resizeTeamSlot(path, slot, cols, rows, runId));
+      }
     }
   } catch (e) {
     return contractErrorAnswer(e);
@@ -71816,18 +73006,18 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
   });
   tools.push({
     name: "team",
-    description: "Run AI models on a task with anonymized outputs and optional blind judging. Every " + "slot is an interactive Claude Code session in its own headless magmux pane. " + "Modes: 'run' (START the models and return once each has taken its prompt \u2014 it does " + "NOT wait for answers), 'status' (per-slot state; read `run.slots`), 'list' (every " + "run this server holds), 'capture' (one slot's screen), 'cancel' (stop one slot or " + "the whole run), 'judge' (blind-vote on existing outputs), 'run-and-judge' (the " + "blocking pipeline). Poll 'status' (read run.slots) or 'list'. " + "NO SLOT IS EVER KILLED ON A TIMER once its prompt is accepted. A team slot is a full " + "Claude Code session and may work for a long time; a slot inside a build or test " + "suite emits nothing for minutes and is working, not stuck. Judge the silence " + "against the task you set, and use 'cancel' if you decide a slot is wedged. A slot " + "that stops on a question it cannot answer is FAILED 'blocked' (team has no way to " + "answer it). JUDGING A WORKING SLOT: read live_output_bytes_by_slot, " + "idle_seconds_by_slot and activity_by_slot (or each row's idle_seconds and " + "activity). Do NOT use 'outputSize' \u2014 it is the size of the final answer, written " + "only when a slot finishes, so it is 0 for every working slot no matter how much " + "that slot has produced.",
+    description: "Run AI models on a task with anonymized outputs and optional blind judging. Every " + "slot is an interactive Claude Code session in its own headless magmux pane. " + "Modes: 'run' (START the models and return once each has taken its prompt \u2014 it does " + "NOT wait for answers), 'status' (per-slot state; read `run.slots`), 'list' (every " + "run this server holds), 'capture' (one slot's screen), 'resize' (set one slot's " + "terminal size), 'cancel' (stop one slot or the whole run), 'judge'(blind-vote on existing outputs), 'run-and-judge' (the " + "blocking pipeline). Poll 'status' (read run.slots) or 'list'. " + "NO SLOT IS EVER KILLED ON A TIMER once its prompt is accepted. A team slot is a full " + "Claude Code session and may work for a long time; a slot inside a build or test " + "suite emits nothing for minutes and is working, not stuck. Judge the silence " + "against the task you set, and use 'cancel' if you decide a slot is wedged. A slot " + "that stops on a question it cannot answer is FAILED 'blocked' (team has no way to " + "answer it). JUDGING A WORKING SLOT: read live_output_bytes_by_slot, " + "idle_seconds_by_slot and activity_by_slot (or each row's idle_seconds and " + "activity). Do NOT use 'outputSize' \u2014 it is the size of the final answer, written " + "only when a slot finishes, so it is 0 for every working slot no matter how much " + "that slot has produced.",
     inputSchema: {
       type: "object",
       properties: {
         mode: {
           type: "string",
-          enum: ["run", "judge", "run-and-judge", "status", "cancel", "list", "capture"],
-          description: "Operation mode. 'run' STARTS the models and returns once every slot has taken " + "its prompt (or failed to) \u2014 it does not wait for answers. Poll 'status' (read " + "`run.slots`) or 'list' for progress, then 'judge' once the slots have " + "finished. 'capture' returns one slot's screen. 'run-and-judge' is the blocking " + "pipeline and holds the call open for the whole run. 'cancel' stops one slot or " + "the whole run."
+          enum: ["run", "judge", "run-and-judge", "status", "cancel", "list", "capture", "resize"],
+          description: "Operation mode. 'run' STARTS the models and returns once every slot has taken " + "its prompt (or failed to) \u2014 it does not wait for answers. Poll 'status' (read " + "`run.slots`) or 'list' for progress, then 'judge' once the slots have " + "finished. 'capture' returns one slot's screen; 'resize' sets its terminal size. " + "'run-and-judge' is the blocking pipeline and holds the call open for the whole run. 'cancel' stops one slot or " + "the whole run."
         },
         slot: {
           type: "string",
-          description: "For 'cancel' and 'capture': the anonymised slot id (e.g. '02') from the slot " + "map 'run' returned. 'capture' requires it; for 'cancel', omit it to stop every " + "slot in the run."
+          description: "For 'cancel', 'capture' and 'resize': the anonymised slot id (e.g. '02') from the " + "slot map 'run' returned. 'capture' and 'resize' require it; for 'cancel', omit it " + "to stop every slot in the run."
         },
         path: {
           type: "string",
@@ -71835,7 +73025,7 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
         },
         run_id: {
           type: "string",
-          description: "For 'status', 'cancel' and 'capture': the run_id a 'run' answer returned. It " + "addresses THAT run while this server retains it, even after a newer run reused " + "the path. Omit it to address the newest run at 'path'."
+          description: "For 'status', 'cancel', 'capture' and 'resize': the run_id a 'run' answer " + "returned. It " + "addresses THAT run while this server retains it, even after a newer run reused " + "the path. Omit it to address the newest run at 'path'."
         },
         since_seq: {
           type: "number",
@@ -71845,6 +73035,14 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
           type: "boolean",
           description: "For 'capture': also return the colour/attribute spans of each line."
         },
+        cols: {
+          type: "integer",
+          description: "For 'resize' (required): the terminal width in columns, clamped to 80\u20139999. The " + "answer {run_id, path, slot, cols, rows, changed, seq} reports the size set."
+        },
+        rows: {
+          type: "integer",
+          description: "For 'resize' (required): the terminal height in rows, clamped to 24\u20139999 and to " + "at most 4 000 000 cells (cols \xD7 rows)."
+        },
         models: {
           type: "array",
           items: { type: "string" },
@@ -71886,7 +73084,7 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
     heartbeat: true,
     handler: async (args, ctx) => {
       const mode = args.mode;
-      if (mode === "list" || mode === "status" || mode === "cancel" || mode === "capture") {
+      if (mode === "list" || mode === "status" || mode === "cancel" || mode === "capture" || mode === "resize") {
         return teamContractVerb(mode, args);
       }
       try {
@@ -71918,7 +73116,7 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
         const promptText = () => {
           if (input !== undefined)
             return input;
-          const existing = join52(resolved, "input.md");
+          const existing = join53(resolved, "input.md");
           return existsSync33(existing) ? readFileSync33(existing, "utf-8") : undefined;
         };
         switch (mode) {
@@ -72077,16 +73275,16 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
         const sp = session_path;
         for (const file of ["status.json", "manifest.json", "input.md"]) {
           try {
-            sessionData[file] = readFileSync33(join52(sp, file), "utf-8");
+            sessionData[file] = readFileSync33(join53(sp, file), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join52(sp, "errors");
+          const errorDir = join53(sp, "errors");
           if (existsSync33(errorDir)) {
             for (const f of readdirSync10(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync33(join52(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync33(join53(errorDir, f), "utf-8");
                 } catch {}
               }
             }
@@ -72096,7 +73294,7 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
           for (const f of readdirSync10(sp)) {
             if (f.startsWith("response-") && f.endsWith(".md")) {
               try {
-                const content = readFileSync33(join52(sp, f), "utf-8");
+                const content = readFileSync33(join53(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -72105,7 +73303,7 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
       }
       let version = "unknown";
       try {
-        const pkgPath = join52(__dirname3, "../package.json");
+        const pkgPath = join53(__dirname3, "../package.json");
         if (existsSync33(pkgPath)) {
           version = JSON.parse(readFileSync33(pkgPath, "utf-8")).version;
         }
@@ -72185,7 +73383,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
   });
   tools.push({
     name: "create_session",
-    description: "Create a new claudish proxy session for an external model: an interactive Claude Code running " + "it in its own headless magmux pane. Returns at once with state STARTING; nothing is " + "pushed while it runs: poll list_sessions (about once every 10 s) for its state, then " + "call get_output once it is COMPLETED. With a prompt it is one-shot (it ends when that turn " + "settles); without one it is interactive and waits for send_input. Needs magmux >= 0.14.0 " + "(darwin and linux).",
+    description: "Create a new claudish proxy session for an external model: an interactive Claude Code running " + "it in its own headless magmux pane. Returns at once with state STARTING; nothing is " + "pushed while it runs: poll list_sessions (about once every 10 s) for its state, then " + "call get_output once it is COMPLETED. With a prompt it is one-shot (it ends when that turn " + `settles); without one it is interactive and waits for send_input. Needs magmux >= ${MIN_MAGMUX_VERSION} ` + "(darwin and linux).",
     inputSchema: {
       type: "object",
       properties: {
@@ -72229,7 +73427,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
         const requestedModel = args.model;
         const workDir = args.work_dir;
         const plan = await prehydrateCredentialsForSpawn([requestedModel], {
-          pin: workDir === undefined || resolve6(workDir) === process.cwd()
+          pin: workDir === undefined || resolve7(workDir) === process.cwd()
         });
         const parentClaudeSessionId = await parentSessionForCall({
           hostPid: sessionManager.hostPid
@@ -72411,7 +73609,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
   });
   tools.push({
     name: "capture_session",
-    description: "Read a session's current terminal screen (160\xD750): {seq, cols, rows, cursor, lines, final, " + "spans?}. A memory read, meant for polling about once per second. Pass the last `seq` as " + "since_seq to get {unchanged:true, seq, final} while nothing changed. `final:true` is the " + "last screen of a closed pane. Errors are a JSON ContractError.",
+    description: "Read a session's current terminal screen: {seq, cols, rows, cursor, lines, final, " + "spans?}. A memory read, meant for polling about once per second. Pass the last `seq` as " + "since_seq to get {unchanged:true, seq, final} while nothing changed. `final:true` is the " + "last screen of a closed pane. Errors are a JSON ContractError.",
     inputSchema: {
       type: "object",
       properties: {
@@ -72441,6 +73639,35 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
       }
     }
   });
+  tools.push({
+    name: "resize_session",
+    description: "Set a session's terminal size: the child gets a real SIGWINCH and Claude Code reflows. " + "Allowed at any time, mid-turn included; the last call wins. The size is clamped to " + "cols 80\u20139999, rows 24\u20139999 and at most 4 000 000 cells (magmux's limits); the answer " + "{session_id, cols, rows, changed, seq, pending?} reports the size set. `seq` is the screen's seq after the resize: the next capture_session " + "shows the new cols/rows. `changed:false` = already that size. `pending:true` = the pane " + "is starting or its socket is reconnecting; the size is applied then. A finished session " + "answers its last size with changed:false. Errors are a JSON ContractError " + "(`resize_unsupported` when the installed magmux has no resize op).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: { type: "string", description: "Session ID from create_session" },
+        cols: { type: "integer", description: "Terminal width in columns (clamped to 80\u20139999)" },
+        rows: {
+          type: "integer",
+          description: "Terminal height in rows (clamped to 24\u20139999 and 4 000 000 cells)"
+        }
+      },
+      required: ["session_id", "cols", "rows"]
+    },
+    group: "session",
+    handler: async (args) => {
+      try {
+        const sessionId = optionalString(args.session_id, "session_id");
+        if (sessionId === undefined)
+          throw new ContractErrorException("invalid_args", "'session_id' is required");
+        const cols = requiredInteger(args.cols, "cols");
+        const rows = requiredInteger(args.rows, "rows");
+        return contractAnswer(await sessionManager.resizeSession(sessionId, cols, rows));
+      } catch (e) {
+        return contractErrorAnswer(e);
+      }
+    }
+  });
   return tools;
 }
 function resolveToolGroups(mode) {
@@ -72566,7 +73793,7 @@ Each session is an interactive Claude Code running the model in its own headless
 3. send_input may be called at any time; it is queued until the session is idle.
 4. COMPLETED: call get_output for the answer.
 5. FAILED or TIMEOUT \u2014 or COMPLETED with an empty or surprising answer \u2014 call get_diagnostics. It returns the child's final screen, the upstream error bodies, the recent state records, the resolved model chain and the paths to the full records. It needs no re-run and no debug flag.
-6. capture_session reads a session's current screen; cancel_session stops it. Nothing stops a session for being idle: a child inside a long build is silent and working.
+6. capture_session reads a session's current screen; resize_session sets its terminal size (any time, mid-turn included); cancel_session stops it. Nothing stops a session for being idle: a child inside a long build is silent and working.
 
 The session_id from create_session is the key for every session tool.`, proxyInstance = null, proxyStarting = null, SCORE_TIE_EPSILON = 0.000001, NEXT_STEP, sanitize2, TOOL_MODES;
 var init_mcp_server = __esm(() => {
@@ -72599,9 +73826,9 @@ var init_mcp_server = __esm(() => {
   import_dotenv2 = __toESM(require_main(), 1);
   import_dotenv2.config({ quiet: true });
   __filename3 = fileURLToPath3(import.meta.url);
-  __dirname3 = dirname14(__filename3);
-  CLAUDISH_CACHE_DIR = join52(homedir35(), ".claudish");
-  OPENROUTER_MODELS_CACHE_PATH = join52(CLAUDISH_CACHE_DIR, "openrouter-models.json");
+  __dirname3 = dirname15(__filename3);
+  CLAUDISH_CACHE_DIR = join53(homedir35(), ".claudish");
+  OPENROUTER_MODELS_CACHE_PATH = join53(CLAUDISH_CACHE_DIR, "openrouter-models.json");
   NEXT_STEP = {
     cancelled: "you stopped this slot; nothing is wrong with it. Re-run it if you still want its vote",
     timeout: "grid mode only \u2014 magmux ended the pane. The orchestrator has no deadline",
@@ -72612,7 +73839,7 @@ var init_mcp_server = __esm(() => {
     prompt_not_accepted: "the REPL never took the prompt \u2014 read the evidence screen; retry",
     prompt_not_read: "the child never read all of its task file \u2014 check that its agent or tool flags allow " + "Read and that the model can call tools; `what` says which lines were read",
     child_exited: "read the evidence screen, then retry or drop the model",
-    pane_lost: "magmux died \u2014 check `magmux --version` \u2265 0.14.0 and retry",
+    pane_lost: `magmux died \u2014 check \`magmux --version\` \u2265 ${MIN_MAGMUX_VERSION} and retry`,
     blocked: "the child asked a question team cannot answer \u2014 make the prompt self-contained or use " + "create_session",
     api_error: "retry once, or route via a different provider (or@<model>)",
     refused: "the model refused \u2014 rephrase or drop the model",
@@ -72928,7 +74155,7 @@ var init_behavior_command = __esm(() => {
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync36, readFileSync as readFileSync36, writeFileSync as writeFileSync27 } from "fs";
 import { connect as netConnect2 } from "net";
-import { join as join53 } from "path";
+import { join as join54 } from "path";
 import { setTimeout as wait } from "timers/promises";
 function paneRouteLine(explanation) {
   const origin = describeRouteExplanation(explanation);
@@ -73078,9 +74305,9 @@ async function runWithGrid(sessionPath, models, input, opts) {
   const keep = opts?.keep ?? false;
   const manifest = setupSession(sessionPath, models, input);
   const startedAt = new Date().toISOString();
-  const gridfilePath = join53(sessionPath, "gridfile.txt");
-  const prompt = readFileSync36(join53(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync36(join53(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join54(sessionPath, "gridfile.txt");
+  const prompt = readFileSync36(join54(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync36(join54(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const routeLines = mode === "interactive" ? new Map : await resolvePaneRouteLines(Object.values(manifest.models).map((entry) => entry.model));
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
@@ -73112,7 +74339,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
   });
   const [{ results }] = await Promise.all([subscription, procExit]);
   const status = buildTeamStatus(manifest, startedAt, results?.panes ?? null);
-  const statusPath = join53(sessionPath, "status.json");
+  const statusPath = join54(sessionPath, "status.json");
   writeFileSync27(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
@@ -73133,7 +74360,7 @@ var init_team_grid = __esm(() => {
 
 // src/team-cli.ts
 import { readFileSync as readFileSync37 } from "fs";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 async function runPaneTeam(sessionPath, models, input, opts) {
   installPaneShutdownHooks({ exitAfter: true });
   try {
@@ -73185,7 +74412,7 @@ Options (run / run-and-judge):
   --timeout <secs>    Grid modes only: magmux's own per-pane timeout (default: 300).
                       json mode has no deadline \u2014 nothing kills a working model.
                       json mode runs each model as an interactive pane in a headless
-                      magmux (>= 0.14.0; darwin and linux).
+                      magmux (>= ${MIN_MAGMUX_VERSION}; darwin and linux).
   --grid              Show all models in a magmux grid with live output + status bar
   --mode <m>          run only: json (default, panes), default (the grid, as --grid)
                       or interactive (as --interactive)
@@ -73278,7 +74505,7 @@ async function teamCommand(args) {
     }
     case "judge": {
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync37(join54(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync37(join55(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "run-and-judge": {
@@ -73294,7 +74521,7 @@ async function teamCommand(args) {
       });
       printStatus(status);
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync37(join54(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync37(join55(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "status": {
@@ -73883,7 +75110,7 @@ var init_keychain_command = __esm(() => {
 import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync37, unlinkSync as unlinkSync9 } from "fs";
 import { homedir as homedir36 } from "os";
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 async function defaultSuggestModel() {
   try {
     const tok = readSharedAntigravityToken();
@@ -74004,7 +75231,7 @@ No session detected yet. Starting the Antigravity CLI interactively \u2014
   async logout(deps) {
     deleteSharedAntigravityToken(deps);
     try {
-      const tokenFile = join55(homedir36(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+      const tokenFile = join56(homedir36(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
       if (existsSync37(tokenFile))
         unlinkSync9(tokenFile);
     } catch {}
@@ -82490,7 +83717,7 @@ import {
   writeFileSync as writeFileSync28
 } from "fs";
 import { homedir as homedir37, tmpdir as tmpdir3 } from "os";
-import { dirname as dirname15, join as join56 } from "path";
+import { dirname as dirname16, join as join57 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -82555,7 +83782,7 @@ function hasResolvableAnthropicAuth(deps = {}) {
   if (isRealAnthropicEnvCredential(env, "ANTHROPIC_API_KEY") || isRealAnthropicEnvCredential(env, "ANTHROPIC_AUTH_TOKEN")) {
     return true;
   }
-  if (fileExists(join56(homedir37(), ".claude", ".credentials.json")))
+  if (fileExists(join57(homedir37(), ".claude", ".credentials.json")))
     return true;
   return keychainProbe();
 }
@@ -82570,7 +83797,7 @@ function isProxyAuthMode(config) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join56(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join57(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
@@ -82591,9 +83818,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir3();
-  const claudishDir = join56(homeDir, ".claudish");
+  const claudishDir = join57(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join56(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join57(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const light = getThemeMode() === "light";
   const cyanCode = light ? "38;2;14;116;144" : "96";
@@ -82731,7 +83958,7 @@ process.stdin.on('end', () => {
 }
 function initializeTokenFile(tokenFilePath) {
   try {
-    mkdirSync25(dirname15(tokenFilePath), { recursive: true });
+    mkdirSync25(dirname16(tokenFilePath), { recursive: true });
     writeFileSync28(tokenFilePath, JSON.stringify({
       input_tokens: 0,
       output_tokens: 0,
@@ -82763,7 +83990,7 @@ function cleanupStaleTokenFiles(dir, now = Date.now(), maxAgeMs = STALE_TOKEN_FI
     if (!name.startsWith("tokens-") || !name.endsWith(".json"))
       continue;
     scanned++;
-    const full = join56(dir, name);
+    const full = join57(dir, name);
     try {
       if (statSync14(full).mtimeMs >= cutoff)
         continue;
@@ -82792,9 +84019,9 @@ function parseSettingsArgSafe(value) {
 }
 function userSettingsFileCandidates(cwd) {
   return [
-    join56(homedir37(), ".claude", "settings.json"),
-    join56(cwd, ".claude", "settings.json"),
-    join56(cwd, ".claude", "settings.local.json")
+    join57(homedir37(), ".claude", "settings.json"),
+    join57(cwd, ".claude", "settings.json"),
+    join57(cwd, ".claude", "settings.local.json")
   ];
 }
 function discoverUserStatusLineCommand(claudeArgs = [], cwd = process.cwd()) {
@@ -82835,12 +84062,12 @@ function buildChainedStatusCommand(userCommand, claudishBody, claudishSegment) {
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLineCommand) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir3();
-  const claudishDir = join56(homeDir, ".claudish");
+  const claudishDir = join57(homeDir, ".claudish");
   try {
     mkdirSync25(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join56(claudishDir, `settings-${timestamp}.json`);
+  const tempPath = join57(claudishDir, `settings-${timestamp}.json`);
   const assignedFile = assignedTokenFile(process.env) !== null;
   const tokenFilePath = resolveTokenFilePath(port);
   cleanupStaleTokenFiles(claudishDir);
@@ -83219,7 +84446,7 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
     const home = homedir37();
-    const localPath = isWindows2() ? join56(home, ".claude", "local", "claude.exe") : join56(home, ".claude", "local", "claude");
+    const localPath = isWindows2() ? join57(home, ".claude", "local", "claude.exe") : join57(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -83332,15 +84559,15 @@ async function findClaudeBinary() {
     }
   }
   const home = homedir37();
-  const localPath = isWindows ? join56(home, ".claude", "local", "claude.exe") : join56(home, ".claude", "local", "claude");
+  const localPath = isWindows ? join57(home, ".claude", "local", "claude.exe") : join57(home, ".claude", "local", "claude");
   if (existsSync39(localPath)) {
     return localPath;
   }
   if (isWindows) {
     const windowsPaths = [
-      join56(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join56(home, ".npm-global", "claude.cmd"),
-      join56(home, "node_modules", ".bin", "claude.cmd")
+      join57(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join57(home, ".npm-global", "claude.cmd"),
+      join57(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path of windowsPaths) {
       if (existsSync39(path)) {
@@ -83351,11 +84578,11 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join56(home, ".npm-global/bin/claude"),
-      join56(home, ".local/bin/claude"),
-      join56(home, "node_modules/.bin/claude"),
+      join57(home, ".npm-global/bin/claude"),
+      join57(home, ".local/bin/claude"),
+      join57(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join56(home, "../usr/bin/claude")
+      join57(home, "../usr/bin/claude")
     ];
     for (const path of commonPaths) {
       if (existsSync39(path)) {
@@ -83440,16 +84667,16 @@ var init_claude_runner = __esm(() => {
 // src/diag-output.ts
 import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync26, unlinkSync as unlinkSync11, writeFileSync as writeFileSync29 } from "fs";
 import { homedir as homedir38 } from "os";
-import { join as join57 } from "path";
+import { join as join58 } from "path";
 function getClaudishDir() {
-  const dir = join57(homedir38(), ".claudish");
+  const dir = join58(homedir38(), ".claudish");
   try {
     mkdirSync26(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join57(getClaudishDir(), `diag-${process.pid}.log`);
+  return join58(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -86064,7 +87291,7 @@ init_startup_trace();
 init_picker_cancelled();
 var import_dotenv3 = __toESM(require_main(), 1);
 import { existsSync as existsSync40, readFileSync as readFileSync40 } from "fs";
-import { join as join58, resolve as resolve7 } from "path";
+import { join as join59, resolve as resolve8 } from "path";
 
 // src/tui/runtime/should-open-picker.ts
 function noModelConfigured(gate) {
@@ -86176,7 +87403,7 @@ async function applyOpImport() {
 async function applyConfigOverride() {
   await Promise.resolve();
   const plan = planConfigOverride(process.argv.slice(2), process.env, {
-    resolve: resolve7,
+    resolve: resolve8,
     exists: existsSync40
   });
   if (plan.kind === "none")
@@ -86380,7 +87607,7 @@ async function runCli() {
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join58(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join59(process.cwd(), `.claudish-team-${Date.now()}`);
       if (mode === "json") {
         await Promise.resolve().then(() => init_pane());
         await Promise.resolve().then(() => init_team_orchestrator());
@@ -86400,7 +87627,7 @@ async function runCli() {
         const status = await runModels(sessionPath);
         const result = { ...status, responses: {} };
         for (const anonId of Object.keys(status.models)) {
-          const responsePath = join58(sessionPath, `response-${anonId}.md`);
+          const responsePath = join59(sessionPath, `response-${anonId}.md`);
           try {
             const raw = readFileSync40(responsePath, "utf-8").trim();
             try {