@h-rig/cli 0.0.6-alpha.83 → 0.0.6-alpha.84

package/dist/src/app-opentui/react/ChromeHost.js

@@ -0,0 +1,2942 @@
+// @bun
+// packages/cli/src/app-opentui/react/ChromeHost.tsx
+import { useEffect, useRef } from "react";
+import { useRenderer, useTerminalDimensions } from "@opentui/react";
+import { TextRenderable as TextRenderable5 } from "@opentui/core";
+
+// packages/cli/src/app-opentui/layout.ts
+var MIN_TERMINAL_WIDTH = 48;
+var MIN_TERMINAL_HEIGHT = 16;
+function computeStageLayout(width, height) {
+  const rawWidth = Math.trunc(width || 80);
+  const rawHeight = Math.trunc(height || 24);
+  const tooSmall = rawWidth < MIN_TERMINAL_WIDTH || rawHeight < MIN_TERMINAL_HEIGHT;
+  const safeWidth = Math.max(40, rawWidth);
+  const safeHeight = Math.max(18, rawHeight);
+  const compact = safeWidth < 92 || safeHeight < 30;
+  const horizontalGutter = compact ? 1 : 2;
+  const centerWidth = Math.max(36, safeWidth - horizontalGutter * 2);
+  const centerLeft = horizontalGutter;
+  const footerTop = Math.max(0, safeHeight - 1);
+  const typeBarTop = Math.max(0, footerTop - 1);
+  const centerTop = compact ? 1 : Math.max(1, Math.floor(safeHeight * 0.055));
+  const centerHeight = Math.max(6, typeBarTop - centerTop);
+  return { width: safeWidth, height: safeHeight, centerWidth, centerLeft, centerTop, centerHeight, typeBarTop, footerTop, compact, tooSmall };
+}
+function visibleWidth(text) {
+  return [...text].length;
+}
+
+// packages/cli/src/app-opentui/render/type-bar.ts
+import { BoxRenderable, InputRenderable, InputRenderableEvents, RGBA, StyledText, TextRenderable } from "@opentui/core";
+
+// packages/cli/src/app-opentui/theme.ts
+import {
+  bold as otuiBold,
+  dim as otuiDim,
+  fg as otuiFg,
+  t,
+  TextAttributes
+} from "@opentui/core";
+var RIG_UI = {
+  bg: "#070809",
+  bg2: "#0b0c0e",
+  panel: "#101115",
+  panel2: "#14161b",
+  glass: "#1e2230",
+  border: "#2a2e3a",
+  ink: "#f4f5f8",
+  ink2: "#c7c9d3",
+  ink3: "#9aa0ae",
+  ink4: "#787b86",
+  lime: "#ccff4d",
+  limeDim: "#a9d63f",
+  cyan: "#56d8ff",
+  cyanDim: "#3f9fbd",
+  red: "#ff5d5d",
+  yellow: "#ffd24d",
+  magenta: "#ff79b0"
+};
+var styles = {
+  ink: otuiFg(RIG_UI.ink),
+  ink2: otuiFg(RIG_UI.ink2),
+  ink3: otuiFg(RIG_UI.ink3),
+  ink4: otuiFg(RIG_UI.ink4),
+  lime: otuiFg(RIG_UI.lime),
+  limeDim: otuiFg(RIG_UI.limeDim),
+  cyan: otuiFg(RIG_UI.cyan),
+  red: otuiFg(RIG_UI.red),
+  yellow: otuiFg(RIG_UI.yellow),
+  magenta: otuiFg(RIG_UI.magenta)
+};
+
+// packages/cli/src/app-opentui/render/type-bar.ts
+var TYPEBAR_BG = RGBA.fromInts(20, 25, 14, 224);
+var TYPEBAR_BORDER = RGBA.fromInts(204, 255, 77, 92);
+function createTypeBar(renderer) {
+  const background = new BoxRenderable(renderer, {
+    id: "typebar-card",
+    position: "absolute",
+    left: 0,
+    top: 0,
+    width: 1,
+    height: 1,
+    backgroundColor: TYPEBAR_BG,
+    border: true,
+    borderColor: TYPEBAR_BORDER,
+    zIndex: 4
+  });
+  const prefix = new TextRenderable(renderer, {
+    id: "typebar-prefix",
+    content: " \u203A",
+    position: "absolute",
+    left: 1,
+    top: 0,
+    fg: RIG_UI.lime,
+    zIndex: 7,
+    selectable: true
+  });
+  const input = new InputRenderable(renderer, {
+    id: "typebar-input",
+    position: "absolute",
+    left: 4,
+    top: 0,
+    width: 40,
+    placeholder: "runs \xB7 tasks \xB7 run next \xB7 help",
+    textColor: RIG_UI.ink,
+    cursorColor: RIG_UI.lime,
+    cursorStyle: { style: "block", blinking: false },
+    showCursor: true,
+    zIndex: 7,
+    selectable: true
+  });
+  const footer = new TextRenderable(renderer, {
+    id: "footer",
+    content: "",
+    position: "absolute",
+    left: 0,
+    top: 1,
+    width: "100%",
+    fg: RIG_UI.ink3,
+    zIndex: 7,
+    selectable: true
+  });
+  return { background, input, prefix, footer };
+}
+function modePrefix(mode) {
+  switch (mode) {
+    case "search":
+      return { glyph: " /", color: RIG_UI.cyan };
+    case "command":
+      return { glyph: " /", color: RIG_UI.lime };
+    case "prompt":
+      return { glyph: " ?", color: RIG_UI.yellow };
+    default:
+      return { glyph: " \u203A", color: RIG_UI.ink3 };
+  }
+}
+function positionTypeBar(renderables, input, footer, width, typeBarTop, footerTop) {
+  const mode = input.mode ?? "nav";
+  const editing = mode !== "nav";
+  const { glyph, color } = modePrefix(mode);
+  renderables.background.visible = true;
+  const cardTop = Math.max(0, typeBarTop - 1);
+  renderables.background.left = 0;
+  renderables.background.top = cardTop;
+  renderables.background.width = width;
+  renderables.background.height = Math.max(3, footerTop - cardTop + 1);
+  renderables.prefix.content = glyph;
+  renderables.prefix.fg = color;
+  renderables.prefix.left = 2;
+  renderables.prefix.top = typeBarTop;
+  renderables.input.top = typeBarTop;
+  renderables.input.left = 5;
+  renderables.input.width = Math.max(10, width - 8);
+  renderables.input.value = editing ? input.value : "";
+  renderables.input.placeholder = editing ? mode === "prompt" ? input.prompt?.label ?? "type a value" : mode === "command" ? "rig \u2026" : "filter\u2026" : input.placeholder;
+  renderables.input.showCursor = editing;
+  if (renderables.input.focused)
+    renderables.input.blur();
+  renderables.footer.top = footerTop;
+  renderables.footer.width = "100%";
+  renderables.footer.content = formatFooter(footer, width);
+}
+function hideTypeBar(renderables, height) {
+  renderables.background.visible = false;
+  renderables.background.top = height + 1;
+  renderables.prefix.content = "";
+  renderables.prefix.top = height + 1;
+  renderables.input.value = "";
+  renderables.input.placeholder = "";
+  renderables.input.top = height + 1;
+  renderables.input.left = 0;
+  renderables.input.width = 1;
+  renderables.input.blur();
+  renderables.footer.content = "";
+  renderables.footer.top = height + 1;
+}
+function safeFooterMessage(message) {
+  const trimmed = message?.trim();
+  if (!trimmed)
+    return null;
+  if (/https?:|\b[a-z0-9-]+\.[a-z]{2,}\b|\brig\b/i.test(trimmed))
+    return null;
+  return trimmed;
+}
+function liveCell(live) {
+  const connected = live.trimStart().startsWith("\u25CF");
+  return { text: live, style: connected ? styles.cyan : styles.ink3 };
+}
+function footerCells(footer) {
+  const safeMessage = safeFooterMessage(footer.message);
+  const cells = [
+    footer.section ? { text: `\u25B8 ${footer.section}`, style: (s) => otuiBold(styles.ink2(s)) } : null,
+    footer.live ? liveCell(footer.live) : null,
+    footer.project ? { text: "workspace", style: styles.ink3 } : null,
+    footer.server ? { text: "server selected", style: styles.ink3 } : null,
+    footer.auth ? { text: "auth ready", style: styles.ink3 } : null,
+    footer.run ? { text: `run ${footer.run}`, style: styles.ink3 } : null,
+    safeMessage ? { text: safeMessage, style: styles.ink2 } : null,
+    footer.updated ? { text: footer.updated, style: styles.ink3 } : null
+  ];
+  return cells.filter((cell) => cell !== null);
+}
+var FOOTER_SEPARATOR = "  \xB7  ";
+function formatFooter(footer, width) {
+  const budget = Math.max(8, width - 2);
+  const chunks = [styles.ink3(" ")];
+  let used = 1;
+  footerCells(footer).forEach((cell, index) => {
+    const sep = index === 0 ? "" : FOOTER_SEPARATOR;
+    const remaining = budget - used - visibleWidth(sep);
+    if (remaining <= 0)
+      return;
+    if (sep) {
+      chunks.push(styles.ink4(sep));
+      used += visibleWidth(sep);
+    }
+    const fits = visibleWidth(cell.text) <= remaining;
+    const text = fits ? cell.text : remaining <= 1 ? "\u2026" : `${[...cell.text].slice(0, Math.max(0, remaining - 1)).join("")}\u2026`;
+    chunks.push(cell.style(text));
+    used += visibleWidth(text);
+  });
+  return new StyledText(chunks);
+}
+
+// packages/cli/src/app-opentui/runtime.ts
+import { BoxRenderable as BoxRenderable3, RGBA as RGBA8, StyledText as StyledText4, TextRenderable as TextRenderable4, createCliRenderer } from "@opentui/core";
+
+// packages/cli/src/app-opentui/command-pty-host.ts
+import { basename } from "path";
+import { fileURLToPath } from "url";
+import { Terminal as XtermTerminal } from "@xterm/headless";
+var MIN_COLS = 40;
+var MIN_ROWS = 10;
+var MAX_ROWS = 300;
+var MAX_SNAPSHOT_LINES = 420;
+var SNAPSHOT_DELAY_MS = 80;
+var fallbackCliScriptPath = fileURLToPath(new URL("../../bin/rig.ts", import.meta.url));
+var activeHost = null;
+function clampCols(cols) {
+  return Math.max(MIN_COLS, Math.trunc(cols || 120));
+}
+function clampRows(rows) {
+  return Math.max(MIN_ROWS, Math.min(MAX_ROWS, Math.trunc(rows || 36)));
+}
+function childCommandPrefix() {
+  const execName = basename(process.execPath).toLowerCase();
+  const currentEntry = process.argv[1];
+  if (execName === "bun" || execName === "bun.exe") {
+    return currentEntry ? [process.execPath, currentEntry] : [process.execPath, fallbackCliScriptPath];
+  }
+  return [process.execPath];
+}
+function withEnv(base) {
+  const env = {};
+  for (const [key, value] of Object.entries(base ?? process.env)) {
+    if (key === "NO_COLOR")
+      continue;
+    if (typeof value === "string")
+      env[key] = value;
+  }
+  return {
+    ...env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+    FORCE_COLOR: env.FORCE_COLOR ?? "1",
+    RIG_PLAIN: "1",
+    RIG_OPENTUI_COMMAND_HOST: "1",
+    RIG_CLI_PLAIN_HELP: env.RIG_CLI_PLAIN_HELP ?? "1"
+  };
+}
+function commandLabel(argv, fallback) {
+  const command = argv.join(" ").trim();
+  return fallback?.trim() || (command ? `rig ${command}` : "rig");
+}
+class CommandPtyHost {
+  argv;
+  projectRoot;
+  label;
+  env;
+  onSnapshot;
+  onExit;
+  onError;
+  terminal;
+  decoder = new TextDecoder("utf-8");
+  proc = null;
+  pty = null;
+  status = "starting";
+  cols;
+  rows;
+  message = "starting command";
+  exitCode;
+  signal;
+  notifyTimer = null;
+  _disposed = false;
+  constructor(options) {
+    this.argv = [...options.argv];
+    this.projectRoot = options.projectRoot;
+    this.label = commandLabel(options.argv, options.label);
+    this.env = options.env;
+    this.cols = clampCols(options.cols);
+    this.rows = clampRows(options.rows);
+    this.onSnapshot = options.onSnapshot;
+    this.onExit = options.onExit;
+    this.onError = options.onError;
+    this.terminal = new XtermTerminal({ allowProposedApi: true, cols: this.cols, rows: this.rows, scrollback: 2000 });
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  get snapshot() {
+    return this.createSnapshot();
+  }
+  async start() {
+    if (this._disposed)
+      throw new Error("Command PTY host is disposed.");
+    if (typeof Bun.Terminal !== "function") {
+      throw new Error("Bun native PTY is unavailable in this runtime. Command host requires Bun.Terminal.");
+    }
+    const spawnOptions = {
+      cwd: this.projectRoot,
+      env: withEnv(this.env),
+      terminal: {
+        cols: this.cols,
+        rows: this.rows,
+        name: "xterm-256color",
+        data: (_terminal, data) => this.handlePtyData(data)
+      }
+    };
+    const proc = Bun.spawn([...childCommandPrefix(), ...this.argv], spawnOptions);
+    if (!proc.terminal)
+      throw new Error("Bun did not attach a terminal to the command child process.");
+    this.proc = proc;
+    this.pty = proc.terminal;
+    this.status = "running";
+    this.message = "running";
+    this.emitSnapshotSoon(0);
+    proc.exited.then((exitCode) => {
+      if (this._disposed)
+        return;
+      this.status = exitCode === 0 ? "exited" : "failed";
+      this.exitCode = exitCode;
+      this.signal = null;
+      this.message = exitCode === 0 ? "completed" : `exited with code ${exitCode}`;
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onExit?.(snapshot);
+      if (activeHost === this)
+        activeHost = null;
+      this.dispose("exit", { kill: false, notify: false });
+    }).catch((error) => {
+      if (this._disposed)
+        return;
+      this.status = "failed";
+      this.message = error instanceof Error ? error.message : String(error);
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onError?.(error, snapshot);
+      if (activeHost === this)
+        activeHost = null;
+      this.dispose("error", { kill: false, notify: false });
+    });
+  }
+  write(data) {
+    if (this._disposed || !this.pty)
+      return;
+    try {
+      this.pty.write(data);
+    } catch (error) {
+      this.status = "failed";
+      this.message = error instanceof Error ? error.message : String(error);
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onError?.(error, snapshot);
+    }
+  }
+  resize(cols, rows) {
+    const nextCols = clampCols(cols);
+    const nextRows = clampRows(rows);
+    if (nextCols === this.cols && nextRows === this.rows)
+      return;
+    this.cols = nextCols;
+    this.rows = nextRows;
+    this.terminal.resize(nextCols, nextRows);
+    try {
+      this.pty?.resize(nextCols, nextRows);
+    } catch {}
+    this.emitSnapshotSoon(0);
+  }
+  dispose(reason = "dispose", options = {}) {
+    if (this._disposed)
+      return;
+    this._disposed = true;
+    if (this.notifyTimer)
+      clearTimeout(this.notifyTimer);
+    this.notifyTimer = null;
+    if (options.kill !== false) {
+      try {
+        this.proc?.kill("SIGTERM");
+      } catch {}
+    }
+    try {
+      this.pty?.close();
+    } catch {}
+    try {
+      this.terminal.dispose();
+    } catch {}
+    if (activeHost === this)
+      activeHost = null;
+    if (options.notify) {
+      this.message = reason;
+      this.onSnapshot?.(this.createSnapshot(reason));
+    }
+  }
+  handlePtyData(data) {
+    if (this._disposed)
+      return;
+    this.decoder.decode(data, { stream: true });
+    this.terminal.write(data, () => this.emitSnapshotSoon());
+  }
+  emitSnapshotSoon(delayMs = SNAPSHOT_DELAY_MS) {
+    if (this._disposed || this.notifyTimer)
+      return;
+    this.notifyTimer = setTimeout(() => {
+      this.notifyTimer = null;
+      if (this._disposed)
+        return;
+      this.onSnapshot?.(this.createSnapshot());
+    }, delayMs);
+  }
+  createSnapshot(message = this.message) {
+    const buffer = this.terminal.buffer.active;
+    const end = buffer.length;
+    const start = Math.max(0, end - MAX_SNAPSHOT_LINES);
+    const lines = [];
+    for (let row = start;row < end; row += 1) {
+      const line = buffer.getLine(row);
+      lines.push((line?.translateToString(false) ?? "").slice(0, this.cols));
+    }
+    while (lines.length < this.rows)
+      lines.push("");
+    return {
+      command: this.argv,
+      label: this.label,
+      status: this.status,
+      cols: this.cols,
+      rows: this.rows,
+      lines,
+      message,
+      ...this.exitCode !== undefined ? { exitCode: this.exitCode } : {},
+      ...this.signal !== undefined ? { signal: this.signal } : {}
+    };
+  }
+}
+
+// packages/cli/src/commands/_help-catalog.ts
+import pc from "picocolors";
+var PRIMARY_GROUPS = [
+  {
+    name: "server",
+    summary: "Choose, inspect, and start the Rig server that owns tasks and runs.",
+    usage: ["rig server <status|list|add|use|start> [options]"],
+    commands: [
+      { command: "status", description: "Show the selected server for this repo.", primary: true },
+      { command: "use local", description: "Switch this repo to the local Rig server.", primary: true },
+      { command: "add <alias> <url>", description: "Save a remote Rig server URL.", primary: true },
+      { command: "use <alias>", description: "Select a saved remote server alias.", primary: true },
+      { command: "list", description: "List saved local/remote server aliases.", primary: true },
+      { command: "start [--host <host>] [--port <n>]", description: "Start a local rig-server process." }
+    ],
+    examples: [
+      "rig server status",
+      "rig server add prod https://where.rig-does.work",
+      "rig server use prod",
+      "rig server use local",
+      "rig server start --port 3773"
+    ],
+    next: ["Use `rig task list` to see server-owned work.", "Use `rig run list` or `rig run attach <id> --follow` to monitor runs."]
+  },
+  {
+    name: "task",
+    summary: "Find work, start Pi-backed runs, and validate task results.",
+    usage: ["rig task <list|next|show|run> [options]"],
+    commands: [
+      { command: "list [--assignee <login|me|@me>] [--state open|closed]", description: "List tasks from the selected server/source.", primary: true },
+      { command: "next [filters]", description: "Render the next matching task as a selected-task card.", primary: true },
+      { command: "show <id>|--task <id> [--raw]", description: "Show a human task summary; --raw prints the full payload.", primary: true },
+      { command: "run [#<issue>|<task-id>|--next|--task <id>]", description: "Submit a task run; interactive follows with bundled Pi.", primary: true },
+      { command: "ready", description: "List task IDs that are runnable now." },
+      { command: "validate|verify [--task <id>]", description: "Run configured task checks/review gates." },
+      { command: "details --task <id>", description: "Show full task info from the configured source." },
+      { command: "reopen [--task <id> | --all] [--reason <text>]", description: "Reopen closed task(s) in the configured source." },
+      { command: "artifacts|artifact-dir|artifact-write", description: "Inspect or write task artifacts." },
+      { command: "report-bug", description: "Create a structured bug report/task." }
+    ],
+    examples: [
+      "rig task list --assignee @me --limit 20",
+      "rig task next",
+      "rig task show 123 --raw",
+      "rig task run --next",
+      "rig task run #123 --runtime-adapter pi",
+      "rig task run --title 'Investigate deploy drift' --initial-prompt 'Check server health'"
+    ],
+    next: ["Use `--detach` to submit without attaching.", "Use `rig run attach <run-id> --follow` to rejoin a live run."]
+  },
+  {
+    name: "run",
+    summary: "Observe, attach to, and control Rig runs. `attach` opens the Pi console \u2014 the full worker session, live.",
+    usage: ["rig run <list|status|show|attach|steer|stop|resume|restart> [options]"],
+    commands: [
+      { command: "list", description: "List recent runs from the selected server or local state.", primary: true },
+      { command: "status", description: "Render active and recent run groups.", primary: true },
+      { command: "show <id>|--run <id> [--raw]", description: "Show a human run summary; --raw prints the full payload.", primary: true },
+      { command: "attach <run-id>|--run <id>", description: "Open the run's Pi console \u2014 see 'Inside the console' below. Works on live AND finished runs.", primary: true },
+      { command: "steer <run-id> --message <text>", description: "Queue a steering message into a live worker without attaching \u2014 delivered into the agent's context within seconds.", primary: true },
+      { command: "stop [<run-id>|--run <id>]", description: "Request stop for one run or local active runs.", primary: true },
+      { command: "resume [<run-id>]", description: "Resume an interrupted run on the selected server (defaults to the most recent resumable)." },
+      { command: "restart [<run-id>]", description: "Re-dispatch a run from a clean runtime, reopening its Pi session where possible." },
+      { command: "timeline --run <id> [--follow]", description: "Stream raw run timeline events (scripts; humans should attach)." },
+      { command: "replay <run-id>|--run <id> [--with-session]", description: "Print the run's consolidated run.jsonl as a merged timeline; --with-session interleaves the Pi session log." },
+      { command: "delete|cleanup", description: "Remove completed run records/artifacts." }
+    ],
+    examples: [
+      "rig run attach <run-id>          # full session console \u2014 live mirror, steering, worker shell",
+      "rig run steer <run-id> --message 'focus on the failing test first'",
+      "rig run list",
+      "rig run show <run-id>",
+      "rig run stop <run-id>"
+    ],
+    next: [
+      "Inside the console: the run's COMPLETE transcript loads on open (finished runs too), and new worker turns stream in live.",
+      "Inside the console: plain text = steering into the worker's context \xB7 !<cmd> = shell in the WORKER workspace \xB7 /<cmd> includes the worker session's commands \xB7 /rig abort stops the current turn.",
+      "The console is read-write but remote-only: nothing runs on your machine; the worker keeps running when you exit.",
+      "Use `rig task run --next` to create a new run; interactive mode drops you straight into its console.",
+      "Use `--json` when scripts need the full structured record."
+    ]
+  },
+  {
+    name: "inbox",
+    summary: "Review approval and user-input requests that block worker runs.",
+    usage: ["rig inbox <approvals|approve|inputs|respond> [options]"],
+    commands: [
+      { command: "approvals [--run <id>] [--task <id>]", description: "List pending approvals.", primary: true },
+      { command: "inputs [--run <id>] [--task <id>]", description: "List pending user-input requests.", primary: true },
+      { command: "approve --run <id> --request <id> --decision approve|reject", description: "Resolve an approval request." },
+      { command: "respond --run <id> --request <id> --answer key=value", description: "Answer a user-input request." }
+    ],
+    examples: [
+      "rig inbox approvals",
+      "rig inbox inputs --run <run-id>",
+      "rig inbox approve --run <run-id> --request <request-id> --decision approve"
+    ],
+    next: ["Rejoin the run after resolving a block: `rig run attach <run-id> --follow`."]
+  },
+  {
+    name: "stats",
+    summary: "Fleet metrics computed from on-disk run journals (no server required).",
+    usage: ["rig stats [show] [--since <7d|30d|ISO date>]"],
+    commands: [
+      { command: "show [--since <window>]", description: "Total runs, completion/failure/needs-attention rates, median run time, steering, stalls, approvals.", primary: true }
+    ],
+    examples: [
+      "rig stats",
+      "rig stats --since 7d",
+      "rig stats --since 2026-06-01 --json"
+    ],
+    next: ["Inspect outliers with `rig run list` and `rig run show <run-id>`.", "Use `--json` for the schema'd envelope (see docs/cli-json.md)."]
+  },
+  {
+    name: "inspect",
+    summary: "Inspect logs, artifacts, graphs, failures for a task.",
+    usage: ["rig inspect <logs|artifacts|failures|graph|audit|diff> --task <id>"],
+    commands: [
+      { command: "logs --task <id>", description: "Latest run log for a task (local or selected server).", primary: true },
+      { command: "artifacts --task <id>", description: "List the task's completion artifacts.", primary: true },
+      { command: "failures --task <id>", description: "Recorded failures for a task.", primary: true },
+      { command: "diff --task <id>", description: "Changed files for a task.", primary: true },
+      { command: "graph", description: "Task dependency graph." },
+      { command: "audit", description: "Controlled-command audit trail." }
+    ],
+    examples: ["rig inspect logs --task <id>", "rig inspect diff --task <id>"],
+    next: ["Use `rig stats` for fleet-level metrics across runs."]
+  },
+  {
+    name: "repo",
+    summary: "Repository sync/baseline helpers for the Rig-managed checkout.",
+    usage: ["rig repo <sync|reset-baseline>"],
+    commands: [
+      { command: "sync", description: "Sync project repository state.", primary: true },
+      { command: "reset-baseline", description: "Reset the managed baseline for the repo." }
+    ],
+    examples: ["rig repo sync"]
+  },
+  {
+    name: "plugin",
+    summary: "Plugin listing, validation, and plugin-contributed commands.",
+    usage: ["rig plugin <list|validate|run> [options]"],
+    commands: [
+      { command: "list", description: "List plugins declared in rig.config.ts and their contributions.", primary: true },
+      { command: "validate --task <id>", description: "Run plugin-contributed validators for a task.", primary: true },
+      { command: "run <command-id> [args...]", description: "Execute a plugin-contributed CLI command (also callable as `rig <command-id>`)." }
+    ],
+    examples: ["rig plugin list", "rig plugin run <command-id>"]
+  },
+  {
+    name: "init",
+    summary: "Set up Rig for this repo: server, GitHub auth, checkout strategy, task source, and Pi wiring.",
+    usage: ["rig init [--yes] [--server local|remote] [--repo owner/repo] [--remote-url <url>]"],
+    commands: [
+      { command: "init", description: "Interactive setup wizard for a new or existing Rig repo.", primary: true },
+      { command: "init --demo", description: "Offline demo project: files task source + 3 sample tasks, zero GitHub.", primary: true },
+      { command: "init --yes", description: "Non-interactive setup using detected/default settings.", primary: true },
+      { command: "init --server remote --remote-url <url>", description: "Link this repo to a remote Rig server.", primary: true },
+      { command: "init --repair", description: "Repair missing private state without replacing project config." }
+    ],
+    examples: [
+      "rig init",
+      "rig init --demo",
+      "rig init --yes --repo humanity-org/humanwork",
+      "rig init --server remote --remote-url https://where.rig-does.work --repo owner/repo"
+    ],
+    next: ["After init, run `rig server status`.", "Then use `rig task list` and `rig task run --next` for day-to-day work."]
+  },
+  {
+    name: "doctor",
+    summary: "Diagnostics for project/server/GitHub/Pi state.",
+    usage: ["rig doctor"],
+    commands: [
+      { command: "doctor", description: "Run setup and runtime diagnostics.", primary: true },
+      { command: "check", description: "Compatibility spelling for diagnostics." }
+    ],
+    examples: ["rig doctor", "rig doctor --json"],
+    next: ["Use `rig server status` and `rig github auth status` to inspect common failure points."]
+  },
+  {
+    name: "github",
+    summary: "GitHub auth helpers for the selected Rig server.",
+    usage: ["rig github auth <status|import-gh|token>"],
+    commands: [
+      { command: "auth status", description: "Show GitHub auth state.", primary: true },
+      { command: "auth import-gh", description: "Import the current `gh` token into the selected server." },
+      { command: "auth token --token <token>", description: "Store a token on the selected server." }
+    ],
+    examples: ["rig github auth status", "rig github auth import-gh"],
+    next: ["After auth is valid, use `rig task run --next`."]
+  }
+];
+var ADVANCED_GROUPS = [
+  {
+    name: "setup",
+    summary: "Bootstrap/check local setup.",
+    usage: ["rig setup <bootstrap|check|preflight>"],
+    commands: [
+      { command: "bootstrap", description: "Bootstrap local setup dependencies.", primary: true },
+      { command: "check", description: "Check local setup state (toolchain, deps, config).", primary: true },
+      { command: "preflight", description: "Run preflight checks before a run.", primary: true }
+    ]
+  },
+  {
+    name: "profile",
+    summary: "Runtime profile/model defaults.",
+    usage: ["rig profile <show|set>"],
+    commands: [
+      { command: "show", description: "Show the active execution profile.", primary: true },
+      { command: "set [--model <model>] [--runtime <runtime>] [--plugin <plugin>]", description: "Set model/runtime/plugin profile defaults.", primary: true }
+    ]
+  },
+  {
+    name: "review",
+    summary: "Inspect or change completion review gate policy.",
+    usage: ["rig review <show|set>"],
+    commands: [
+      { command: "show", description: "Show current review gate settings." },
+      { command: "set <off|advisory|required> [--provider <provider>]", description: "Change review strictness/provider (e.g. --provider greptile)." }
+    ],
+    examples: ["rig review show", "rig review set required --provider greptile"],
+    next: ["Use `rig inbox approvals` for blocked run handoffs."]
+  },
+  {
+    name: "browser",
+    summary: "Browser workstation actions for browser-required tasks: launch, check, CDP probe, profile reset, and app-specific smokes.",
+    usage: ["rig browser <help|explain|demo|hp-next|cdp-probe|profile-persistence|profile-lock-check|smoke-test> [options]"],
+    commands: [
+      { command: "help", description: "Rich browser command help (canonical: `rig browser help`).", primary: true },
+      { command: "explain", description: "Explain the browser-required task contract and runtime helper commands.", primary: true },
+      { command: "demo [--port <n>] [--profile <name>] [--state-dir <path>] [--target-url <url>] [--keep-open] [--no-build]", description: "Run a guided real browser/agent demo flow.", primary: true },
+      { command: "hp-next dev", description: "Start hp-next Rig Browser in dev/watch mode.", primary: true },
+      { command: "hp-next start", description: "Build/start the hp-next browser workstation without watch mode.", primary: true },
+      { command: "hp-next check", description: "Validate the hp-next CDP endpoint on the configured port.", primary: true },
+      { command: "hp-next e2e", description: "Run hp-next browser e2e smoke checks through Rig Browser.", primary: true },
+      { command: "hp-next reset", description: "Reset the hp-next browser profile when stale browser state is suspected.", primary: true },
+      { command: "cdp-probe", description: "Run an isolated CDP attach/evaluate/layout probe." },
+      { command: "profile-persistence", description: "Verify a named browser profile persists browser state." },
+      { command: "profile-lock-check", description: "Verify concurrent launches reject the same profile." },
+      { command: "smoke-test", description: "Run the browser package smoke test." }
+    ],
+    examples: [
+      "rig browser help",
+      "rig browser hp-next check",
+      "rig browser hp-next e2e",
+      "rig browser cdp-probe",
+      "rig browser profile-lock-check"
+    ],
+    next: ["Inside a task run, use rig-browser-launch, rig-browser-check, and rig-browser-attach-info from the worker PATH."]
+  },
+  {
+    name: "pi",
+    summary: "Manage Pi extension packages for this project (community extensions from npm/git).",
+    usage: ["rig pi <list|add|remove|search> [args]"],
+    commands: [
+      { command: "list", description: "Show project and user Pi extension packages." },
+      { command: "add <source>", description: "Add an npm/git Pi extension to .pi/settings.json (auto-installs at next session)." },
+      { command: "remove <source>", description: "Remove an operator-added Pi extension." },
+      { command: "search [term]", description: "Discover Pi extension packages on the npm registry." }
+    ],
+    examples: ["rig pi search subagents", "rig pi add pi-subagents", "rig pi list"],
+    next: ["Config-managed extensions: declare `runtime: { pi: { packages: [...] } }` in rig.config.ts \u2014 workers pick them up automatically."]
+  },
+  {
+    name: "queue",
+    summary: "Run task queues locally.",
+    usage: ["rig queue run [--workers <n>] [--max-tasks <n>] [--action validate|verify|pipeline] [--isolation off|worktree] [--no-runtime-reuse] [--fail-fast] [--skip-project-sync]"],
+    commands: [
+      { command: "run [--workers <n>] [--max-tasks <n>] [--action validate|verify|pipeline] [--isolation off|worktree] [--no-runtime-reuse] [--fail-fast] [--skip-project-sync]", description: "Process queue work: drain matching tasks with N workers, optional per-task action and isolation.", primary: true }
+    ]
+  },
+  {
+    name: "agent",
+    summary: "Runtime agent workspace helpers.",
+    usage: ["rig agent <list|prepare|run|cleanup>"],
+    commands: [
+      { command: "list", description: "List prepared agent runtimes.", primary: true },
+      { command: "prepare [--id <id>] [--mode <mode>] [--task <task>]", description: "Prepare an isolated agent runtime workspace.", primary: true },
+      { command: "run [--id <id>] [--mode <mode>] [--task <task>] [--skip-project-sync]", description: "Prepare (if needed) and run an agent in its workspace.", primary: true },
+      { command: "cleanup [--all] [--id <id>]", description: "Remove prepared agent workspaces.", primary: true }
+    ]
+  },
+  { name: "inspector", summary: "Event stream and drift scanners.", usage: ["rig inspector <stream|scan-upstream-drift>"], commands: [{ command: "stream", description: "Stream events." }] },
+  {
+    name: "dist",
+    summary: "Build/install packaged Rig CLI.",
+    usage: ["rig dist <build|install|doctor|rebuild-agent>"],
+    commands: [
+      { command: "build [--output-dir <dir>]", description: "Build the distributable Rig CLI.", primary: true },
+      { command: "install [--scope <scope>] [--path <path>]", description: "Install the built CLI to a scope/path.", primary: true },
+      { command: "doctor", description: "Diagnose the dist toolchain and install state.", primary: true },
+      { command: "rebuild-agent", description: "Rebuild the agent runtime image, pruning stale images.", primary: true }
+    ]
+  },
+  { name: "workspace", summary: "Workspace topology/service helpers.", usage: ["rig workspace <summary|topology|remote-hosts>"], commands: [{ command: "summary", description: "Show workspace summary." }] },
+  {
+    name: "remote",
+    summary: "Compatibility remote orchestration controls.",
+    usage: ["rig remote <status|tasks|watch|pause|resume|continue|stop|refresh|add-iterations|remove-iterations|endpoint ...>"],
+    commands: [
+      { command: "status [--remote <alias>]", description: "Show the remote orchestration state.", primary: true },
+      { command: "tasks [--remote <alias>]", description: "List the remote's tracked tasks.", primary: true },
+      { command: "watch [--remote <alias>] [--seconds <n>] [--event <type>]", description: "Stream remote orchestration events.", primary: true },
+      { command: "pause [--remote <alias>]", description: "Pause the running remote orchestration.", primary: true },
+      { command: "resume [--remote <alias>] [--max-workers <n>] [--max-iterations <n>] [--direct-merge]", description: "Resume the remote with optional tuning.", primary: true },
+      { command: "continue [--remote <alias>]", description: "Continue a paused remote orchestration.", primary: true },
+      { command: "stop [--remote <alias>]", description: "Stop the remote orchestration.", primary: true },
+      { command: "refresh [--remote <alias>]", description: "Refresh remote state.", primary: true },
+      { command: "add-iterations [--count <n>] [--remote <alias>]", description: "Grant the remote more iterations.", primary: true },
+      { command: "remove-iterations [--count <n>] [--remote <alias>]", description: "Reduce the remote's iteration budget.", primary: true },
+      { command: "endpoint list", description: "List configured remote endpoints.", primary: true },
+      { command: "endpoint add --alias <alias> --host <host> --port <n> [--token <token>]", description: "Register a remote endpoint.", primary: true },
+      { command: "endpoint remove --alias <alias>", description: "Remove a remote endpoint.", primary: true },
+      { command: "endpoint test [--alias <alias>]", description: "Test connectivity to a remote endpoint.", primary: true },
+      { command: "endpoint doctor", description: "Diagnose remote endpoint configuration.", primary: true }
+    ]
+  },
+  { name: "git", summary: "Pass through to Rig git-flow helper.", usage: ["rig git <args...>"], commands: [{ command: "<args...>", description: "Advanced git flow operations." }] },
+  { name: "harness", summary: "Pass through to runtime harness CLI.", usage: ["rig harness <args...>"], commands: [{ command: "<args...>", description: "Advanced harness operations." }] },
+  { name: "test", summary: "Project test wrappers.", usage: ["rig test <unit|e2e|all>"], commands: [{ command: "all", description: "Run configured project tests." }] }
+];
+var ALL_GROUPS = [...PRIMARY_GROUPS, ...ADVANCED_GROUPS];
+
+// packages/cli/src/app-opentui/surface-catalog.ts
+var BESPOKE_FAMILIES = new Set([
+  "run",
+  "task",
+  "inbox",
+  "server",
+  "init",
+  "doctor",
+  "pi",
+  "plugin",
+  "repo",
+  "workspace",
+  "inspect"
+]);
+var SAFE_DIRECT_COMMANDS = new Set([
+  "server status",
+  "server list",
+  "server use local",
+  "task list",
+  "task next",
+  "task ready",
+  "run list",
+  "run status",
+  "inbox approvals",
+  "inbox inputs",
+  "stats show",
+  "plugin list",
+  "doctor doctor",
+  "doctor check",
+  "github auth status",
+  "browser help",
+  "browser explain",
+  "pi list",
+  "pi search",
+  "setup check",
+  "profile show",
+  "review show",
+  "repo sync",
+  "agent list",
+  "dist doctor",
+  "workspace summary",
+  "remote status"
+]);
+
+// packages/cli/src/app-opentui/intent.ts
+var NAV_SCENES = new Map([
+  ["", "main"],
+  ["main", "main"],
+  ["home", "main"],
+  ["fleet", "fleet"],
+  ["runs", "fleet"],
+  ["run", "fleet"],
+  ["tasks", "tasks"],
+  ["task", "tasks"],
+  ["inbox", "inbox"],
+  ["server", "server"],
+  ["init", "init"],
+  ["doctor", "doctor"],
+  ["pi", "pi"],
+  ["plugin", "plugin"],
+  ["repo", "repo"],
+  ["workspace", "workspace"],
+  ["inspect", "inspect"],
+  ["help", "help"]
+]);
+var TASK_VIEW_COMMANDS = new Set([
+  "",
+  "all",
+  "open",
+  "ready",
+  "blocked",
+  "closed",
+  "done",
+  "mine",
+  "me",
+  "sort",
+  "status",
+  "state",
+  "assignee",
+  "assigned",
+  "label",
+  "search",
+  "q"
+]);
+var HOLLOW_FAMILIES = new Set([
+  "browser",
+  "stats",
+  "dist",
+  "agent",
+  "queue",
+  "remote",
+  "harness",
+  "git",
+  "setup",
+  "profile",
+  "review",
+  "inspector",
+  "test"
+]);
+
+// packages/cli/src/app-opentui/pi-pty-host.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { basename as basename2 } from "path";
+import { RGBA as RGBA2, StyledText as StyledText2, TextAttributes as TextAttributes2 } from "@opentui/core";
+import { Terminal as XtermTerminal2 } from "@xterm/headless";
+var MIN_COLS2 = 40;
+var MIN_ROWS2 = 12;
+var MAX_ROWS2 = 300;
+var MAX_SNAPSHOT_LINES2 = 360;
+var STYLED_SNAPSHOT_MARGIN = 6;
+var SNAPSHOT_DELAY_MS2 = 120;
+var fallbackChildScriptPath = fileURLToPath2(new URL("./pi-host-child.ts", import.meta.url));
+var activeHost2 = null;
+function clampCols2(cols) {
+  return Math.max(MIN_COLS2, Math.trunc(cols || 100));
+}
+function clampRows2(rows) {
+  return Math.max(MIN_ROWS2, Math.min(MAX_ROWS2, Math.trunc(rows || 35)));
+}
+var XTERM_COLOR_MODE_INDEXED_16 = 16777216;
+var XTERM_COLOR_MODE_INDEXED_256 = 33554432;
+var XTERM_COLOR_MODE_RGB = 50331648;
+function rgbaFromXtermColor(mode, value) {
+  if (mode === 1 || mode === 2 || mode === XTERM_COLOR_MODE_INDEXED_16 || mode === XTERM_COLOR_MODE_INDEXED_256) {
+    return RGBA2.fromIndex(value);
+  }
+  if (mode === 3 || mode === XTERM_COLOR_MODE_RGB) {
+    return RGBA2.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255);
+  }
+  return;
+}
+function textAttributesFromCell(cell) {
+  let attributes = TextAttributes2.NONE;
+  if (cell.isBold())
+    attributes |= TextAttributes2.BOLD;
+  if (cell.isDim())
+    attributes |= TextAttributes2.DIM;
+  if (cell.isItalic())
+    attributes |= TextAttributes2.ITALIC;
+  if (cell.isUnderline())
+    attributes |= TextAttributes2.UNDERLINE;
+  if (cell.isBlink())
+    attributes |= TextAttributes2.BLINK;
+  if (cell.isInverse())
+    attributes |= TextAttributes2.INVERSE;
+  if (cell.isInvisible())
+    attributes |= TextAttributes2.HIDDEN;
+  if (cell.isStrikethrough())
+    attributes |= TextAttributes2.STRIKETHROUGH;
+  return attributes;
+}
+function sameRgba(a, b) {
+  if (!a && !b)
+    return true;
+  return Boolean(a && b && a.equals(b));
+}
+function sameStyle(a, b) {
+  return sameRgba(a.fg, b.fg) && sameRgba(a.bg, b.bg) && (a.attributes ?? 0) === (b.attributes ?? 0);
+}
+function styleFromCell(cell) {
+  return {
+    fg: rgbaFromXtermColor(cell.getFgColorMode(), cell.getFgColor()),
+    bg: rgbaFromXtermColor(cell.getBgColorMode(), cell.getBgColor()),
+    attributes: textAttributesFromCell(cell)
+  };
+}
+function lineToStyledText(line, cols) {
+  if (!line)
+    return new StyledText2([{ __isChunk: true, text: "" }]);
+  const chunks = [];
+  let run = "";
+  let runStyle = null;
+  const flush = () => {
+    if (!run)
+      return;
+    chunks.push({
+      __isChunk: true,
+      text: run,
+      ...runStyle?.fg ? { fg: runStyle.fg } : {},
+      ...runStyle?.bg ? { bg: runStyle.bg } : {},
+      ...(runStyle?.attributes ?? 0) !== 0 ? { attributes: runStyle.attributes } : {}
+    });
+    run = "";
+  };
+  for (let index = 0;index < cols; index += 1) {
+    const cell = line.getCell(index);
+    if (!cell) {
+      if (runStyle !== null)
+        flush();
+      runStyle = null;
+      run += " ";
+      continue;
+    }
+    if (cell.getWidth() === 0)
+      continue;
+    const style = styleFromCell(cell);
+    if (!runStyle || !sameStyle(runStyle, style)) {
+      flush();
+      runStyle = style;
+    }
+    run += cell.getChars() || " ";
+  }
+  flush();
+  return new StyledText2(chunks.length > 0 ? chunks : [{ __isChunk: true, text: "" }]);
+}
+function childCommandPrefix2() {
+  const execName = basename2(process.execPath).toLowerCase();
+  const currentEntry = process.argv[1];
+  if (execName === "bun" || execName === "bun.exe") {
+    return currentEntry ? [process.execPath, currentEntry, "__opentui-pi-host"] : [process.execPath, fallbackChildScriptPath];
+  }
+  return [process.execPath, "__opentui-pi-host"];
+}
+function withEnv2(base) {
+  const env = {};
+  for (const [key, value] of Object.entries(base ?? process.env)) {
+    if (key === "RIG_PLAIN" || key === "RIG_CLI_PLAIN_HELP" || key === "NO_COLOR")
+      continue;
+    if (typeof value === "string")
+      env[key] = value;
+  }
+  return {
+    ...env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+    FORCE_COLOR: env.FORCE_COLOR ?? "1",
+    RIG_OPENTUI_PI_HOST: "1"
+  };
+}
+class PiPtyHost {
+  runId;
+  projectRoot;
+  onSnapshot;
+  onExit;
+  onError;
+  terminal;
+  disposables = [];
+  decoder = new TextDecoder("utf-8");
+  proc = null;
+  pty = null;
+  status = "starting";
+  cols;
+  rows;
+  message = "starting bundled Pi";
+  lastResizeError = null;
+  exitCode;
+  signal;
+  notifyTimer = null;
+  lastStreamKey = "";
+  _disposed = false;
+  constructor(options) {
+    this.runId = options.runId;
+    this.projectRoot = options.projectRoot;
+    this.cols = clampCols2(options.cols);
+    this.rows = clampRows2(options.rows);
+    this.onSnapshot = options.onSnapshot;
+    this.onExit = options.onExit;
+    this.onError = options.onError;
+    this.terminal = new XtermTerminal2({
+      allowProposedApi: true,
+      cols: this.cols,
+      rows: this.rows,
+      scrollback: 1000
+    });
+    this.registerTerminalResponders();
+    this.disposables.push(this.terminal.onWriteParsed(() => {
+      if (this._disposed)
+        return;
+      const snapshot = this.createSnapshot();
+      const key = snapshot.lines.join(`
+`);
+      if (key === this.lastStreamKey)
+        return;
+      this.lastStreamKey = key;
+      this.onSnapshot?.(snapshot);
+    }));
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  get snapshot() {
+    return this.createSnapshot();
+  }
+  async start() {
+    if (this._disposed)
+      throw new Error("Pi PTY host is disposed.");
+    if (typeof Bun.Terminal !== "function") {
+      throw new Error("Bun native PTY is unavailable in this runtime. Pi host requires Bun.Terminal.");
+    }
+    const spawnOptions = {
+      cwd: this.projectRoot,
+      env: withEnv2(process.env),
+      terminal: {
+        cols: this.cols,
+        rows: this.rows,
+        name: "xterm-256color",
+        data: (_terminal, data) => this.handlePtyData(data)
+      }
+    };
+    const proc = Bun.spawn([
+      ...childCommandPrefix2(),
+      "--run-id",
+      this.runId,
+      "--project-root",
+      this.projectRoot
+    ], spawnOptions);
+    if (!proc.terminal)
+      throw new Error("Bun did not attach a terminal to the bundled Pi child process.");
+    this.proc = proc;
+    this.pty = proc.terminal;
+    this.status = "running";
+    this.message = "bundled Pi running inside this app";
+    this.emitSnapshotSoon(0);
+    proc.exited.then((exitCode) => {
+      if (this._disposed)
+        return;
+      this.status = exitCode === 0 ? "exited" : "failed";
+      this.exitCode = exitCode;
+      this.signal = null;
+      this.message = exitCode === 0 ? "bundled Pi exited" : `bundled Pi exited with code ${exitCode}`;
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onExit?.(snapshot);
+      if (activeHost2 === this)
+        activeHost2 = null;
+      this.dispose("exit", { kill: false, notify: false });
+    }).catch((error) => {
+      if (this._disposed)
+        return;
+      this.status = "failed";
+      this.message = error instanceof Error ? error.message : String(error);
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onError?.(error, snapshot);
+      if (activeHost2 === this)
+        activeHost2 = null;
+      this.dispose("error", { kill: false, notify: false });
+    });
+  }
+  write(data) {
+    if (this._disposed || !this.pty)
+      return;
+    try {
+      this.pty.write(data);
+    } catch (error) {
+      this.status = "failed";
+      this.message = error instanceof Error ? error.message : String(error);
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onError?.(error, snapshot);
+    }
+  }
+  resize(cols, rows) {
+    const nextCols = clampCols2(cols);
+    const nextRows = clampRows2(rows);
+    if (nextCols === this.cols && nextRows === this.rows)
+      return;
+    this.cols = nextCols;
+    this.rows = nextRows;
+    this.terminal.resize(nextCols, nextRows);
+    try {
+      this.pty?.resize(nextCols, nextRows);
+      this.lastResizeError = null;
+    } catch (error) {
+      this.lastResizeError = error instanceof Error ? error.message : String(error);
+    }
+    this.emitSnapshotSoon(0);
+  }
+  detach() {
+    this.dispose("detach");
+    return this.createSnapshot("detached from bundled Pi");
+  }
+  dispose(reason = "dispose", options = {}) {
+    if (this._disposed)
+      return;
+    this._disposed = true;
+    if (this.notifyTimer)
+      clearTimeout(this.notifyTimer);
+    this.notifyTimer = null;
+    for (const disposable of this.disposables.splice(0)) {
+      try {
+        disposable.dispose();
+      } catch {}
+    }
+    if (options.kill !== false) {
+      try {
+        this.proc?.kill("SIGTERM");
+      } catch {}
+    }
+    try {
+      this.pty?.close();
+    } catch {}
+    try {
+      this.terminal.dispose();
+    } catch {}
+    if (activeHost2 === this)
+      activeHost2 = null;
+    if (options.notify) {
+      this.message = reason;
+      this.onSnapshot?.(this.createSnapshot(reason));
+    }
+  }
+  handlePtyData(data) {
+    if (this._disposed)
+      return;
+    const text = this.decoder.decode(data, { stream: true });
+    this.respondToRawTerminalQueries(text);
+    this.terminal.write(data);
+  }
+  emitSnapshotSoon(delayMs = SNAPSHOT_DELAY_MS2) {
+    if (this._disposed || this.notifyTimer)
+      return;
+    this.notifyTimer = setTimeout(() => {
+      this.notifyTimer = null;
+      if (this._disposed)
+        return;
+      this.onSnapshot?.(this.createSnapshot());
+    }, delayMs);
+  }
+  createSnapshot(message = this.message) {
+    const buffer = this.terminal.buffer.active;
+    const end = buffer.length;
+    const start = Math.max(0, end - MAX_SNAPSHOT_LINES2);
+    const styledStart = Math.max(start, end - this.rows - STYLED_SNAPSHOT_MARGIN);
+    const lines = [];
+    const styledLines = [];
+    for (let row = start;row < end; row += 1) {
+      const line = buffer.getLine(row);
+      lines.push((line?.translateToString(false) ?? "").slice(0, this.cols));
+      if (row >= styledStart)
+        styledLines[lines.length - 1] = lineToStyledText(line, this.cols);
+    }
+    while (lines.length < this.rows) {
+      lines.push("");
+      styledLines[lines.length - 1] = new StyledText2([{ __isChunk: true, text: "" }]);
+    }
+    const resolvedMessage = this.lastResizeError ? `resize degraded: ${this.lastResizeError}` : message;
+    return {
+      runId: this.runId,
+      status: this.status,
+      cols: this.cols,
+      rows: this.rows,
+      lines,
+      styledLines,
+      message: resolvedMessage,
+      ...this.lastResizeError ? { resizeError: this.lastResizeError } : {},
+      ...this.exitCode !== undefined ? { exitCode: this.exitCode } : {},
+      ...this.signal !== undefined ? { signal: this.signal } : {}
+    };
+  }
+  registerTerminalResponders() {
+    this.disposables.push(this.terminal.parser.registerCsiHandler({ final: "c" }, (params) => {
+      if (params.length === 0 || params[0] === 0)
+        this.write("\x1B[?62;22c");
+      return false;
+    }));
+    this.disposables.push(this.terminal.parser.registerCsiHandler({ prefix: ">", final: "c" }, (params) => {
+      if (params.length === 0 || params[0] === 0)
+        this.write("\x1B[>0;0;0c");
+      return false;
+    }));
+    this.disposables.push(this.terminal.parser.registerCsiHandler({ final: "n" }, (params) => {
+      if (params[0] === 5) {
+        this.write("\x1B[0n");
+      } else if (params[0] === 6) {
+        const row = this.terminal.buffer.active.cursorY + 1;
+        const col = this.terminal.buffer.active.cursorX + 1;
+        this.write(`\x1B[${row};${col}R`);
+      }
+      return false;
+    }));
+  }
+  respondToRawTerminalQueries(text) {
+    if (!text)
+      return;
+    const decrqm = /\x1b\[\?(\d+)\$p/g;
+    let match;
+    while ((match = decrqm.exec(text)) !== null) {
+      this.write(`\x1B[?${match[1]};2$y`);
+    }
+  }
+}
+
+// packages/cli/src/commands/_server-events.ts
+import { WsTransport } from "@rig/client";
+import { RIG_WS_CHANNELS } from "@rig/contracts";
+
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+// packages/cli/src/commands/_server-client.ts
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+var scopedGitHubBearerTokens = new Map;
+var serverReachabilityCache = new Map;
+var RESUMABLE_RUN_STATUSES = new Set([
+  "created",
+  "preparing",
+  "running",
+  "validating",
+  "reviewing",
+  "stopped",
+  "failed",
+  "needs-attention",
+  "needs_attention"
+]);
+
+// packages/cli/src/app-opentui/drone.ts
+import { RGBA as RGBA3, StyledText as StyledText3, TextAttributes as TextAttributes3 } from "@opentui/core";
+var COLOR = {
+  body: RGBA3.fromHex(RIG_UI.lime),
+  mini: RGBA3.fromHex(RIG_UI.limeDim),
+  rotor: RGBA3.fromHex(RIG_UI.cyan),
+  path: RGBA3.fromHex(RIG_UI.cyan),
+  eye: RGBA3.fromHex(RIG_UI.ink),
+  dim: RGBA3.fromHex(RIG_UI.ink4),
+  ink: RGBA3.fromHex(RIG_UI.ink2)
+};
+
+// packages/cli/src/app-opentui/render/graphics.ts
+import { FrameBufferRenderable, RGBA as RGBA4 } from "@opentui/core";
+
+// packages/cli/src/app-opentui/render/ascii-fleet.ts
+var LEAD_DRONE = [
+  "  .-=-.                   .-=-.   ",
+  " ( !!! )                 ( !!! )  ",
+  "  '-=-'._               _.'-=-'   ",
+  "        '._           _.'         ",
+  "           '=$$$$$$$=.'           ",
+  "          =$$$$$$$$$$$=           ",
+  "         $$$@@@@@@@@@@$$$         ",
+  "        $$$@@        @@$$$        ",
+  "        $$@    ?     @$$$         ",
+  "        $$$@   '-'   @$$$         ",
+  "        $$$@@        @@$$$        ",
+  "         $$$@@@@@@@@@@$$$         ",
+  "          =$$$$$$$$$$$=           ",
+  "           '=$$$$$$$=.'           ",
+  "        _.'           '._         ",
+  "  .-=-.'                 '.-=-.   ",
+  " ( !!! )                 ( !!! )  ",
+  "  '-=-'                   '-=-'   "
+];
+var MINI_DRONE = [
+  "(!!!)   (!!!)",
+  "  \\%==%/  ",
+  "   %%?%%   ",
+  "  /%==%\\  ",
+  "(!!!)   (!!!)"
+];
+var ROTORS = ["---", "\\\\\\", "|||", "///"];
+var FLEET_GRID_WIDTH = 52;
+var FLEET_GRID_HEIGHT = 27;
+var FLEET = [
+  { art: MINI_DRONE, x: 0, y: 2, amp: 1, speed: 0.05, phase: 0, dx: 1, driftSpeed: 0.02 },
+  { art: MINI_DRONE, x: 39, y: 2, amp: 1, speed: 0.044, phase: 2.1, dx: 1, driftSpeed: 0.017 },
+  { art: MINI_DRONE, x: 1, y: 20, amp: 1, speed: 0.048, phase: 4.2, dx: 1, driftSpeed: 0.023 },
+  { art: MINI_DRONE, x: 38, y: 20, amp: 1, speed: 0.041, phase: 1.3, dx: 1, driftSpeed: 0.015 },
+  { art: LEAD_DRONE, x: 10, y: 5, amp: 2, speed: 0.04, phase: 0, dx: 0, driftSpeed: 0.011 }
+];
+function fleetRows(tick, options = {}) {
+  const animate = options.animate ?? true;
+  const t2 = animate ? tick : 0;
+  const blade = ROTORS[Math.floor(t2 / 4) % ROTORS.length];
+  const pulse = Math.sin(t2 * 0.07);
+  const eye = pulse > 0.45 ? "@" : pulse > -0.1 ? "o" : ".";
+  const grid = Array.from({ length: FLEET_GRID_HEIGHT }, () => Array.from({ length: FLEET_GRID_WIDTH }, () => " "));
+  for (const drone of FLEET) {
+    const yOffset = drone.y + Math.round(drone.amp * Math.sin(t2 * drone.speed + drone.phase));
+    const xOffset = drone.x + Math.round(drone.dx * Math.sin(t2 * drone.driftSpeed + drone.phase));
+    for (let row = 0;row < drone.art.length; row += 1) {
+      const source = drone.art[row];
+      const targetY = yOffset + row;
+      if (targetY < 0 || targetY >= FLEET_GRID_HEIGHT)
+        continue;
+      for (let col = 0;col < source.length; col += 1) {
+        let char = source[col];
+        if (char === " ")
+          continue;
+        const targetX = xOffset + col;
+        if (targetX < 0 || targetX >= FLEET_GRID_WIDTH)
+          continue;
+        if (source.slice(col, col + 3) === "!!!") {
+          for (let rotorIndex = 0;rotorIndex < 3; rotorIndex += 1) {
+            if (targetX + rotorIndex < FLEET_GRID_WIDTH)
+              grid[targetY][targetX + rotorIndex] = blade[rotorIndex];
+          }
+          col += 2;
+          continue;
+        }
+        if (char === "?")
+          char = eye;
+        grid[targetY][targetX] = char;
+      }
+    }
+  }
+  return grid.map((row) => row.join("").replace(/\s+$/, ""));
+}
+
+// packages/cli/src/app-opentui/render/panel-layout.ts
+function panelPixelPlacement(layout, panel, size, minPixels = 8) {
+  const cellW = size.width / layout.width;
+  const cellH = size.height / layout.height;
+  const leftCells = layout.centerLeft + (panel.left ?? 0);
+  const topCells = layout.centerTop + panel.top;
+  const widthCells = panel.width ?? layout.centerWidth;
+  const heightCells = panel.height;
+  const left = Math.round(leftCells * cellW);
+  const top = Math.round(topCells * cellH);
+  const width = Math.round(widthCells * cellW);
+  const height = Math.round(heightCells * cellH);
+  return width > minPixels && height > minPixels ? { left, top, width, height, leftCells, topCells, widthCells, heightCells } : null;
+}
+
+// packages/cli/src/app-opentui/render/constants.ts
+var LCG_MULTIPLIER = 1664525;
+var LCG_INCREMENT = 1013904223;
+var LCG_DIVISOR = 4294967295;
+var PACKET_CYAN_PROBABILITY = 0.22;
+var LANE_INTERP_STEPS = 32;
+var LANE_LEN_BASE = 0.32;
+var LANE_LEN_SPREAD = 0.42;
+var LANE_CURVE_RANGE = 0.7;
+var PACKET_SPEED_BASE = 0.003;
+var PACKET_SPEED_SPREAD = 0.009;
+var DISPATCH_LANES_COMPACT = 7;
+var DISPATCH_LANES_WIDE = 12;
+var DISPATCH_PACKETS_COMPACT = 70;
+var DISPATCH_PACKETS_WIDE = 150;
+var CARRIER_NODES_COMPACT = 5;
+var CARRIER_NODES_WIDE = 7;
+var LOOP_GATES_COMPACT = 4;
+var LOOP_GATES_WIDE = 5;
+var DISPATCH_DRONES_COMPACT = 4;
+var DISPATCH_DRONES_WIDE = 8;
+var CORE_DISPATCH_X = 0.3;
+var CORE_DISPATCH_Y = 0.45;
+var CORE_CARRIER_X = 0.5;
+var CORE_CARRIER_Y = 0.54;
+var CORE_LOOP_X = 0.09;
+var CORE_LOOP_Y = 0.56;
+var RAIL_YS_LOOP = [0.18, 0.5, 0.82];
+var RAIL_YS_CARRIER = [0.24, 0.54, 0.82];
+var RAIL_YS_DISPATCH = [0.18, 0.58, 0.82];
+var GLOW_FALLOFF_EXP_ASCII = 2.2;
+var GLOW_FALLOFF_EXP_IMAGE = 2.4;
+
+// packages/cli/src/app-opentui/render/graphics.ts
+var BRAILLE_SAMPLES_X = 2;
+var BRAILLE_SAMPLES_Y = 4;
+var TRANSPARENT = RGBA4.fromValues(0, 0, 0, 0);
+var BACKDROP = RGBA4.fromHex(RIG_UI.bg);
+var PANEL_BG = RGBA4.fromInts(16, 17, 21, 184);
+var PANEL_HEADER_BG = RGBA4.fromInts(16, 17, 21, 188);
+var PANEL_LINE = RGBA4.fromInts(255, 255, 255, 20);
+var PANEL_LINE_DIM = RGBA4.fromInts(255, 255, 255, 8);
+var PANEL_TEXT_DIM = RGBA4.fromInts(108, 110, 121, 255);
+var AC_RGB = [204, 255, 77];
+var C2_RGB = [86, 216, 255];
+var MG_RGB = [255, 121, 176];
+var INK_RGB = [108, 110, 121];
+var BRAILLE_BITS = [
+  [1, 8],
+  [2, 16],
+  [4, 32],
+  [64, 128]
+];
+function sceneKind(scene) {
+  if (scene === "tasks")
+    return "loop";
+  if (scene === "help")
+    return "carrier";
+  return "dispatch";
+}
+function seeded(seed) {
+  let value = seed >>> 0;
+  return () => {
+    value = value * LCG_MULTIPLIER + LCG_INCREMENT >>> 0;
+    return value / LCG_DIVISOR;
+  };
+}
+function channelBuffer(canvas, channel) {
+  switch (channel) {
+    case 0:
+      return canvas.ac;
+    case 1:
+      return canvas.c2;
+    case 2:
+      return canvas.mg;
+    case 3:
+      return canvas.ink;
+  }
+}
+function addSample(canvas, channel, x, y, value) {
+  const ix = Math.trunc(x);
+  const iy = Math.trunc(y);
+  if (ix < 0 || iy < 0 || ix >= canvas.width || iy >= canvas.height)
+    return;
+  const buffer = channelBuffer(canvas, channel);
+  const index = iy * canvas.width + ix;
+  buffer[index] = Math.min(1, buffer[index] + value);
+}
+function drawDot(canvas, channel, cx, cy, radius, value) {
+  const minX = Math.floor(cx - radius);
+  const maxX = Math.ceil(cx + radius);
+  const minY = Math.floor(cy - radius);
+  const maxY = Math.ceil(cy + radius);
+  for (let y = minY;y <= maxY; y += 1) {
+    for (let x = minX;x <= maxX; x += 1) {
+      const dx = x - cx;
+      const dy = y - cy;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      if (distance > radius)
+        continue;
+      const falloff = 1 - distance / Math.max(0.001, radius);
+      addSample(canvas, channel, x, y, value * (0.28 + falloff * 0.72));
+    }
+  }
+}
+function drawGlow(canvas, channel, cx, cy, radius, value) {
+  const minX = Math.floor(cx - radius);
+  const maxX = Math.ceil(cx + radius);
+  const minY = Math.floor(cy - radius);
+  const maxY = Math.ceil(cy + radius);
+  for (let y = minY;y <= maxY; y += 1) {
+    for (let x = minX;x <= maxX; x += 1) {
+      const dx = x - cx;
+      const dy = y - cy;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      if (distance > radius)
+        continue;
+      const falloff = Math.pow(1 - distance / Math.max(0.001, radius), GLOW_FALLOFF_EXP_ASCII);
+      addSample(canvas, channel, x, y, value * falloff);
+    }
+  }
+}
+function drawLine(canvas, channel, x0, y0, x1, y1, value, width = 0.8) {
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const steps = Math.max(1, Math.ceil(Math.hypot(dx, dy) * 1.7));
+  for (let step = 0;step <= steps; step += 1) {
+    const t2 = step / steps;
+    const x = x0 + dx * t2;
+    const y = y0 + dy * t2;
+    drawDot(canvas, channel, x, y, width, value);
+  }
+}
+function drawCircleStroke(canvas, channel, cx, cy, radius, value) {
+  const steps = Math.max(18, Math.ceil(radius * 8));
+  for (let step = 0;step < steps; step += 1) {
+    const a = step / steps * Math.PI * 2;
+    drawDot(canvas, channel, cx + Math.cos(a) * radius, cy + Math.sin(a) * radius, 0.72, value);
+  }
+}
+function paletteColor(ac, c2, mg, ink) {
+  const total = Math.max(0.001, ac + c2 + mg + ink);
+  const r = (AC_RGB[0] * ac + C2_RGB[0] * c2 + MG_RGB[0] * mg + INK_RGB[0] * ink) / total;
+  const g = (AC_RGB[1] * ac + C2_RGB[1] * c2 + MG_RGB[1] * mg + INK_RGB[1] * ink) / total;
+  const b = (AC_RGB[2] * ac + C2_RGB[2] * c2 + MG_RGB[2] * mg + INK_RGB[2] * ink) / total;
+  const intensity = Math.min(1, total / 4);
+  const lift = 0.34 + intensity * 0.66;
+  return RGBA4.fromInts(Math.round(r * lift), Math.round(g * lift), Math.round(b * lift), 255);
+}
+function clearCanvas(canvas) {
+  canvas.ac.fill(0);
+  canvas.c2.fill(0);
+  canvas.mg.fill(0);
+  canvas.ink.fill(0);
+}
+function makeCanvas(layout) {
+  const width = Math.max(1, layout.width * BRAILLE_SAMPLES_X);
+  const height = Math.max(1, layout.height * BRAILLE_SAMPLES_Y);
+  const size = width * height;
+  return {
+    width,
+    height,
+    ac: new Float32Array(size),
+    c2: new Float32Array(size),
+    mg: new Float32Array(size),
+    ink: new Float32Array(size)
+  };
+}
+
+class MarketingGlyphCanvas {
+  rand = seeded(6221137);
+  canvas;
+  layout;
+  activeKind = null;
+  lanes = [];
+  motes = [];
+  packets = [];
+  constructor(layout) {
+    this.layout = layout;
+    this.canvas = makeCanvas(layout);
+    this.reset("dispatch");
+  }
+  resize(layout) {
+    if (layout.width === this.layout.width && layout.height === this.layout.height)
+      return;
+    this.layout = layout;
+    this.canvas = makeCanvas(layout);
+    this.reset(this.activeKind ?? "dispatch");
+  }
+  render(layer, scene, tick) {
+    const kind = sceneKind(scene);
+    if (kind !== this.activeKind)
+      this.reset(kind);
+    clearCanvas(this.canvas);
+    this.drawMarketingRails(kind, tick);
+    if (kind === "loop")
+      this.drawLoop(tick);
+    else if (kind === "carrier")
+      this.drawCarrier(tick);
+    else
+      this.drawDispatch(tick);
+    this.blit(layer);
+  }
+  reset(kind) {
+    this.activeKind = kind;
+    this.lanes = [];
+    this.motes = [];
+    this.packets = [];
+    if (kind === "dispatch")
+      this.setupDispatch();
+    else if (kind === "loop")
+      this.setupLoop();
+    else
+      this.setupCarrier();
+  }
+  setupDispatch() {
+    const count = this.layout.compact ? DISPATCH_LANES_COMPACT : DISPATCH_LANES_WIDE;
+    for (let i = 0;i < count; i += 1) {
+      const ang = (-0.9 + 1.8 * (i / Math.max(1, count - 1))) * (Math.PI * 0.5);
+      this.lanes.push({ ang, len: this.canvas.width * (LANE_LEN_BASE + this.rand() * LANE_LEN_SPREAD), curve: (this.rand() - 0.5) * LANE_CURVE_RANGE, phase: this.rand() * Math.PI * 2 });
+    }
+    const packets = this.layout.compact ? DISPATCH_PACKETS_COMPACT : DISPATCH_PACKETS_WIDE;
+    for (let i = 0;i < packets; i += 1)
+      this.packets.push(this.packet(true));
+  }
+  setupLoop() {
+    const lanes = this.layout.compact ? 4 : 7;
+    for (let i = 0;i < lanes; i += 1)
+      this.packets.push(this.packet(true));
+  }
+  setupCarrier() {
+    const nodes = this.layout.compact ? CARRIER_NODES_COMPACT : CARRIER_NODES_WIDE;
+    for (let i = 0;i < nodes * 6; i += 1)
+      this.packets.push(this.packet(true));
+  }
+  packet(random = false) {
+    return {
+      lane: Math.floor(this.rand() * Math.max(1, this.lanes.length || 7)),
+      p: random ? this.rand() : 0,
+      spd: PACKET_SPEED_BASE + this.rand() * PACKET_SPEED_SPREAD,
+      channel: this.rand() < PACKET_CYAN_PROBABILITY ? 1 : 0,
+      wobble: (this.rand() - 0.5) * 7,
+      size: 0.8 + this.rand() * 1.3
+    };
+  }
+  core(kind) {
+    if (kind === "dispatch")
+      return { x: this.canvas.width * CORE_DISPATCH_X, y: this.canvas.height * CORE_DISPATCH_Y };
+    if (kind === "carrier")
+      return { x: this.canvas.width * CORE_CARRIER_X, y: this.canvas.height * CORE_CARRIER_Y };
+    return { x: this.canvas.width * CORE_LOOP_X, y: this.canvas.height * CORE_LOOP_Y };
+  }
+  lanePoint(lane, p, kind = "dispatch") {
+    const core = this.core(kind);
+    const dist = lane.len * p;
+    const bend = Math.sin(p * Math.PI) * lane.curve * 28;
+    const ux = Math.cos(lane.ang);
+    const uy = Math.sin(lane.ang);
+    return { x: core.x + ux * dist + -uy * bend, y: core.y + uy * dist + ux * bend };
+  }
+  drawMotes(tick) {
+    for (const mote of this.motes) {
+      mote.x += 0.1 * mote.z;
+      if (mote.x > this.canvas.width + 2)
+        mote.x = -2;
+      const alpha = (0.035 + 0.08 * mote.z) * (0.55 + 0.45 * Math.sin(tick * 0.03 + mote.tw));
+      drawDot(this.canvas, mote.channel, mote.x, mote.y, 0.45 * mote.z, alpha);
+    }
+  }
+  drawMarketingRails(kind, tick) {
+    const ys = kind === "loop" ? RAIL_YS_LOOP : kind === "carrier" ? RAIL_YS_CARRIER : RAIL_YS_DISPATCH;
+    ys.forEach((ratio, index) => {
+      const y = this.canvas.height * ratio + Math.sin(tick * 0.018 + index) * 1.8;
+      drawLine(this.canvas, index === 1 ? 0 : 1, this.canvas.width * 0.06, y, this.canvas.width * 0.94, y + Math.sin(index) * 2, index === 1 ? 0.11 : 0.07, 0.55);
+      for (let p = (tick * 0.004 + index * 0.21) % 1;p < 1; p += 0.18 + index * 0.02) {
+        const x = this.canvas.width * (0.06 + 0.88 * p);
+        drawDot(this.canvas, index === 2 ? 1 : 0, x, y, 1 + index * 0.25, 0.24);
+        drawGlow(this.canvas, index === 2 ? 1 : 0, x, y, 3.8, 0.035);
+      }
+    });
+  }
+  drawDispatch(tick) {
+    const core = this.core("dispatch");
+    drawGlow(this.canvas, 0, core.x, core.y, 30, 0.12);
+    drawDot(this.canvas, 0, core.x, core.y, 2.2, 0.85);
+    for (const lane of this.lanes) {
+      let prev = this.lanePoint(lane, 0);
+      for (let i = 1;i <= LANE_INTERP_STEPS; i += 1) {
+        const next = this.lanePoint(lane, i / LANE_INTERP_STEPS);
+        drawLine(this.canvas, lane.phase > Math.PI ? 1 : 0, prev.x, prev.y, next.x, next.y, 0.045, 0.38);
+        prev = next;
+      }
+    }
+    for (const packet of this.packets) {
+      packet.p += packet.spd;
+      if (packet.p > 1)
+        Object.assign(packet, this.packet(false));
+      const lane = this.lanes[packet.lane % Math.max(1, this.lanes.length)];
+      if (!lane)
+        continue;
+      const pt = this.lanePoint(lane, packet.p);
+      const fade = packet.p < 0.1 ? packet.p / 0.1 : packet.p > 0.88 ? (1 - packet.p) / 0.12 : 1;
+      const y = pt.y + packet.wobble * Math.sin(packet.p * Math.PI * 2);
+      drawLine(this.canvas, packet.channel, pt.x - 4, y - 1, pt.x, y, 0.08 * fade, 0.38);
+      drawDot(this.canvas, packet.channel, pt.x, y, packet.size, 0.5 * fade);
+      drawGlow(this.canvas, packet.channel, pt.x, y, packet.size * 4, 0.045 * fade);
+    }
+    for (let i = 0;i < (this.layout.compact ? DISPATCH_DRONES_COMPACT : DISPATCH_DRONES_WIDE); i += 1) {
+      const lane = this.lanes[i % Math.max(1, this.lanes.length)];
+      if (!lane)
+        continue;
+      const p = (tick * 0.002 + i * 0.13) % 1;
+      const pt = this.lanePoint(lane, p);
+      this.drawDrone(pt.x, pt.y + Math.sin(tick * 0.04 + i) * 2, 2.6 + i % 2 * 0.6, tick + i * 11, i % 3 === 0 ? 1 : 0);
+    }
+  }
+  drawLoop(tick) {
+    const y = this.canvas.height * 0.56;
+    const x0 = this.canvas.width * 0.09;
+    const x1 = this.canvas.width * 0.91;
+    drawLine(this.canvas, 0, x0, y, x1, y, 0.12, 0.55);
+    const gates = this.layout.compact ? LOOP_GATES_COMPACT : LOOP_GATES_WIDE;
+    const active = Math.floor(tick / 16) % gates;
+    for (let i = 0;i < gates; i += 1) {
+      const x = x0 + (x1 - x0) * (i / Math.max(1, gates - 1));
+      drawLine(this.canvas, i === active ? 0 : 3, x, y - 22, x, y + 22, i === active ? 0.25 : 0.08, i === active ? 0.7 : 0.42);
+      drawDot(this.canvas, i <= active ? 0 : 3, x, y, i === active ? 2.2 : 1.2, i === active ? 0.72 : 0.25);
+      drawCircleStroke(this.canvas, i <= active ? 0 : 3, x, y, i === active ? 4.2 : 2.4, i === active ? 0.18 : 0.08);
+    }
+    for (const packet of this.packets) {
+      packet.p += packet.spd * 0.7;
+      if (packet.p > 1)
+        packet.p = 0;
+      const x = x0 + (x1 - x0) * packet.p;
+      const segment = Math.min(gates - 1, Math.floor(packet.p * gates));
+      const channel = segment < active ? 0 : segment === active ? 1 : 3;
+      const py = y + packet.wobble * Math.sin(packet.p * Math.PI * 2);
+      drawLine(this.canvas, channel, x - 6, py, x, py, 0.1, 0.42);
+      drawDot(this.canvas, channel, x, py, packet.size, channel === 3 ? 0.22 : 0.58);
+      drawGlow(this.canvas, channel, x, py, 3.8, channel === 3 ? 0.02 : 0.04);
+    }
+    this.drawDrone(x0 + (x1 - x0) * (tick * 0.003 % 1), y - 18, 2.7, tick, 0);
+    this.drawDrone(x0 + (x1 - x0) * ((tick * 0.002 + 0.5) % 1), y + 16, 2.2, tick + 40, 2);
+  }
+  drawCarrier(tick) {
+    const core = this.core("carrier");
+    drawGlow(this.canvas, 0, core.x, core.y, 26, 0.12);
+    drawDot(this.canvas, 0, core.x, core.y, 2.4, 0.92);
+    drawCircleStroke(this.canvas, 0, core.x, core.y, 8 + Math.sin(tick * 0.06) * 2, 0.14);
+    const nodes = this.layout.compact ? CARRIER_NODES_COMPACT : CARRIER_NODES_WIDE;
+    const rx = this.canvas.width * 0.36;
+    const ry = this.canvas.height * 0.22;
+    for (let i = 0;i < nodes; i += 1) {
+      const a = i / nodes * Math.PI * 2 - Math.PI / 2 + tick * 0.006;
+      const x = core.x + Math.cos(a) * rx;
+      const y = core.y + Math.sin(a) * ry;
+      drawLine(this.canvas, i % 2 ? 1 : 0, core.x, core.y, x, y, 0.055, 0.36);
+      drawCircleStroke(this.canvas, i % 2 ? 1 : 0, x, y, 4.2, 0.15);
+      drawDot(this.canvas, i % 2 ? 1 : 0, x, y, 1.7, 0.62);
+      this.drawDrone(x, y - 8, 2.1, tick + i * 9, i % 2 ? 1 : 0);
+    }
+    for (const packet of this.packets) {
+      packet.p += packet.spd;
+      if (packet.p > 1)
+        packet.p = 0;
+      const lane = packet.lane % nodes;
+      const a = lane / nodes * Math.PI * 2 - Math.PI / 2 + tick * 0.006;
+      const nx = core.x + Math.cos(a) * rx;
+      const ny = core.y + Math.sin(a) * ry;
+      const x = core.x + (nx - core.x) * packet.p;
+      const y = core.y + (ny - core.y) * packet.p;
+      drawDot(this.canvas, packet.channel, x, y, packet.size, 0.48);
+      drawGlow(this.canvas, packet.channel, x, y, 3.2, 0.035);
+    }
+  }
+  drawDrone(x, y, scale, tick, channel) {
+    const wobble = Math.sin(tick * 0.08) * 0.7;
+    drawDot(this.canvas, channel, x, y + wobble, scale, 0.58);
+    drawDot(this.canvas, 3, x, y + wobble, Math.max(0.6, scale * 0.28), 0.42);
+    const rotor = scale * 1.75;
+    const arms = [
+      [-rotor, -rotor * 0.75],
+      [rotor, -rotor * 0.75],
+      [-rotor, rotor * 0.75],
+      [rotor, rotor * 0.75]
+    ];
+    for (const [dx, dy] of arms) {
+      drawLine(this.canvas, channel, x, y + wobble, x + dx, y + dy + wobble, 0.11, 0.38);
+      drawCircleStroke(this.canvas, channel, x + dx, y + dy + wobble, scale * (0.65 + Math.abs(Math.sin(tick * 0.18)) * 0.25), 0.16);
+      drawDot(this.canvas, channel, x + dx, y + dy + wobble, 0.7, 0.25);
+    }
+    drawLine(this.canvas, channel === 1 ? 0 : 1, x - rotor * 2.4, y + wobble + 1.2, x - rotor * 1.2, y + wobble, 0.05, 0.35);
+  }
+  blit(layer) {
+    const fb = layer.frameBuffer;
+    fb.clear(BACKDROP);
+    const { width, height, ac, c2, mg, ink } = this.canvas;
+    for (let cy = 0;cy < this.layout.height; cy += 1) {
+      for (let cx = 0;cx < this.layout.width; cx += 1) {
+        let bits = 0;
+        let acSum = 0;
+        let c2Sum = 0;
+        let mgSum = 0;
+        let inkSum = 0;
+        for (let sy = 0;sy < BRAILLE_SAMPLES_Y; sy += 1) {
+          for (let sx = 0;sx < BRAILLE_SAMPLES_X; sx += 1) {
+            const px = cx * BRAILLE_SAMPLES_X + sx;
+            const py = cy * BRAILLE_SAMPLES_Y + sy;
+            if (px >= width || py >= height)
+              continue;
+            const index = py * width + px;
+            const a = ac[index];
+            const c = c2[index];
+            const m = mg[index];
+            const k = ink[index];
+            const total2 = a + c + m + k;
+            acSum += a;
+            c2Sum += c;
+            mgSum += m;
+            inkSum += k;
+            if (total2 > 0.11)
+              bits |= BRAILLE_BITS[sy][sx];
+          }
+        }
+        const total = acSum + c2Sum + mgSum + inkSum;
+        if (bits === 0 || total <= 0.02)
+          continue;
+        const char = String.fromCharCode(10240 + bits);
+        fb.setCellWithAlphaBlending(cx, cy, char, paletteColor(acSum, c2Sum, mgSum, inkSum), TRANSPARENT);
+      }
+    }
+  }
+}
+
+// packages/cli/src/app-opentui/fleet-stats.ts
+var ACTIVE_STATUSES = new Set([
+  "running",
+  "preparing",
+  "created",
+  "validating",
+  "reviewing",
+  "closing-out",
+  "stopping",
+  "loading"
+]);
+
+// packages/cli/src/app-opentui/render/image-visual-layer.ts
+import { Worker } from "worker_threads";
+import { deflateSync } from "zlib";
+import { allocateImageId, deleteKittyImage } from "@earendil-works/pi-tui";
+
+// packages/cli/src/app-opentui/terminal-capabilities.ts
+import { getCapabilities } from "@earendil-works/pi-tui";
+function getRigTerminalCapabilities() {
+  const imageProtocol = getCapabilities().images;
+  const supportsKittyImages = imageProtocol === "kitty";
+  return {
+    imageProtocol,
+    supportsKittyImages,
+    visualMode: supportsKittyImages ? "kitty-images" : "framebuffer-fallback"
+  };
+}
+
+// packages/cli/src/app-opentui/render/image-visual-layer.ts
+var PANEL_MASK_RADIUS_MIN = 14;
+var PANEL_MASK_RADIUS_MAX = 34;
+var PANEL_MASK_RADIUS_FACTOR = 0.035;
+var PANEL_BLUR_RADIUS_MIN = 8;
+var PANEL_BLUR_RADIUS_MAX = 28;
+var PANEL_BLUR_RADIUS_FACTOR = 0.018;
+var BG = [7, 8, 9, 255];
+var PANEL = [16, 17, 21, 184];
+var PANEL_HEADER = [16, 17, 21, 190];
+var PANEL_LINE2 = [255, 255, 255, 24];
+var LIME = [204, 255, 77, 255];
+var LIME_DIM = [169, 214, 63, 255];
+var CYAN = [86, 216, 255, 255];
+var MAGENTA = [255, 121, 176, 255];
+var INK_DIM = [108, 110, 121, 255];
+var PNG_SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+var CRC_TABLE = makeCrcTable();
+var MAX_IMAGE_BYTES = 48 * 1024 * 1024;
+var KITTY_CHUNK_SIZE = 4096;
+var PANEL_BLUR_SCALE = 1;
+var PANEL_MASK_CACHE_LIMIT = 16;
+var ZLIB_LEVEL = 1;
+var LOAD_BUCKETS = 5;
+function loadBucket(load) {
+  if (!Number.isFinite(load ?? NaN))
+    return 0;
+  return Math.max(0, Math.min(LOAD_BUCKETS, Math.round((load ?? 0) * LOAD_BUCKETS)));
+}
+var panelMaskCache = new Map;
+var BG_WORD = rgbaWord(BG);
+function imageTransport() {
+  const forced = process.env.RIG_OPENTUI_IMAGE_TRANSPORT;
+  if (forced === "rgba-zlib")
+    return "rgba-zlib";
+  return "png";
+}
+function rgbaWord(color) {
+  return (color[3] << 24 | color[2] << 16 | color[1] << 8 | color[0]) >>> 0;
+}
+function fillRgba(data, color, word = rgbaWord(color)) {
+  if (data.byteOffset % 4 === 0 && data.byteLength % 4 === 0) {
+    new Uint32Array(data.buffer, data.byteOffset, data.byteLength / 4).fill(word);
+    return;
+  }
+  for (let i = 0;i < data.length; i += 4) {
+    data[i] = color[0];
+    data[i + 1] = color[1];
+    data[i + 2] = color[2];
+    data[i + 3] = color[3];
+  }
+}
+var ASCII_GLYPHS = {
+  ".": ["00000", "00000", "00000", "00000", "00000", "00100", "00100"],
+  "'": ["00100", "00100", "00000", "00000", "00000", "00000", "00000"],
+  "-": ["00000", "00000", "00000", "11111", "00000", "00000", "00000"],
+  _: ["00000", "00000", "00000", "00000", "00000", "00000", "11111"],
+  "=": ["00000", "11111", "00000", "00000", "11111", "00000", "00000"],
+  "|": ["00100", "00100", "00100", "00100", "00100", "00100", "00100"],
+  "/": ["00001", "00010", "00010", "00100", "01000", "01000", "10000"],
+  "\\": ["10000", "01000", "01000", "00100", "00010", "00010", "00001"],
+  "(": ["00010", "00100", "01000", "01000", "01000", "00100", "00010"],
+  ")": ["01000", "00100", "00010", "00010", "00010", "00100", "01000"],
+  "!": ["00100", "00100", "00100", "00100", "00100", "00000", "00100"],
+  "%": ["11001", "11010", "00100", "01000", "10110", "00110", "00000"],
+  $: ["00100", "11110", "10100", "11110", "00101", "11110", "00100"],
+  "@": ["01110", "10001", "10111", "10101", "10111", "10000", "01111"],
+  o: ["00000", "01110", "10001", "10001", "10001", "01110", "00000"],
+  "*": ["00100", "10101", "01110", "11111", "01110", "10101", "00100"]
+};
+function sceneStaticTick(scene) {
+  let hash = 0;
+  for (let index = 0;index < scene.length; index += 1)
+    hash = hash * 33 + scene.charCodeAt(index) >>> 0;
+  return 11 + hash % 97;
+}
+function charColor(char, row, totalRows) {
+  if (char === "@" || char === "$" || char === "o")
+    return LIME;
+  if (char === "%" || char === "!" || char === "/" || char === "\\" || char === "|")
+    return CYAN;
+  if (char === "." || char === "'" || char === "_" || row < 3 || row > totalRows - 4)
+    return INK_DIM;
+  if (char === "-" || char === "=" || char === "(" || char === ")")
+    return LIME_DIM;
+  return MAGENTA;
+}
+function fillRectAlpha(data, width, height, left, top, rectWidth, rectHeight, color, alpha) {
+  const x0 = Math.max(0, Math.floor(left));
+  const y0 = Math.max(0, Math.floor(top));
+  const x1 = Math.min(width, Math.ceil(left + rectWidth));
+  const y1 = Math.min(height, Math.ceil(top + rectHeight));
+  for (let y = y0;y < y1; y += 1) {
+    for (let x = x0;x < x1; x += 1)
+      blendOver(data, (y * width + x) * 4, color, alpha);
+  }
+}
+function drawAsciiGlyph(data, width, height, x, y, cellWidth, cellHeight, char, color, alpha) {
+  const pattern = ASCII_GLYPHS[char] ?? ASCII_GLYPHS["*"];
+  const glyphWidth = Math.max(1, cellWidth * 0.56);
+  const glyphHeight = Math.max(1, cellHeight * 0.7);
+  const originX = x + (cellWidth - glyphWidth) * 0.5;
+  const originY = y + (cellHeight - glyphHeight) * 0.5;
+  const pixelWidth = Math.max(1, glyphWidth / pattern[0].length);
+  const pixelHeight = Math.max(1, glyphHeight / pattern.length);
+  for (let row = 0;row < pattern.length; row += 1) {
+    const bits = pattern[row];
+    for (let col = 0;col < bits.length; col += 1) {
+      if (bits[col] !== "1")
+        continue;
+      fillRectAlpha(data, width, height, originX + col * pixelWidth, originY + row * pixelHeight, pixelWidth * 0.72, pixelHeight * 0.72, color, alpha);
+    }
+  }
+}
+function drawStaticAsciiFleetBackground(data, width, height, scene, layout, load, activeRuns) {
+  const rows = fleetRows(sceneStaticTick(scene), { animate: true });
+  const cellWidth = width / Math.max(1, layout.width);
+  const cellHeight = height / Math.max(1, layout.height);
+  const sideBySide = layout.width >= FLEET_GRID_WIDTH * 1.9;
+  const leftCells = sideBySide ? Math.max(1, Math.floor(layout.width * 0.3 - FLEET_GRID_WIDTH / 2)) : Math.floor((layout.width - FLEET_GRID_WIDTH) / 2);
+  const topCells = Math.floor((layout.height - FLEET_GRID_HEIGHT) / 2);
+  const fleetLeft = leftCells * cellWidth;
+  const fleetTop = topCells * cellHeight;
+  drawGlow2(data, width, height, width * 0.5, height * 0.5, Math.min(width, height) * 0.4, LIME, 0.022 + load * 0.03);
+  drawGlow2(data, width, height, width * 0.18, height * 0.22, Math.min(width, height) * 0.28, CYAN, 0.018 + load * 0.012);
+  drawGlow2(data, width, height, width * 0.82, height * 0.78, Math.min(width, height) * 0.22, MAGENTA, 0.012 + load * 0.008);
+  let droneTotal = 0;
+  for (const line2 of rows)
+    for (const char of line2)
+      if (char === "@" || char === "$" || char === "%")
+        droneTotal += 1;
+  const litTarget = Math.max(0, Math.min(droneTotal, activeRuns));
+  let droneIndex = 0;
+  for (let row = 0;row < rows.length; row += 1) {
+    const line2 = rows[row];
+    for (let col = 0;col < line2.length; col += 1) {
+      const char = line2[col];
+      if (char === " ")
+        continue;
+      const x = fleetLeft + col * cellWidth;
+      const y = fleetTop + row * cellHeight;
+      const color = charColor(char, row, rows.length);
+      const isDrone = char === "@" || char === "$" || char === "%";
+      const lit = isDrone && droneIndex < litTarget;
+      drawAsciiGlyph(data, width, height, x + cellWidth * 0.07, y + cellHeight * 0.05, cellWidth, cellHeight, char, color, lit ? 0.72 : 0.46);
+      if (isDrone) {
+        droneIndex += 1;
+        drawGlow2(data, width, height, x + cellWidth * 0.5, y + cellHeight * 0.5, Math.max(cellWidth, cellHeight) * 0.95, color, lit ? 0.044 : 0.014);
+      }
+    }
+  }
+}
+function applyStaticAtmosphere(data, width, height, load) {
+  const cx = width * 0.5;
+  const cy = height * 0.42;
+  const radius = Math.max(width, height) * 0.78;
+  const minVignette = 0.1 - load * 0.02;
+  for (let y = 0;y < height; y += 1) {
+    for (let x = 0;x < width; x += 1) {
+      const distance = Math.hypot(x - cx, y - cy) / radius;
+      const alpha = Math.max(minVignette, Math.min(0.82, 0.12 + Math.pow(distance, 1.65) * 0.62));
+      blendOver(data, (y * width + x) * 4, BG, alpha);
+    }
+  }
+  drawGlow2(data, width, height, width * 0.82, height * 0.04, Math.min(width, height) * 0.2, LIME, 0.024 + load * 0.012);
+  drawGlow2(data, width, height, width * 0.12, height * 0.18, Math.min(width, height) * 0.16, CYAN, 0.018 + load * 0.008);
+}
+function makeCrcTable() {
+  const table = new Uint32Array(256);
+  for (let n = 0;n < 256; n += 1) {
+    let c = n;
+    for (let k = 0;k < 8; k += 1)
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+}
+function crc32(bytes) {
+  let c = 4294967295;
+  for (let i = 0;i < bytes.length; i += 1)
+    c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function chunk(type, data) {
+  const out = new Uint8Array(12 + data.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, data.length);
+  out[4] = type.charCodeAt(0);
+  out[5] = type.charCodeAt(1);
+  out[6] = type.charCodeAt(2);
+  out[7] = type.charCodeAt(3);
+  out.set(data, 8);
+  view.setUint32(8 + data.length, crc32(out.subarray(4, 8 + data.length)));
+  return out;
+}
+function encodePng(width, height, rgba) {
+  const ihdr = new Uint8Array(13);
+  const ihdrView = new DataView(ihdr.buffer);
+  ihdrView.setUint32(0, width);
+  ihdrView.setUint32(4, height);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  const stride = width * 4;
+  const raw = new Uint8Array((stride + 1) * height);
+  for (let y = 0;y < height; y += 1) {
+    const rawOffset = y * (stride + 1);
+    raw[rawOffset] = 0;
+    raw.set(rgba.subarray(y * stride, y * stride + stride), rawOffset + 1);
+  }
+  const compressed = deflateSync(raw, { level: ZLIB_LEVEL });
+  return Buffer.concat([
+    Buffer.from(PNG_SIGNATURE),
+    Buffer.from(chunk("IHDR", ihdr)),
+    Buffer.from(chunk("IDAT", compressed)),
+    Buffer.from(chunk("IEND", new Uint8Array(0)))
+  ]);
+}
+function kittyImageSequence(base64, options) {
+  const params = [`a=T`, `f=${options.format}`, `q=2`, `C=1`, `c=${options.columns}`, `r=${options.rows}`, `i=${options.imageId}`, `z=${options.zIndex}`];
+  if (options.format === 32) {
+    params.push(`s=${options.pixelWidth ?? 1}`, `v=${options.pixelHeight ?? 1}`);
+    if (options.compressed)
+      params.push("o=z");
+  }
+  if (base64.length <= KITTY_CHUNK_SIZE)
+    return `\x1B_G${params.join(",")};${base64}\x1B\\`;
+  const chunks = [];
+  for (let offset = 0;offset < base64.length; offset += KITTY_CHUNK_SIZE) {
+    const part = base64.slice(offset, offset + KITTY_CHUNK_SIZE);
+    const last = offset + KITTY_CHUNK_SIZE >= base64.length;
+    chunks.push(`\x1B_G${offset === 0 ? `${params.join(",")},` : ""}m=${last ? 0 : 1};${part}\x1B\\`);
+  }
+  return chunks.join("");
+}
+function clampByte(value) {
+  return Math.max(0, Math.min(255, Math.round(value)));
+}
+function blendOver(data, index, color, alphaScale = 1) {
+  const alpha = color[3] / 255 * alphaScale;
+  const inv = 1 - alpha;
+  data[index] = clampByte(color[0] * alpha + data[index] * inv);
+  data[index + 1] = clampByte(color[1] * alpha + data[index + 1] * inv);
+  data[index + 2] = clampByte(color[2] * alpha + data[index + 2] * inv);
+  data[index + 3] = 255;
+}
+function drawDisc(data, width, height, cx, cy, radius, color, alpha = 1) {
+  const minX = Math.max(0, Math.floor(cx - radius));
+  const maxX = Math.min(width - 1, Math.ceil(cx + radius));
+  const minY = Math.max(0, Math.floor(cy - radius));
+  const maxY = Math.min(height - 1, Math.ceil(cy + radius));
+  for (let y = minY;y <= maxY; y += 1) {
+    for (let x = minX;x <= maxX; x += 1) {
+      const dx = x + 0.5 - cx;
+      const dy = y + 0.5 - cy;
+      const d = Math.sqrt(dx * dx + dy * dy);
+      if (d > radius)
+        continue;
+      const edge = Math.max(0, Math.min(1, radius - d));
+      blendOver(data, (y * width + x) * 4, color, alpha * Math.min(1, 0.35 + edge));
+    }
+  }
+}
+function drawGlow2(data, width, height, cx, cy, radius, color, alpha = 0.18) {
+  const minX = Math.max(0, Math.floor(cx - radius));
+  const maxX = Math.min(width - 1, Math.ceil(cx + radius));
+  const minY = Math.max(0, Math.floor(cy - radius));
+  const maxY = Math.min(height - 1, Math.ceil(cy + radius));
+  for (let y = minY;y <= maxY; y += 1) {
+    for (let x = minX;x <= maxX; x += 1) {
+      const dx = x + 0.5 - cx;
+      const dy = y + 0.5 - cy;
+      const d = Math.sqrt(dx * dx + dy * dy);
+      if (d > radius)
+        continue;
+      const falloff = Math.pow(1 - d / Math.max(1, radius), GLOW_FALLOFF_EXP_IMAGE);
+      blendOver(data, (y * width + x) * 4, color, alpha * falloff);
+    }
+  }
+}
+function drawLine2(data, width, height, x0, y0, x1, y1, color, alpha = 0.5, thickness = 1.4) {
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const steps = Math.max(1, Math.ceil(Math.hypot(dx, dy) * 1.2));
+  for (let i = 0;i <= steps; i += 1) {
+    const t2 = i / steps;
+    drawDisc(data, width, height, x0 + dx * t2, y0 + dy * t2, thickness, color, alpha);
+  }
+}
+function roundRectAlpha(px, py, x, y, w, h, r) {
+  const rx = Math.max(x + r, Math.min(px, x + w - r));
+  const ry = Math.max(y + r, Math.min(py, y + h - r));
+  const dx = px - rx;
+  const dy = py - ry;
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  return Math.max(0, Math.min(1, r + 0.75 - dist));
+}
+function panelRect(layout, panel, size) {
+  return panelPixelPlacement(layout, panel, size);
+}
+function downsampleRegion(data, canvasW, canvasH, rect, scale) {
+  const w = Math.max(1, Math.ceil(rect.width / scale));
+  const h = Math.max(1, Math.ceil(rect.height / scale));
+  const out = new Uint8ClampedArray(w * h * 3);
+  for (let y = 0;y < h; y += 1) {
+    for (let x = 0;x < w; x += 1) {
+      let r = 0, g = 0, b = 0, count = 0;
+      const sx0 = rect.left + x * scale;
+      const sy0 = rect.top + y * scale;
+      for (let yy = 0;yy < scale; yy += 1) {
+        const sy = sy0 + yy;
+        if (sy < 0 || sy >= canvasH)
+          continue;
+        for (let xx = 0;xx < scale; xx += 1) {
+          const sx = sx0 + xx;
+          if (sx < 0 || sx >= canvasW)
+            continue;
+          const i = (sy * canvasW + sx) * 4;
+          r += data[i];
+          g += data[i + 1];
+          b += data[i + 2];
+          count += 1;
+        }
+      }
+      const oi = (y * w + x) * 3;
+      out[oi] = count ? r / count : BG[0];
+      out[oi + 1] = count ? g / count : BG[1];
+      out[oi + 2] = count ? b / count : BG[2];
+    }
+  }
+  return { pixels: out, width: w, height: h };
+}
+function blurRgb(buffer, width, height, radius) {
+  const tmp = new Uint8ClampedArray(buffer.length);
+  const out = new Uint8ClampedArray(buffer.length);
+  const window = radius * 2 + 1;
+  for (let y = 0;y < height; y += 1) {
+    let r = 0, g = 0, b = 0;
+    for (let x = -radius;x <= radius; x += 1) {
+      const sx = Math.max(0, Math.min(width - 1, x));
+      const i = (y * width + sx) * 3;
+      r += buffer[i];
+      g += buffer[i + 1];
+      b += buffer[i + 2];
+    }
+    for (let x = 0;x < width; x += 1) {
+      const oi = (y * width + x) * 3;
+      tmp[oi] = r / window;
+      tmp[oi + 1] = g / window;
+      tmp[oi + 2] = b / window;
+      const removeX = Math.max(0, x - radius);
+      const addX = Math.min(width - 1, x + radius + 1);
+      const ri = (y * width + removeX) * 3;
+      const ai = (y * width + addX) * 3;
+      r += tmp.length ? buffer[ai] - buffer[ri] : 0;
+      g += tmp.length ? buffer[ai + 1] - buffer[ri + 1] : 0;
+      b += tmp.length ? buffer[ai + 2] - buffer[ri + 2] : 0;
+    }
+  }
+  for (let x = 0;x < width; x += 1) {
+    let r = 0, g = 0, b = 0;
+    for (let y = -radius;y <= radius; y += 1) {
+      const sy = Math.max(0, Math.min(height - 1, y));
+      const i = (sy * width + x) * 3;
+      r += tmp[i];
+      g += tmp[i + 1];
+      b += tmp[i + 2];
+    }
+    for (let y = 0;y < height; y += 1) {
+      const oi = (y * width + x) * 3;
+      out[oi] = r / window;
+      out[oi + 1] = g / window;
+      out[oi + 2] = b / window;
+      const removeY = Math.max(0, y - radius);
+      const addY = Math.min(height - 1, y + radius + 1);
+      const ri = (removeY * width + x) * 3;
+      const ai = (addY * width + x) * 3;
+      r += tmp[ai] - tmp[ri];
+      g += tmp[ai + 1] - tmp[ri + 1];
+      b += tmp[ai + 2] - tmp[ri + 2];
+    }
+  }
+  return out;
+}
+function panelMaskKey(width, height, rect, headerPx, blurScale) {
+  return `${width}x${height}:${rect.left},${rect.top},${rect.width},${rect.height}:${Math.round(headerPx * 100) / 100}:${blurScale}`;
+}
+function getPanelMask(width, height, rect, headerPx, blurScale) {
+  const key = panelMaskKey(width, height, rect, headerPx, blurScale);
+  const cached = panelMaskCache.get(key);
+  if (cached)
+    return cached;
+  const radius = Math.max(PANEL_MASK_RADIUS_MIN, Math.min(PANEL_MASK_RADIUS_MAX, Math.round(Math.min(rect.width, rect.height) * PANEL_MASK_RADIUS_FACTOR)));
+  const sampledWidth = Math.max(1, Math.ceil(rect.width / blurScale));
+  const sampledHeight = Math.max(1, Math.ceil(rect.height / blurScale));
+  const x0 = Math.max(0, rect.left);
+  const y0 = Math.max(0, rect.top);
+  const x1 = Math.min(width - 1, rect.left + rect.width - 1);
+  const y1 = Math.min(height - 1, rect.top + rect.height - 1);
+  const indices = [];
+  const sampleIndices = [];
+  const panelAlpha = [];
+  const edgeAlpha = [];
+  const headerFlags = [];
+  const dividerIndices = [];
+  for (let y = y0;y <= y1; y += 1) {
+    for (let x = x0;x <= x1; x += 1) {
+      const a = roundRectAlpha(x + 0.5, y + 0.5, rect.left, rect.top, rect.width, rect.height, radius);
+      if (a <= 0)
+        continue;
+      const edge = roundRectAlpha(x + 0.5, y + 0.5, rect.left + 1.2, rect.top + 1.2, rect.width - 2.4, rect.height - 2.4, Math.max(1, radius - 1.2));
+      const sx = Math.max(0, Math.min(sampledWidth - 1, Math.floor((x - rect.left) / blurScale)));
+      const sy = Math.max(0, Math.min(sampledHeight - 1, Math.floor((y - rect.top) / blurScale)));
+      indices.push((y * width + x) * 4);
+      sampleIndices.push((sy * sampledWidth + sx) * 3);
+      panelAlpha.push(a);
+      edgeAlpha.push(edge < 0.96 ? Math.min(1, (1 - edge) * 0.7) : 0);
+      headerFlags.push(y < rect.top + headerPx ? 1 : 0);
+    }
+  }
+  const dividerY = Math.round(rect.top + headerPx);
+  if (dividerY > y0 && dividerY < y1) {
+    for (let x = x0 + radius;x <= x1 - radius; x += 1) {
+      dividerIndices.push((dividerY * width + x) * 4);
+    }
+  }
+  const mask = {
+    key,
+    indices: Uint32Array.from(indices),
+    sampleIndices: Uint32Array.from(sampleIndices),
+    panelAlpha: Float32Array.from(panelAlpha),
+    edgeAlpha: Float32Array.from(edgeAlpha),
+    headerFlags: Uint8Array.from(headerFlags),
+    dividerIndices: Uint32Array.from(dividerIndices)
+  };
+  panelMaskCache.set(key, mask);
+  while (panelMaskCache.size > PANEL_MASK_CACHE_LIMIT) {
+    const oldest = panelMaskCache.keys().next().value;
+    if (!oldest)
+      break;
+    panelMaskCache.delete(oldest);
+  }
+  return mask;
+}
+function compositePanel(data, width, height, rect, headerPx) {
+  const blurScale = PANEL_BLUR_SCALE;
+  const sampled = downsampleRegion(data, width, height, rect, blurScale);
+  const blurRadius = Math.max(PANEL_BLUR_RADIUS_MIN, Math.min(PANEL_BLUR_RADIUS_MAX, Math.round(Math.min(rect.width, rect.height) * PANEL_BLUR_RADIUS_FACTOR)));
+  const blurred = blurRgb(sampled.pixels, sampled.width, sampled.height, blurRadius);
+  const mask = getPanelMask(width, height, rect, headerPx, blurScale);
+  for (let i = 0;i < mask.indices.length; i += 1) {
+    const idx = mask.indices[i];
+    const sampleIdx = mask.sampleIndices[i];
+    data[idx] = blurred[sampleIdx];
+    data[idx + 1] = blurred[sampleIdx + 1];
+    data[idx + 2] = blurred[sampleIdx + 2];
+    data[idx + 3] = 255;
+    blendOver(data, idx, mask.headerFlags[i] ? PANEL_HEADER : PANEL, mask.panelAlpha[i]);
+    const edge = mask.edgeAlpha[i];
+    if (edge > 0)
+      blendOver(data, idx, PANEL_LINE2, edge);
+  }
+  for (let i = 0;i < mask.dividerIndices.length; i += 1) {
+    blendOver(data, mask.dividerIndices[i], PANEL_LINE2, 0.28);
+  }
+}
+var RIG_GLYPH_STROKES = {
+  R: [[0, 0, 0, 1], [0, 0, 0.82, 0], [0.82, 0, 0.82, 0.5], [0, 0.5, 0.82, 0.5], [0.36, 0.5, 0.92, 1]],
+  I: [[0.5, 0, 0.5, 1], [0.18, 0, 0.82, 0], [0.18, 1, 0.82, 1]],
+  G: [[0.92, 0.08, 0.12, 0], [0.12, 0, 0.12, 1], [0.12, 1, 0.92, 1], [0.92, 0.5, 0.92, 1], [0.5, 0.5, 0.92, 0.5]]
+};
+function drawBigRigWordmark(data, width, height, layout, load) {
+  const sideBySide = layout.width >= FLEET_GRID_WIDTH * 1.9;
+  if (!sideBySide)
+    return;
+  const letters = "RIG";
+  const min = Math.min(width, height);
+  const glyphH = height * 0.42;
+  const glyphW = width * 0.13;
+  const gap = glyphW * 0.3;
+  const totalW = letters.length * glyphW + (letters.length - 1) * gap;
+  const centerX = width * 0.71;
+  const startX = centerX - totalW / 2;
+  const top = (height - glyphH) / 2;
+  const stroke = Math.max(2, min * 0.013);
+  drawGlow2(data, width, height, centerX, top + glyphH / 2, Math.max(glyphW, glyphH) * 0.9, LIME, 0.022 + load * 0.02);
+  const strokeAlpha = 0.1 + load * 0.06;
+  letters.split("").forEach((letter, index) => {
+    const segments = RIG_GLYPH_STROKES[letter];
+    if (!segments)
+      return;
+    const ox = startX + index * (glyphW + gap);
+    for (const [x0, y0, x1, y1] of segments) {
+      drawLine2(data, width, height, ox + x0 * glyphW, top + y0 * glyphH, ox + x1 * glyphW, top + y1 * glyphH, LIME_DIM, strokeAlpha, stroke);
+    }
+  });
+}
+function drawBackground(data, width, height, _tick, scene, layout, load, activeRuns) {
+  fillRgba(data, BG, BG_WORD);
+  drawStaticAsciiFleetBackground(data, width, height, scene, layout, load, activeRuns);
+  drawBigRigWordmark(data, width, height, layout, load);
+  applyStaticAtmosphere(data, width, height, load);
+}
+function imageVisualFrameKey(input) {
+  const width = Math.max(1, Math.floor(input.pixelSize.width));
+  const height = Math.max(1, Math.floor(input.pixelSize.height));
+  const layer = "layer" in input ? input.layer ?? "full" : "full";
+  const load = loadBucket(input.load);
+  return `${layer}:${width}x${height}:${input.layout.width}x${input.layout.height}:${input.scene}:${input.tick}:l${load}:${input.panels.map((panel) => `${panel.id}:${panel.top}:${panel.height}:${panel.width ?? ""}:${panel.left ?? ""}:${panel.headerHeight ?? ""}`).join("|")}`;
+}
+function encodeKittyFrame(width, height, data, input) {
+  if (input.transport === "png") {
+    const png = encodePng(width, height, data);
+    return kittyImageSequence(png.toString("base64"), { columns: input.layout.width, rows: input.layout.height, imageId: input.imageId, zIndex: input.zIndex, format: 100 });
+  }
+  const compressed = deflateSync(data, { level: ZLIB_LEVEL });
+  return kittyImageSequence(compressed.toString("base64"), {
+    columns: input.layout.width,
+    rows: input.layout.height,
+    imageId: input.imageId,
+    zIndex: input.zIndex,
+    format: 32,
+    pixelWidth: width,
+    pixelHeight: height,
+    compressed: true
+  });
+}
+function cropRgba(data, sourceWidth, rect) {
+  const out = new Uint8ClampedArray(rect.width * rect.height * 4);
+  for (let y = 0;y < rect.height; y += 1) {
+    const sourceStart = ((rect.top + y) * sourceWidth + rect.left) * 4;
+    out.set(data.subarray(sourceStart, sourceStart + rect.width * 4), y * rect.width * 4);
+  }
+  return out;
+}
+function encodePanelPatch(data, sourceWidth, placement, imageId, zIndex) {
+  const patch = cropRgba(data, sourceWidth, placement);
+  const png = encodePng(placement.width, placement.height, patch);
+  const sequence = kittyImageSequence(png.toString("base64"), {
+    columns: Math.max(1, Math.round(placement.widthCells)),
+    rows: Math.max(1, Math.round(placement.heightCells)),
+    imageId,
+    zIndex,
+    format: 100
+  });
+  return `\x1B[${Math.max(1, Math.round(placement.topCells) + 1)};${Math.max(1, Math.round(placement.leftCells) + 1)}H${sequence}`;
+}
+function renderImageVisualFrame(input) {
+  const width = Math.max(1, Math.floor(input.pixelSize.width));
+  const height = Math.max(1, Math.floor(input.pixelSize.height));
+  const byteCount = width * height * 4;
+  if (byteCount > MAX_IMAGE_BYTES)
+    return null;
+  const layer = input.layer ?? "full";
+  const data = new Uint8ClampedArray(byteCount);
+  const load = loadBucket(input.load) / LOAD_BUCKETS;
+  const activeRuns = Math.max(0, Math.floor(input.activeRuns ?? 0));
+  drawBackground(data, width, height, 0, input.scene, input.layout, load, activeRuns);
+  if (layer === "split") {
+    const sequences = [encodeKittyFrame(width, height, data, input)];
+    let panelIndex = 0;
+    for (const panel of input.panels) {
+      if (panel.chrome !== "ad-terminal")
+        continue;
+      const placement = panelPixelPlacement(input.layout, panel, { width, height });
+      if (!placement)
+        continue;
+      const cellH = height / input.layout.height;
+      const headerPx = Math.max(cellH * 3, (panel.headerHeight ?? 3) * cellH);
+      compositePanel(data, width, height, placement, headerPx);
+      const imageId = input.imageIds?.[panelIndex] ?? (input.imageId + 1000 + panelIndex >>> 0 || panelIndex + 1);
+      sequences.push(encodePanelPatch(data, width, placement, imageId, -12));
+      panelIndex += 1;
+    }
+    return { key: imageVisualFrameKey(input), sequence: sequences.join("") };
+  }
+  if (layer === "panel-chrome")
+    return { key: imageVisualFrameKey(input), sequence: "" };
+  if (layer === "background") {
+    return { key: imageVisualFrameKey(input), sequence: encodeKittyFrame(width, height, data, input) };
+  }
+  if (layer === "panel-patches") {
+    const sequences = [];
+    let panelIndex = 0;
+    for (const panel of input.panels) {
+      if (panel.chrome !== "ad-terminal")
+        continue;
+      const placement = panelPixelPlacement(input.layout, panel, { width, height });
+      if (!placement)
+        continue;
+      const cellH = height / input.layout.height;
+      const headerPx = Math.max(cellH * 3, (panel.headerHeight ?? 3) * cellH);
+      compositePanel(data, width, height, placement, headerPx);
+      const imageId = input.imageIds?.[panelIndex] ?? (input.imageId + 1000 + panelIndex >>> 0 || panelIndex + 1);
+      sequences.push(encodePanelPatch(data, width, placement, imageId, input.zIndex));
+      panelIndex += 1;
+    }
+    return { key: imageVisualFrameKey(input), sequence: sequences.join("") };
+  }
+  for (const panel of input.panels) {
+    if (panel.chrome !== "ad-terminal")
+      continue;
+    const rect = panelRect(input.layout, panel, { width, height });
+    if (!rect)
+      continue;
+    const cellH = height / input.layout.height;
+    const headerPx = Math.max(cellH * 3, (panel.headerHeight ?? 3) * cellH);
+    compositePanel(data, width, height, rect, headerPx);
+  }
+  return { key: imageVisualFrameKey(input), sequence: encodeKittyFrame(width, height, data, input) };
+}
+function shouldRenderImagesInline() {
+  return process.env.RIG_OPENTUI_IMAGE_WORKER === "0" || import.meta.url.includes("$bunfs");
+}
+function createImageWorker() {
+  if (shouldRenderImagesInline())
+    return null;
+  const isTypeScriptRuntime = import.meta.url.endsWith(".ts");
+  const workerUrl = new URL(isTypeScriptRuntime ? "./image-visual-layer-worker.ts" : "./image-visual-layer-worker.js", import.meta.url);
+  try {
+    return new Worker(workerUrl);
+  } catch {
+    if (typeof process.versions.bun === "string") {
+      try {
+        return new Worker("./src/app-opentui/render/image-visual-layer-worker.ts");
+      } catch {}
+    }
+    return null;
+  }
+}
+var RECENT_WRITTEN_LIMIT = 24;
+var DEFAULT_IMAGE_OUTPUT_BACKLOG_BYTES = 256 * 1024;
+var DEFAULT_IMAGE_OUTPUT_BYTES_PER_SECOND = 850 * 1024;
+function imageOutputBacklogBytes() {
+  const raw = Number.parseInt(process.env.RIG_OPENTUI_IMAGE_BACKLOG_BYTES ?? "", 10);
+  if (Number.isFinite(raw) && raw > 0)
+    return Math.max(64 * 1024, Math.min(2 * 1024 * 1024, raw));
+  return DEFAULT_IMAGE_OUTPUT_BACKLOG_BYTES;
+}
+function imageOutputBytesPerSecond() {
+  const raw = Number.parseInt(process.env.RIG_OPENTUI_IMAGE_BYTES_PER_SECOND ?? "", 10);
+  if (Number.isFinite(raw) && raw > 0)
+    return Math.max(128 * 1024, Math.min(2 * 1024 * 1024, raw));
+  return DEFAULT_IMAGE_OUTPUT_BYTES_PER_SECOND;
+}
+function pendingLayerKey(key) {
+  return key.split(":", 1)[0] || "full";
+}
+
+class ImageVisualLayer {
+  imageId = allocateImageId();
+  panelImageIds = Array.from({ length: 8 }, () => allocateImageId());
+  panelChromeImageIds = Array.from({ length: 8 }, () => allocateImageId());
+  stdout;
+  onFrameReady;
+  protocol;
+  transport = imageTransport();
+  maxOutputBacklogBytes = imageOutputBacklogBytes();
+  outputBytesPerSecond = imageOutputBytesPerSecond();
+  outputBudgetBytes = imageOutputBytesPerSecond();
+  lastBudgetAtMs = Date.now();
+  motionSlot = this.createSlot();
+  workersStarted = false;
+  pendingFrames = new Map;
+  recentWrittenKeys = [];
+  imagesVisible = false;
+  flushPaused = false;
+  requestId = 0;
+  lastBackgroundKey = "";
+  fatalWorkerError = null;
+  destroyed = false;
+  constructor(stdout = process.stdout, onFrameReady) {
+    this.stdout = stdout;
+    this.onFrameReady = onFrameReady;
+    this.protocol = getRigTerminalCapabilities().imageProtocol;
+  }
+  get enabled() {
+    return this.protocol === "kitty";
+  }
+  clear() {
+    if (this.enabled) {
+      if (this.imagesVisible)
+        this.stdout.write([this.imageId, ...this.panelImageIds, ...this.panelChromeImageIds].map((id) => deleteKittyImage(id)).join("") + "\x1B[?25h");
+      this.imagesVisible = false;
+      this.pendingFrames.clear();
+      this.recentWrittenKeys.length = 0;
+      this.resetSlot(this.motionSlot);
+      this.lastBackgroundKey = "";
+      this.outputBudgetBytes = this.outputBytesPerSecond;
+      this.lastBudgetAtMs = Date.now();
+      this.motionSlot.clearedThroughRequestId = this.requestId;
+    }
+  }
+  destroy() {
+    if (this.destroyed)
+      return;
+    this.clear();
+    this.destroyed = true;
+    const workers = [this.motionSlot.worker];
+    this.motionSlot.worker = null;
+    for (const worker of workers)
+      if (worker)
+        worker.terminate().catch(() => {
+          return;
+        });
+  }
+  setFlushPaused(paused) {
+    this.flushPaused = paused;
+  }
+  isReady(input) {
+    if (!this.enabled || this.destroyed)
+      return true;
+    this.throwIfFatal();
+    const splitKey = imageVisualFrameKey({ ...input, tick: 0, layer: "split" });
+    return this.recentWrittenKeys.includes(splitKey) || Array.from(this.pendingFrames.values()).some((frame) => frame.key === splitKey);
+  }
+  render(input) {
+    if (!this.enabled || this.destroyed)
+      return;
+    this.throwIfFatal();
+    if (this.transport !== "png")
+      this.failWorker("renderer", new Error("OpenTUI image visuals require PNG transport for static-background rendering."));
+    this.ensureWorkersStarted();
+    const width = Math.max(1, Math.floor(input.pixelSize.width));
+    const height = Math.max(1, Math.floor(input.pixelSize.height));
+    if (width * height * 4 > MAX_IMAGE_BYTES)
+      return;
+    if (this.isOutputBackedUp())
+      return;
+    this.refillOutputBudget();
+    const splitInput = { ...input, tick: 0, layer: "split" };
+    const splitKey = imageVisualFrameKey(splitInput);
+    if (input.force || splitKey !== this.lastBackgroundKey) {
+      this.scheduleRender(this.motionSlot, splitInput, this.imageId, -30, input.force, this.panelImageIds);
+      this.lastBackgroundKey = splitKey;
+    }
+  }
+  flush() {
+    this.throwIfFatal();
+    if (this.flushPaused)
+      return false;
+    if (this.pendingFrames.size === 0)
+      return false;
+    this.refillOutputBudget();
+    if (this.isOutputBackedUp()) {
+      const retainedSplit = this.pendingFrames.get("split");
+      this.pendingFrames.clear();
+      if (retainedSplit)
+        this.pendingFrames.set("split", retainedSplit);
+      return false;
+    }
+    const framePriority = (frame) => {
+      const layer = pendingLayerKey(frame.key);
+      if (layer === "split")
+        return 1;
+      return 4;
+    };
+    const frames = Array.from(this.pendingFrames.values()).sort((a, b) => framePriority(a) - framePriority(b));
+    const prefix = "\x1B[?25l\x1B7\x1B[s\x1B[H";
+    const suffix = "\x1B[u\x1B8";
+    const selected = [];
+    const retained = new Map;
+    let sequence = "";
+    let byteLength = Buffer.byteLength(prefix + suffix);
+    for (const frame of frames) {
+      const candidate = sequence + frame.sequence;
+      const candidateBytes = Buffer.byteLength(prefix + candidate + suffix);
+      const layer = pendingLayerKey(frame.key);
+      const allowOneStaticFrame = selected.length === 0 && layer === "split";
+      if (candidateBytes <= this.outputBudgetBytes || allowOneStaticFrame) {
+        selected.push(frame);
+        sequence = candidate;
+        byteLength = candidateBytes;
+      } else if (layer === "split") {
+        retained.set(layer, frame);
+      }
+    }
+    this.pendingFrames.clear();
+    for (const [layer, frame] of retained)
+      this.pendingFrames.set(layer, frame);
+    if (!sequence || selected.length === 0)
+      return false;
+    const payload = `${prefix}${sequence}${suffix}`;
+    for (const frame of selected)
+      this.markWritten(frame.key);
+    this.outputBudgetBytes -= byteLength;
+    this.stdout.cork?.();
+    const accepted = this.stdout.write(payload);
+    this.stdout.uncork?.();
+    this.imagesVisible = true;
+    return accepted;
+  }
+  createSlot() {
+    return { worker: null, busy: false, queuedRequest: null, inFlightKey: "", queuedKey: "", clearedThroughRequestId: 0, latestRequestId: 0 };
+  }
+  resetSlot(slot) {
+    slot.busy = false;
+    slot.queuedRequest = null;
+    slot.inFlightKey = "";
+    slot.queuedKey = "";
+  }
+  markWritten(key) {
+    this.recentWrittenKeys.push(key);
+    while (this.recentWrittenKeys.length > RECENT_WRITTEN_LIMIT)
+      this.recentWrittenKeys.shift();
+  }
+  refillOutputBudget() {
+    const now = Date.now();
+    const elapsedMs = Math.max(0, now - this.lastBudgetAtMs);
+    this.lastBudgetAtMs = now;
+    this.outputBudgetBytes = Math.min(this.outputBytesPerSecond, this.outputBudgetBytes + elapsedMs / 1000 * this.outputBytesPerSecond);
+  }
+  isOutputBackedUp() {
+    return Boolean(this.stdout.writableNeedDrain) || this.stdout.writableLength > this.maxOutputBacklogBytes;
+  }
+  stageFrame(frame) {
+    this.pendingFrames.set(pendingLayerKey(frame.key), frame);
+  }
+  isKnownKey(slot, key) {
+    return this.recentWrittenKeys.includes(key) || Array.from(this.pendingFrames.values()).some((frame) => frame.key === key) || key === slot.inFlightKey || key === slot.queuedKey;
+  }
+  ensureWorkersStarted() {
+    if (this.workersStarted)
+      return;
+    this.workersStarted = true;
+    this.startWorker(this.motionSlot, "static-visuals");
+  }
+  failWorker(name, error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    this.fatalWorkerError ??= new Error(`OpenTUI image worker ${name} failed: ${detail}`);
+    throw this.fatalWorkerError;
+  }
+  throwIfFatal() {
+    if (this.fatalWorkerError)
+      throw this.fatalWorkerError;
+  }
+  scheduleRender(slot, input, imageId, zIndex, force, imageIds) {
+    this.throwIfFatal();
+    const key = imageVisualFrameKey(input);
+    if (!force && this.isKnownKey(slot, key))
+      return;
+    const request = {
+      ...input,
+      imageId,
+      ...imageIds ? { imageIds } : {},
+      zIndex,
+      transport: this.transport,
+      requestId: ++this.requestId,
+      key
+    };
+    slot.latestRequestId = request.requestId;
+    if (!slot.worker) {
+      this.renderInline(slot, request);
+      return;
+    }
+    this.enqueueWorkerRender(slot, request);
+  }
+  startWorker(slot, name) {
+    const worker = createImageWorker();
+    if (!worker)
+      return;
+    slot.worker = worker;
+    worker.on("message", (message) => this.handleWorkerMessage(slot, message));
+    worker.once("error", (error) => {
+      if (!this.destroyed)
+        this.fatalWorkerError ??= new Error(`OpenTUI image worker ${name} failed: ${error instanceof Error ? error.message : String(error)}`);
+    });
+    worker.once("exit", (code) => {
+      if (!this.destroyed)
+        this.fatalWorkerError ??= new Error(`OpenTUI image worker ${name} exited unexpectedly with code ${code}.`);
+    });
+  }
+  renderInline(slot, request) {
+    try {
+      const result = renderImageVisualFrame(request);
+      if (result?.sequence && !this.isKnownKey(slot, result.key) && (!this.isOutputBackedUp() || pendingLayerKey(result.key) === "split")) {
+        this.stageFrame({ key: result.key, sequence: result.sequence });
+        this.onFrameReady?.();
+      }
+    } catch (error) {
+      this.failWorker(String(request.layer ?? "visual"), error);
+    }
+  }
+  enqueueWorkerRender(slot, request) {
+    this.throwIfFatal();
+    if (slot.busy) {
+      slot.queuedRequest = request;
+      slot.queuedKey = request.key;
+      return;
+    }
+    this.dispatchWorkerRender(slot, request);
+  }
+  dispatchWorkerRender(slot, request) {
+    this.throwIfFatal();
+    if (!slot.worker)
+      this.failWorker(String(request.layer ?? "visual"), new Error("worker is unavailable"));
+    slot.busy = true;
+    slot.inFlightKey = request.key;
+    try {
+      slot.worker.postMessage(request);
+    } catch (error) {
+      this.failWorker(String(request.layer ?? "visual"), error);
+    }
+  }
+  handleWorkerMessage(slot, message) {
+    if (this.destroyed || !message || typeof message !== "object")
+      return;
+    const response = message;
+    slot.busy = false;
+    slot.inFlightKey = "";
+    const isStale = response.requestId <= slot.clearedThroughRequestId || response.requestId < slot.latestRequestId;
+    if (!isStale) {
+      if (response.error)
+        this.failWorker(pendingLayerKey(response.key), new Error(response.error));
+      if (response.sequence && !this.isKnownKey(slot, response.key) && (!this.isOutputBackedUp() || pendingLayerKey(response.key) === "split")) {
+        this.stageFrame({ key: response.key, sequence: response.sequence });
+        this.onFrameReady?.();
+      }
+    }
+    const next = slot.queuedRequest;
+    slot.queuedRequest = null;
+    slot.queuedKey = "";
+    if (next && !this.isKnownKey(slot, next.key))
+      this.dispatchWorkerRender(slot, next);
+  }
+}
+
+// packages/cli/src/app-opentui/render/text.ts
+import { RGBA as RGBA5, TextAttributes as TextAttributes4, TextRenderable as TextRenderable2 } from "@opentui/core";
+var TRANSPARENT2 = RGBA5.fromInts(0, 0, 0, 0);
+
+// packages/cli/src/app-opentui/render/panels.ts
+import { RGBA as RGBA6, ScrollBoxRenderable } from "@opentui/core";
+var TRANSPARENT3 = RGBA6.fromInts(0, 0, 0, 0);
+var PANEL_BORDER = hexToRgba(RIG_UI.border, 255);
+function hexToRgba(hex, alpha) {
+  const clean = hex.replace(/^#/, "");
+  const full = clean.length === 3 ? clean.split("").map((part) => `${part}${part}`).join("") : clean;
+  const value = Number.parseInt(full, 16);
+  if (!Number.isFinite(value))
+    return RGBA6.fromInts(14, 15, 17, alpha);
+  return RGBA6.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255, alpha);
+}
+
+// packages/cli/src/app-opentui/render/native-host.ts
+import {
+  BoxRenderable as BoxRenderable2,
+  CodeRenderable,
+  DiffRenderable,
+  RGBA as RGBA7,
+  ScrollBoxRenderable as ScrollBoxRenderable2,
+  SyntaxStyle,
+  TextRenderable as TextRenderable3,
+  TextTableRenderable
+} from "@opentui/core";
+
+// packages/cli/src/app-opentui/runtime.ts
+var PRELOADER_BACKDROP = RGBA8.fromHex(RIG_UI.bg);
+function inboxPendingCount(state) {
+  const inbox = state.data.inbox;
+  if (!inbox || typeof inbox !== "object" || Array.isArray(inbox))
+    return 0;
+  const record = inbox;
+  const approvals = Array.isArray(record.approvals) ? record.approvals.length : 0;
+  const inputs = Array.isArray(record.inputs) ? record.inputs.length : 0;
+  return approvals + inputs;
+}
+var PRIMARY_NAV = [
+  { id: "cockpit", label: "Cockpit", scene: "main", argv: ["main"], enterLabel: "Cockpit", member: ["main"] },
+  { id: "runs", label: "Runs", scene: "fleet", argv: ["runs"], enterLabel: "Runs", member: ["fleet", "run-detail", "inspect", "handoff"] },
+  { id: "tasks", label: "Tasks", scene: "tasks", argv: ["tasks"], enterLabel: "Tasks", member: ["tasks"] },
+  { id: "inbox", label: "Inbox", scene: "inbox", argv: ["inbox"], enterLabel: "Inbox", member: ["inbox"], badge: inboxPendingCount },
+  { id: "stats", label: "Stats", scene: "family", argv: ["stats"], enterLabel: "Stats", member: ["family"] },
+  { id: "setup", label: "Setup", scene: "init", argv: ["init"], enterLabel: "Setup", member: ["init", "doctor", "server", "pi", "plugin", "repo", "workspace"] },
+  { id: "help", label: "Help", scene: "help", argv: ["help"], enterLabel: "Help", member: ["help"] }
+];
+function activeNavSection(scene) {
+  return PRIMARY_NAV.find((section) => section.member.includes(scene)) ?? PRIMARY_NAV[0];
+}
+function sceneSectionLabel(scene) {
+  const labels = {
+    main: "cockpit",
+    fleet: "runs",
+    tasks: "tasks",
+    inbox: "inbox",
+    inspect: "inspect",
+    "run-detail": "run",
+    handoff: "pi console",
+    server: "server",
+    doctor: "doctor",
+    init: "setup",
+    pi: "pi",
+    plugin: "plugins",
+    repo: "repo",
+    workspace: "workspace",
+    family: "family",
+    command: "command",
+    help: "help",
+    error: "error"
+  };
+  return labels[scene] ?? scene;
+}
+function buildNavStrip(state) {
+  const active = activeNavSection(state.scene);
+  const chunks = [];
+  PRIMARY_NAV.forEach((section, index) => {
+    if (index > 0)
+      chunks.push(styles.ink4("   "));
+    const isActive = section.id === active.id;
+    chunks.push(isActive ? otuiBold(styles.lime(section.label)) : styles.ink3(section.label));
+    const badgeCount = section.badge ? section.badge(state) : 0;
+    if (badgeCount > 0) {
+      chunks.push(styles.ink4(" "));
+      chunks.push(otuiBold(styles.yellow(String(badgeCount))));
+    }
+  });
+  return new StyledText4(chunks);
+}
+var DESTRUCTIVE_ACTION_KINDS = new Set(["run-stop", "inbox-reject"]);
+
+// packages/cli/src/app-opentui/react/ChromeHost.tsx
+function isTerminalScene(scene) {
+  return scene === "handoff" || scene === "command";
+}
+function ChromeHost(props) {
+  const renderer = useRenderer();
+  const dims = useTerminalDimensions();
+  const navRef = useRef(null);
+  const barRef = useRef(null);
+  useEffect(() => {
+    const nav = new TextRenderable5(renderer, { id: "react-primary-nav", content: "", position: "absolute", left: 0, top: -2, width: 1, zIndex: 9, selectable: false });
+    renderer.root.add(nav);
+    navRef.current = nav;
+    const bar = createTypeBar(renderer);
+    renderer.root.add(bar.background);
+    renderer.root.add(bar.prefix);
+    renderer.root.add(bar.input);
+    renderer.root.add(bar.footer);
+    barRef.current = bar;
+    return () => {
+      try {
+        renderer.root.remove(nav.id);
+      } catch {}
+      for (const r of [bar.background, bar.prefix, bar.input, bar.footer]) {
+        try {
+          renderer.root.remove(r.id);
+        } catch {}
+      }
+      navRef.current = null;
+      barRef.current = null;
+    };
+  }, [renderer]);
+  useEffect(() => {
+    const { state, frame } = props;
+    const layout = computeStageLayout(dims.width, dims.height);
+    const nav = navRef.current;
+    const bar = barRef.current;
+    const terminalActive = isTerminalScene(state.scene);
+    const showNav = !frame.fullScreen && !terminalActive && state.typeBar.mode !== "command";
+    if (nav) {
+      nav.visible = showNav;
+      if (showNav) {
+        nav.content = buildNavStrip(state);
+        nav.left = layout.centerLeft;
+        nav.top = Math.max(0, layout.centerTop - 2);
+        nav.width = layout.centerWidth;
+        nav.fg = RIG_UI.ink3;
+        nav.zIndex = 9;
+      }
+    }
+    if (bar) {
+      if (frame.hideTypeBar) {
+        hideTypeBar(bar, layout.height);
+      } else {
+        positionTypeBar(bar, { ...state.typeBar, placeholder: frame.typeBarPlaceholder ?? state.typeBar.placeholder }, { section: sceneSectionLabel(state.scene), ...state.footer, ...frame.footer ?? {} }, layout.width, layout.typeBarTop, layout.footerTop);
+      }
+    }
+  });
+  return null;
+}
+export {
+  ChromeHost
+};