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

package/dist/src/app-opentui/runtime.js

@@ -1,279 +1,656 @@
 // @bun
-// packages/cli/src/app-opentui/runtime.ts
-import { existsSync } from "fs";
-import { resolve } from "path";
-import { createCliRenderer } from "@opentui/core";
-
-// packages/cli/src/app-opentui/events.ts
-function createAppEventBus() {
-  const listeners = new Set;
-  return {
-    emit(event) {
-      for (const listener of [...listeners])
-        listener(event);
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    }
-  };
-}
-function normalizeError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  const rawHint = error instanceof Error ? error.hint : undefined;
-  return {
-    message: message || "Unknown Rig app error",
-    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {},
-    cause: error
-  };
-}
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// packages/cli/src/app-opentui/intent.ts
-var NAV_SCENES = new Map([
-  ["", "fleet"],
-  ["main", "fleet"],
-  ["home", "fleet"],
-  ["fleet", "fleet"],
-  ["runs", "fleet"],
-  ["run", "fleet"],
-  ["tasks", "tasks"],
-  ["task", "tasks"],
-  ["help", "help"]
-]);
-var TASK_VIEW_COMMANDS = new Set([
-  "",
-  "all",
-  "open",
-  "ready",
-  "blocked",
-  "closed",
-  "done",
-  "mine",
-  "me",
-  "sort",
-  "status",
-  "state",
-  "assignee",
-  "assigned",
-  "label",
-  "search",
-  "q"
-]);
-function isTaskViewCommand(command) {
-  return !command || TASK_VIEW_COMMANDS.has(command) || command.startsWith("-");
+// packages/cli/src/app-opentui/pi-pty-host.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { basename as basename2 } from "path";
+import { RGBA, StyledText, TextAttributes } from "@opentui/core";
+import { Terminal as XtermTerminal2 } from "@xterm/headless";
+function clampCols2(cols) {
+  return Math.max(MIN_COLS2, Math.trunc(cols || 100));
 }
-function intent(scene, argv, kind, payload, label, raw) {
-  return {
-    scene,
-    argv,
-    ...raw ? { raw } : {},
-    action: {
-      kind,
-      ...label ? { label } : {},
-      ...payload ? { payload } : {}
-    }
-  };
+function clampRows2(rows) {
+  return Math.max(MIN_ROWS2, Math.min(MAX_ROWS2, Math.trunc(rows || 35)));
 }
-function unsupportedPlainCliIntent(argv, raw) {
-  const command = argv.join(" ").trim() || "command";
-  return intent("help", argv, "none", { unsupported: command }, `${command} is on the plain CLI path; exit Rig shell or rerun with RIG_PLAIN=1`, raw);
+function rgbaFromXtermColor(mode, value) {
+  if (mode === 1 || mode === 2 || mode === XTERM_COLOR_MODE_INDEXED_16 || mode === XTERM_COLOR_MODE_INDEXED_256) {
+    return RGBA.fromIndex(value);
+  }
+  if (mode === 3 || mode === XTERM_COLOR_MODE_RGB) {
+    return RGBA.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255);
+  }
+  return;
 }
-function firstValueAfter(args, option) {
-  const index = args.indexOf(option);
-  return index >= 0 ? args[index + 1] : undefined;
+function textAttributesFromCell(cell) {
+  let attributes = TextAttributes.NONE;
+  if (cell.isBold())
+    attributes |= TextAttributes.BOLD;
+  if (cell.isDim())
+    attributes |= TextAttributes.DIM;
+  if (cell.isItalic())
+    attributes |= TextAttributes.ITALIC;
+  if (cell.isUnderline())
+    attributes |= TextAttributes.UNDERLINE;
+  if (cell.isBlink())
+    attributes |= TextAttributes.BLINK;
+  if (cell.isInverse())
+    attributes |= TextAttributes.INVERSE;
+  if (cell.isInvisible())
+    attributes |= TextAttributes.HIDDEN;
+  if (cell.isStrikethrough())
+    attributes |= TextAttributes.STRIKETHROUGH;
+  return attributes;
 }
-function firstNonOption(args) {
-  return args.find((part) => part.trim() && !part.startsWith("-"));
+function sameRgba(a, b) {
+  if (!a && !b)
+    return true;
+  return Boolean(a && b && a.equals(b));
 }
-function explicitTaskIdArg(args) {
-  const taskValue = firstValueAfter(args, "--task");
-  if (taskValue && !taskValue.startsWith("-"))
-    return taskValue;
-  return args.find((part) => part.trim() && part !== "next" && part !== "--next" && part !== "--task" && !part.startsWith("-"));
+function sameStyle(a, b) {
+  return sameRgba(a.fg, b.fg) && sameRgba(a.bg, b.bg) && (a.attributes ?? 0) === (b.attributes ?? 0);
 }
-function taskViewPayload(command, rest) {
-  const normalized = command.toLowerCase();
-  const args = command ? [command, ...rest] : rest;
-  const sort = firstValueAfter(args, "--sort") ?? firstValueAfter(args, "-s");
-  const state = firstValueAfter(args, "--state");
-  const status = firstValueAfter(args, "--status");
-  const assignee = firstValueAfter(args, "--assignee") ?? firstValueAfter(args, "--assigned");
-  const label = firstValueAfter(args, "--label");
-  const search = firstValueAfter(args, "--search") ?? firstValueAfter(args, "-q");
-  const optionPayload = {
-    ...sort ? { taskSort: sort } : {},
-    ...state ? { taskState: state, taskFilterPreset: "custom" } : {},
-    ...status ? { taskStatus: status, taskFilterPreset: "custom" } : {},
-    ...assignee ? { taskAssignee: assignee, taskFilterPreset: "custom" } : {},
-    ...label ? { taskLabel: label, taskFilterPreset: "custom" } : {},
-    ...search ? { taskSearch: search, taskFilterPreset: "custom" } : {}
+function styleFromCell(cell) {
+  return {
+    fg: rgbaFromXtermColor(cell.getFgColorMode(), cell.getFgColor()),
+    bg: rgbaFromXtermColor(cell.getBgColorMode(), cell.getBgColor()),
+    attributes: textAttributesFromCell(cell)
   };
-  if (normalized === "sort") {
-    const value = firstNonOption(rest) ?? sort ?? "priority";
-    return { payload: { ...optionPayload, taskSort: value }, label: `Sorting tasks by ${value}` };
-  }
-  if (normalized === "status") {
-    const value = firstNonOption(rest) ?? status ?? "open";
-    return { payload: { ...optionPayload, taskStatus: value, taskFilterPreset: "custom" }, label: `Filtering tasks by status ${value}` };
-  }
-  if (normalized === "state") {
-    const value = firstNonOption(rest) ?? state ?? "open";
-    return { payload: { ...optionPayload, taskState: value, taskFilterPreset: "custom" }, label: `Filtering tasks by state ${value}` };
-  }
-  if (normalized === "assignee" || normalized === "assigned" || normalized === "mine" || normalized === "me") {
-    const value = normalized === "mine" || normalized === "me" ? "me" : firstNonOption(rest) ?? assignee ?? "me";
-    return { payload: { ...optionPayload, taskAssignee: value, taskState: "open", taskFilterPreset: value === "me" ? "mine" : "custom" }, label: value === "me" ? "Filtering my tasks" : `Filtering tasks for ${value}` };
-  }
-  if (normalized === "label") {
-    const value = firstNonOption(rest) ?? label;
-    return { payload: { ...optionPayload, ...value ? { taskLabel: value } : {}, taskFilterPreset: "custom" }, label: value ? `Filtering tasks labeled ${value}` : "Filtering tasks by label" };
-  }
-  if (normalized === "search" || normalized === "q") {
-    const value = rest.join(" ").trim() || search;
-    return { payload: { ...optionPayload, ...value ? { taskSearch: value } : {}, taskFilterPreset: "custom" }, label: value ? `Searching tasks for ${value}` : "Searching tasks" };
-  }
-  if (["all", "open", "ready", "blocked", "closed", "done"].includes(normalized)) {
-    return { payload: { ...optionPayload, taskFilterPreset: normalized === "done" ? "closed" : normalized }, label: `Filtering tasks: ${normalized}` };
-  }
-  if (Object.keys(optionPayload).length > 0)
-    return { payload: optionPayload, label: "Filtering tasks" };
-  return { label: "Loading tasks" };
-}
-function taskViewIntent(argv, command = "", rest = [], raw) {
-  const { payload, label } = taskViewPayload(command, rest);
-  return intent("tasks", argv, "refresh", payload, label, raw);
 }
-function intentFromArgv(argv) {
-  const [group = "", command = "", ...rest] = argv;
-  const normalizedGroup = group.toLowerCase();
-  const normalizedCommand = command.toLowerCase();
-  if (!normalizedGroup)
-    return intent("fleet", argv, "refresh", undefined, "Opening runs");
-  if (normalizedGroup === "--help" || normalizedGroup === "-h" || normalizedGroup === "help") {
-    return argv.length === 1 ? intent("help", argv, "none", undefined, "Help") : unsupportedPlainCliIntent(argv);
-  }
-  if (normalizedGroup === "task") {
-    if (normalizedCommand === "run") {
-      if (rest.includes("--next") || rest.includes("next")) {
-        return intent("tasks", argv, "task-run-next", undefined, "Dispatching next task");
-      }
-      const task = explicitTaskIdArg(rest);
-      if (task)
-        return intent("tasks", argv, "task-run-id", { task }, `Dispatching ${task}`);
-      return intent("tasks", argv, "refresh", undefined, "Select a task, then press Enter; or use run next");
+function lineToStyledText(line, cols) {
+  if (!line)
+    return new StyledText([{ __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 (!isTaskViewCommand(normalizedCommand))
-      return unsupportedPlainCliIntent(argv);
-    return taskViewIntent(argv, normalizedCommand, rest);
-  }
-  if (normalizedGroup === "tasks") {
-    if (!isTaskViewCommand(normalizedCommand))
-      return unsupportedPlainCliIntent(argv);
-    return taskViewIntent(argv, normalizedCommand, rest);
-  }
-  if (normalizedGroup === "run") {
-    if (normalizedCommand === "attach") {
-      const runId = firstNonOption(rest);
-      return intent("handoff", argv, "run-attach", { runId }, runId ? `Attaching ${runId}` : "Attaching run");
+    if (cell.getWidth() === 0)
+      continue;
+    const style = styleFromCell(cell);
+    if (!runStyle || !sameStyle(runStyle, style)) {
+      flush();
+      runStyle = style;
     }
-    if (!normalizedCommand)
-      return intent("fleet", argv, "refresh", undefined, "Loading fleet");
-    return unsupportedPlainCliIntent(argv);
-  }
-  if (normalizedGroup === "attach") {
-    const runId = firstNonOption([command, ...rest]);
-    return intent("handoff", argv, "run-attach", { runId }, runId ? `Attaching ${runId}` : "Attaching run");
+    run += cell.getChars() || " ";
   }
-  const nav = NAV_SCENES.get(normalizedGroup);
-  if (nav)
-    return intent(nav, argv, "navigate", undefined, `Opening ${nav}`);
-  return unsupportedPlainCliIntent(argv);
-}
-function intentFromTypeBar(value) {
-  const raw = value.trim();
-  if (!raw)
-    return intent("fleet", [], "refresh", undefined, "Opening runs", value);
-  const parts = raw.split(/\s+/).filter(Boolean);
-  const [first = "", second = "", ...rest] = parts;
-  const firstScene = NAV_SCENES.get(first.toLowerCase());
-  if (first === "tasks" || first === "task") {
-    if (second === "run") {
-      const task = explicitTaskIdArg(rest);
-      if (rest.includes("--next") || task === "next")
-        return intent("tasks", parts, "task-run-next", undefined, "Dispatching next task", value);
-      if (task)
-        return intent("tasks", parts, "task-run-id", { task }, `Dispatching ${task}`, value);
-      return intent("tasks", parts, "refresh", undefined, "Select a task, then press Enter; or use run next", value);
-    }
-    if (!isTaskViewCommand(second.toLowerCase()))
-      return unsupportedPlainCliIntent(parts, value);
-    return taskViewIntent(parts, second, rest, value);
-  }
-  if (first === "run") {
-    if (second === "next" || second === "--next")
-      return intent("tasks", parts, "task-run-next", undefined, "Dispatching next task", value);
-    if (second === "--task") {
-      const task = explicitTaskIdArg([second, ...rest]);
-      if (task)
-        return intent("tasks", parts, "task-run-id", { task }, `Dispatching ${task}`, value);
-      return intent("tasks", parts, "refresh", undefined, "Select a task, then press Enter; or use run next", value);
-    }
-    if (second && !second.startsWith("-"))
-      return intent("tasks", parts, "task-run-id", { task: second }, `Dispatching ${second}`, value);
-    return intent("tasks", parts, "refresh", undefined, "Select a task, then press Enter; or use run next", value);
-  }
-  if (firstScene && parts.length === 1) {
-    return intent(firstScene, parts, "navigate", undefined, `Opening ${firstScene}`, value);
-  }
-  if (first === "stop")
-    return intent("fleet", parts, "run-stop", { runId: second || undefined }, second ? `Stopping ${second}` : "Stopping run", value);
-  if (first === "attach") {
-    if (!second)
-      return intent("handoff", parts, "navigate", undefined, "Select a run to attach", value);
-    return intent("handoff", parts, "run-attach", { runId: second }, `Attaching ${second}`, value);
-  }
-  return intentFromArgv(parts);
-}
-
-// packages/cli/src/app-opentui/layout.ts
-function computeStageLayout(width, height) {
-  const safeWidth = Math.max(40, Math.trunc(width || 80));
-  const safeHeight = Math.max(18, Math.trunc(height || 24));
-  const compact = safeWidth < 92 || safeHeight < 30;
-  const horizontalGutter = compact ? 1 : 2;
-  const centerWidth = Math.max(36, safeWidth - horizontalGutter * 2);
-  const centerLeft = horizontalGutter;
-  const typeBarTop = Math.max(0, safeHeight - 3);
-  const footerTop = Math.max(0, safeHeight - 1);
-  const centerTop = compact ? 1 : Math.max(1, Math.floor(safeHeight * 0.055));
-  const centerHeight = Math.max(8, typeBarTop - centerTop - 1);
-  return { width: safeWidth, height: safeHeight, centerWidth, centerLeft, centerTop, centerHeight, typeBarTop, footerTop, compact };
+  flush();
+  return new StyledText(chunks.length > 0 ? chunks : [{ __isChunk: true, text: "" }]);
 }
-function visibleWidth(text) {
-  return [...text].length;
+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 alignText(text, width, align = "left") {
-  const length = visibleWidth(text);
-  if (length >= width)
-    return text;
-  const pad = width - length;
-  if (align === "right")
-    return `${" ".repeat(pad)}${text}`;
-  if (align === "center") {
-    const left = Math.floor(pad / 2);
-    return `${" ".repeat(left)}${text}${" ".repeat(pad - left)}`;
+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 text;
+  return {
+    ...env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+    FORCE_COLOR: env.FORCE_COLOR ?? "1",
+    RIG_OPENTUI_PI_HOST: "1"
+  };
 }
-function truncateText(text, width) {
-  if (visibleWidth(text) <= width)
-    return text;
-  if (width <= 1)
-    return "\u2026";
-  return `${[...text].slice(0, Math.max(0, width - 1)).join("")}\u2026`;
+function getActivePiHost() {
+  return activeHost2 && !activeHost2.disposed ? activeHost2 : null;
+}
+function stopActivePiHost(reason = "detach") {
+  activeHost2?.dispose(reason);
+  activeHost2 = null;
 }
 
-// packages/cli/src/app-opentui/list-search.ts
+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";
+  exitCode;
+  signal;
+  notifyTimer = null;
+  _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();
+  }
+  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);
+    } catch {}
+    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, () => this.emitSnapshotSoon());
+  }
+  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 StyledText([{ __isChunk: true, text: "" }]);
+    }
+    return {
+      runId: this.runId,
+      status: this.status,
+      cols: this.cols,
+      rows: this.rows,
+      lines,
+      styledLines,
+      message,
+      ...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`);
+    }
+  }
+}
+var MIN_COLS2 = 40, MIN_ROWS2 = 12, MAX_ROWS2 = 300, MAX_SNAPSHOT_LINES2 = 360, STYLED_SNAPSHOT_MARGIN = 6, SNAPSHOT_DELAY_MS2 = 120, fallbackChildScriptPath, activeHost2 = null, XTERM_COLOR_MODE_INDEXED_16 = 16777216, XTERM_COLOR_MODE_INDEXED_256 = 33554432, XTERM_COLOR_MODE_RGB = 50331648;
+var init_pi_pty_host = __esm(() => {
+  fallbackChildScriptPath = fileURLToPath2(new URL("./pi-host-child.ts", import.meta.url));
+});
+// packages/cli/src/app-opentui/runtime.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { BoxRenderable as BoxRenderable2, RGBA as RGBA7, TextRenderable as TextRenderable3, createCliRenderer } from "@opentui/core";
+
+// packages/cli/src/app-opentui/events.ts
+function createAppEventBus() {
+  const listeners = new Set;
+  return {
+    emit(event) {
+      for (const listener of [...listeners])
+        listener(event);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function normalizeError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const rawHint = error instanceof Error ? error.hint : undefined;
+  return {
+    message: message || "Unknown app error",
+    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {},
+    cause: error
+  };
+}
+
+// packages/cli/src/app-opentui/focus-manager.ts
+class AppFocusManager {
+  modalStack = [];
+  pushModal(owner) {
+    this.modalStack = [...this.modalStack.filter((entry) => entry !== owner), owner];
+  }
+  popModal(owner) {
+    this.modalStack = this.modalStack.filter((entry) => entry !== owner);
+  }
+  get modal() {
+    const owner = this.modalStack[this.modalStack.length - 1];
+    return owner ? { active: true, owner } : { active: false };
+  }
+  restoreTypeBarFocus(typeBar, options = {}) {
+    if (options.hidden || this.modal.active || !typeBar)
+      return;
+    if (!typeBar.input.focused)
+      typeBar.input.focus();
+  }
+}
+
+// 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");
+}
+function getActiveCommandHost() {
+  return activeHost && !activeHost.disposed ? activeHost : null;
+}
+function stopActiveCommandHost(reason = "detach") {
+  activeHost?.dispose(reason);
+  activeHost = null;
+}
+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/app-opentui/list-search.ts
 function isListSearchScene(scene) {
   return scene === "fleet" || scene === "tasks";
 }
@@ -291,19 +668,411 @@ function valueText(value) {
     const record = value;
     return ["id", "runId", "taskId", "number", "title", "name", "summary", "status", "state", "label", "labels", "assignee", "assignees", "url"].map((key) => valueText(record[key])).join(" ");
   }
-  return "";
-}
-function includesQuery(haystack, query) {
-  const needle = query.trim().toLowerCase();
-  if (!needle)
-    return true;
-  return haystack.map(valueText).join(" ").toLowerCase().includes(needle);
+  return "";
+}
+function includesQuery(haystack, query) {
+  const needle = query.trim().toLowerCase();
+  if (!needle)
+    return true;
+  return haystack.map(valueText).join(" ").toLowerCase().includes(needle);
+}
+function filterRunsForSearch(runs, query) {
+  return query.trim() ? runs.filter((run) => includesQuery([run.runId, run.status, run.title, run.taskId, run.raw], query)) : [...runs];
+}
+function filterTasksForSearch(tasks, query) {
+  return query.trim() ? tasks.filter((task) => includesQuery([task.id, task.status, task.title, task.priority, task.labels, task.assignees, task.raw], query)) : [...tasks];
+}
+
+// packages/cli/src/app-opentui/keymap.ts
+init_pi_pty_host();
+function clearTypeBar(context, message) {
+  const typeBar = context.getTypeBar();
+  if (typeBar)
+    typeBar.input.value = "";
+  context.emitTypeBarPatch({ value: "", message });
+}
+function handleEmbeddedTerminalKey(context, key) {
+  const state = context.getState();
+  const piHost = getActivePiHost();
+  const commandHost = getActiveCommandHost();
+  const host = state.scene === "handoff" ? piHost : state.scene === "command" ? commandHost : null;
+  if (!host)
+    return false;
+  if (key.ctrl && key.name === "]") {
+    if (state.scene === "handoff") {
+      stopActivePiHost("operator detach");
+      clearTypeBar(context, "detached from Pi");
+      context.runAppAction("Opening runs", () => context.runtime.runIntent({ scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } }));
+    } else {
+      stopActiveCommandHost("operator detach");
+      clearTypeBar(context, "closed command");
+      context.runAppAction("Project menu", () => context.runtime.runIntent({ scene: "main", argv: ["main"], action: { kind: "none", label: "Project menu" } }));
+    }
+    return true;
+  }
+  const sequence = key.raw || key.sequence;
+  if (sequence)
+    host.write(sequence);
+  const typeBar = context.getTypeBar();
+  if (typeBar)
+    typeBar.input.value = "";
+  return true;
+}
+function handleAppKeyPress(context, key) {
+  if (handleEmbeddedTerminalKey(context, key))
+    return;
+  const renderer = context.renderer();
+  if (key.ctrl && key.name === "c") {
+    renderer?.destroy();
+    return;
+  }
+  const state = context.getState();
+  const currentScene = state.scene;
+  const searchScene = isListSearchScene(currentScene);
+  const typeBar = context.getTypeBar();
+  const inputValue = typeBar?.input.value ?? "";
+  const typeBarEmpty = inputValue.trim() === "";
+  if (typeBarEmpty && (key.name === "right" || key.name === "tab")) {
+    context.runAppAction("Navigate", () => context.runtime.runIntent(context.primaryNavIntent(context.nextPrimaryScene(context.getState().scene, 1))));
+    return;
+  }
+  if (typeBarEmpty && key.name === "left") {
+    context.runAppAction("Navigate", () => context.runtime.runIntent(context.primaryNavIntent(context.nextPrimaryScene(context.getState().scene, -1))));
+    return;
+  }
+  if (!searchScene && typeBarEmpty && key.name === "r") {
+    context.runAppAction("Opening runs", () => context.runtime.runIntent(context.primaryNavIntent("fleet")));
+    return;
+  }
+  if (!searchScene && typeBarEmpty && key.name === "t") {
+    context.runAppAction("Opening tasks", () => context.runtime.runIntent(context.primaryNavIntent("tasks")));
+    return;
+  }
+  if (!searchScene && typeBarEmpty && (key.name === "h" || key.sequence === "?")) {
+    context.runAppAction("Opening help", () => context.runtime.runIntent(context.primaryNavIntent("help")));
+    return;
+  }
+  if (searchScene && key.name === "up" || !searchScene && typeBarEmpty && (key.name === "up" || key.name === "k")) {
+    if (context.moveSelection(-1, context.getRenderedSelectableItems()))
+      return;
+  }
+  if (searchScene && key.name === "down" || !searchScene && typeBarEmpty && (key.name === "down" || key.name === "j")) {
+    if (context.moveSelection(1, context.getRenderedSelectableItems()))
+      return;
+  }
+  if (typeBarEmpty && (key.name === "return" || key.name === "enter" || key.name === "space" || key.sequence === " ")) {
+    context.runAppAction("Activate selection", () => context.activateSelection(context.getRenderedSelectableItems()));
+    return;
+  }
+  if (!searchScene && key.name === "q" && typeBarEmpty) {
+    renderer?.destroy();
+    return;
+  }
+  if (key.name === "escape") {
+    if (inputValue)
+      clearTypeBar(context);
+    else
+      context.runAppAction("Project menu", () => context.runtime.runIntent({ scene: "main", argv: ["main"], action: { kind: "none", label: "Project menu" } }));
+  }
+}
+
+// packages/cli/src/app-opentui/layout.ts
+function computeStageLayout(width, height) {
+  const safeWidth = Math.max(40, Math.trunc(width || 80));
+  const safeHeight = Math.max(18, Math.trunc(height || 24));
+  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 = footerTop;
+  const centerTop = compact ? 1 : Math.max(1, Math.floor(safeHeight * 0.055));
+  const centerHeight = Math.max(8, footerTop - centerTop);
+  return { width: safeWidth, height: safeHeight, centerWidth, centerLeft, centerTop, centerHeight, typeBarTop, footerTop, compact };
+}
+function visibleWidth(text) {
+  return [...text].length;
+}
+function alignText(text, width, align = "left") {
+  const length = visibleWidth(text);
+  if (length >= width)
+    return text;
+  const pad = width - length;
+  if (align === "right")
+    return `${" ".repeat(pad)}${text}`;
+  if (align === "center") {
+    const left = Math.floor(pad / 2);
+    return `${" ".repeat(left)}${text}${" ".repeat(pad - left)}`;
+  }
+  return text;
+}
+function truncateText(text, width) {
+  if (visibleWidth(text) <= width)
+    return text;
+  if (width <= 1)
+    return "\u2026";
+  return `${[...text].slice(0, Math.max(0, width - 1)).join("")}\u2026`;
+}
+
+// packages/cli/src/app-opentui/runtime-resources.ts
+class RuntimeResources {
+  disposers = [];
+  disposed = false;
+  add(disposer) {
+    if (this.disposed) {
+      disposer();
+      return () => {
+        return;
+      };
+    }
+    this.disposers.push(disposer);
+    return disposer;
+  }
+  setTimeout(callback, delayMs) {
+    const timer = setTimeout(() => {
+      this.remove(dispose);
+      callback();
+    }, delayMs);
+    const dispose = () => clearTimeout(timer);
+    this.add(dispose);
+    return timer;
+  }
+  setInterval(callback, delayMs) {
+    const timer = setInterval(callback, delayMs);
+    this.add(() => clearInterval(timer));
+    return timer;
+  }
+  clearTimeout(timer) {
+    if (timer)
+      clearTimeout(timer);
+  }
+  on(emitter, event, listener) {
+    emitter.on(event, listener);
+    this.add(() => {
+      if (typeof emitter.off === "function")
+        emitter.off(event, listener);
+      else
+        emitter.removeListener?.(event, listener);
+    });
+  }
+  disposeAll() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    for (let index = this.disposers.length - 1;index >= 0; index -= 1) {
+      try {
+        this.disposers[index]?.();
+      } catch {}
+    }
+    this.disposers.length = 0;
+  }
+  remove(disposer) {
+    const index = this.disposers.indexOf(disposer);
+    if (index >= 0)
+      this.disposers.splice(index, 1);
+  }
+}
+
+// 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"],
+  ["help", "help"]
+]);
+var TASK_VIEW_COMMANDS = new Set([
+  "",
+  "all",
+  "open",
+  "ready",
+  "blocked",
+  "closed",
+  "done",
+  "mine",
+  "me",
+  "sort",
+  "status",
+  "state",
+  "assignee",
+  "assigned",
+  "label",
+  "search",
+  "q"
+]);
+function isHelpCommand(command) {
+  return command === "help" || command === "--help" || command === "-h";
+}
+function isTaskViewCommand(command) {
+  return !command || TASK_VIEW_COMMANDS.has(command) || command.startsWith("-") && !isHelpCommand(command);
+}
+function intent(scene, argv, kind, payload, label, raw) {
+  return {
+    scene,
+    argv,
+    ...raw ? { raw } : {},
+    action: {
+      kind,
+      ...label ? { label } : {},
+      ...payload ? { payload } : {}
+    }
+  };
+}
+function commandRunIntent(argv, raw, reason) {
+  const command = argv.join(" ").trim();
+  return intent("command", argv, "command-run", { argv: [...argv], ...reason ? { reason } : {} }, command ? `Running rig ${command}` : "Running rig", raw);
+}
+function unsupportedPlainCliIntent(argv, raw, reason) {
+  return commandRunIntent(argv, raw, reason);
+}
+function firstValueAfter(args, option) {
+  const index = args.indexOf(option);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+function firstNonOption(args) {
+  return args.find((part) => part.trim() && !part.startsWith("-"));
+}
+function inboxActionIntent(argv, command, rest, raw) {
+  const requestId = firstNonOption(rest);
+  if (command === "approve" || command === "approvals") {
+    return requestId ? intent("inbox", argv, "inbox-approve", { requestId }, `Approving ${requestId}`, raw) : intent("inbox", argv, "refresh", undefined, "Loading approvals", raw);
+  }
+  if (command === "reject") {
+    return requestId ? intent("inbox", argv, "inbox-reject", { requestId }, `Rejecting ${requestId}`, raw) : intent("inbox", argv, "refresh", undefined, "Loading approvals", raw);
+  }
+  if (command === "answer" || command === "inputs" || command === "respond") {
+    const answer = rest.slice(requestId ? 1 : 0).join(" ").trim();
+    return requestId && answer ? intent("inbox", argv, "inbox-answer", { requestId, answer }, `Answering ${requestId}`, raw) : intent("inbox", argv, "refresh", undefined, "Loading inbox", raw);
+  }
+  return intent("inbox", argv, "refresh", undefined, "Loading inbox", raw);
+}
+function taskViewPayload(command, rest) {
+  const normalized = command.toLowerCase();
+  const args = command ? [command, ...rest] : rest;
+  const sort = firstValueAfter(args, "--sort") ?? firstValueAfter(args, "-s");
+  const state = firstValueAfter(args, "--state");
+  const status = firstValueAfter(args, "--status");
+  const assignee = firstValueAfter(args, "--assignee") ?? firstValueAfter(args, "--assigned");
+  const label = firstValueAfter(args, "--label");
+  const search = firstValueAfter(args, "--search") ?? firstValueAfter(args, "-q");
+  const optionPayload = {
+    ...sort ? { taskSort: sort } : {},
+    ...state ? { taskState: state, taskFilterPreset: "custom" } : {},
+    ...status ? { taskStatus: status, taskFilterPreset: "custom" } : {},
+    ...assignee ? { taskAssignee: assignee, taskFilterPreset: "custom" } : {},
+    ...label ? { taskLabel: label, taskFilterPreset: "custom" } : {},
+    ...search ? { taskSearch: search, taskFilterPreset: "custom" } : {}
+  };
+  if (normalized === "sort") {
+    const value = firstNonOption(rest) ?? sort ?? "priority";
+    return { payload: { ...optionPayload, taskSort: value }, label: `Sorting tasks by ${value}` };
+  }
+  if (normalized === "status") {
+    const value = firstNonOption(rest) ?? status ?? "open";
+    return { payload: { ...optionPayload, taskStatus: value, taskFilterPreset: "custom" }, label: `Filtering tasks by status ${value}` };
+  }
+  if (normalized === "state") {
+    const value = firstNonOption(rest) ?? state ?? "open";
+    return { payload: { ...optionPayload, taskState: value, taskFilterPreset: "custom" }, label: `Filtering tasks by state ${value}` };
+  }
+  if (normalized === "assignee" || normalized === "assigned" || normalized === "mine" || normalized === "me") {
+    const value = normalized === "mine" || normalized === "me" ? "me" : firstNonOption(rest) ?? assignee ?? "me";
+    return { payload: { ...optionPayload, taskAssignee: value, taskState: "open", taskFilterPreset: value === "me" ? "mine" : "custom" }, label: value === "me" ? "Filtering my tasks" : `Filtering tasks for ${value}` };
+  }
+  if (normalized === "label") {
+    const value = firstNonOption(rest) ?? label;
+    return { payload: { ...optionPayload, ...value ? { taskLabel: value } : {}, taskFilterPreset: "custom" }, label: value ? `Filtering tasks labeled ${value}` : "Filtering tasks by label" };
+  }
+  if (normalized === "search" || normalized === "q") {
+    const value = rest.join(" ").trim() || search;
+    return { payload: { ...optionPayload, ...value ? { taskSearch: value } : {}, taskFilterPreset: "custom" }, label: value ? `Searching tasks for ${value}` : "Searching tasks" };
+  }
+  if (["all", "open", "ready", "blocked", "closed", "done"].includes(normalized)) {
+    return { payload: { ...optionPayload, taskFilterPreset: normalized === "done" ? "closed" : normalized }, label: `Filtering tasks: ${normalized}` };
+  }
+  if (Object.keys(optionPayload).length > 0)
+    return { payload: optionPayload, label: "Filtering tasks" };
+  return { label: "Loading tasks" };
 }
-function filterRunsForSearch(runs, query) {
-  return query.trim() ? runs.filter((run) => includesQuery([run.runId, run.status, run.title, run.taskId, run.raw], query)) : [...runs];
+function taskViewIntent(argv, command = "", rest = [], raw) {
+  const { payload, label } = taskViewPayload(command, rest);
+  return intent("tasks", argv, "refresh", payload, label, raw);
 }
-function filterTasksForSearch(tasks, query) {
-  return query.trim() ? tasks.filter((task) => includesQuery([task.id, task.status, task.title, task.priority, task.labels, task.assignees, task.raw], query)) : [...tasks];
+function intentFromArgv(argv) {
+  const [group = "", command = "", ...rest] = argv;
+  const normalizedGroup = group.toLowerCase();
+  const normalizedCommand = command.toLowerCase();
+  if (!normalizedGroup)
+    return intent("main", argv, "none", undefined, "Project menu");
+  if (normalizedGroup === "--help" || normalizedGroup === "-h" || normalizedGroup === "help") {
+    return argv.length === 1 ? intent("help", argv, "none", undefined, "Help") : unsupportedPlainCliIntent(argv);
+  }
+  if (normalizedGroup === "task") {
+    if (normalizedCommand === "run" || normalizedCommand === "ready" || normalizedCommand === "status")
+      return commandRunIntent(argv);
+    if (!isTaskViewCommand(normalizedCommand))
+      return commandRunIntent(argv);
+    return taskViewIntent(argv, normalizedCommand, rest);
+  }
+  if (normalizedGroup === "tasks") {
+    if (!isTaskViewCommand(normalizedCommand))
+      return unsupportedPlainCliIntent(argv);
+    return taskViewIntent(argv, normalizedCommand, rest);
+  }
+  if (normalizedGroup === "run") {
+    if (normalizedCommand === "attach") {
+      const runId = firstNonOption(rest);
+      const nativeOnly = Boolean(runId) && rest.filter((part) => part.trim()).length === 1;
+      return nativeOnly ? intent("handoff", argv, "run-attach", { runId }, `Attaching ${runId}`) : commandRunIntent(argv);
+    }
+    if (!normalizedCommand || normalizedCommand === "list" || normalizedCommand === "status")
+      return intent("fleet", argv, "refresh", undefined, "Loading fleet");
+    if (normalizedCommand === "stop") {
+      const runId = firstNonOption(rest);
+      return runId && rest.filter((part) => part.trim()).length === 1 ? intent("fleet", argv, "run-stop", { runId }, "Stopping run") : commandRunIntent(argv);
+    }
+    return commandRunIntent(argv);
+  }
+  if (normalizedGroup === "server") {
+    if (!normalizedCommand || normalizedCommand === "status")
+      return intent("server", argv, "refresh", undefined, normalizedCommand ? "Checking server" : "Loading server");
+    return unsupportedPlainCliIntent(argv, undefined, `server ${normalizedCommand} is not executed in the shell; exit and run it in plain mode.`);
+  }
+  if (normalizedGroup === "github") {
+    if (normalizedCommand === "auth" && (rest[0]?.toLowerCase() ?? "status") === "status" && rest.length <= 1) {
+      return intent("server", argv, "refresh", undefined, "Checking GitHub auth");
+    }
+    return unsupportedPlainCliIntent(argv, undefined, "github auth mutations are not executed in the shell; exit and run them in plain mode.");
+  }
+  if (normalizedGroup === "init")
+    return commandRunIntent(argv);
+  if (normalizedGroup === "doctor") {
+    return normalizedCommand ? commandRunIntent(argv) : intent("doctor", argv, "doctor-run", undefined, "Running doctor");
+  }
+  if (normalizedGroup === "inbox") {
+    if (normalizedCommand === "watch")
+      return commandRunIntent(argv);
+    if ((normalizedCommand === "approvals" || normalizedCommand === "inputs") && rest.length > 0)
+      return commandRunIntent(argv);
+    return normalizedCommand && normalizedCommand !== "approvals" && normalizedCommand !== "inputs" ? commandRunIntent(argv) : inboxActionIntent(argv, normalizedCommand, rest);
+  }
+  if (normalizedGroup === "attach") {
+    const attachArgs = [command, ...rest].filter((part) => part.trim());
+    const runId = firstNonOption(attachArgs);
+    return runId && attachArgs.length === 1 ? intent("handoff", argv, "run-attach", { runId }, `Attaching ${runId}`) : commandRunIntent(argv);
+  }
+  const nav = NAV_SCENES.get(normalizedGroup);
+  if (nav && argv.length === 1)
+    return intent(nav, argv, "navigate", undefined, `Opening ${nav}`);
+  return commandRunIntent(argv);
 }
 
 // packages/cli/src/app-opentui/state.ts
@@ -431,7 +1200,7 @@ import {
   dim as otuiDim,
   fg as otuiFg,
   t,
-  TextAttributes
+  TextAttributes as TextAttributes2
 } from "@opentui/core";
 var RIG_UI = {
   bg: "#070809",
@@ -462,16 +1231,175 @@ var styles = {
   yellow: otuiFg(RIG_UI.yellow),
   magenta: otuiFg(RIG_UI.magenta)
 };
+// packages/cli/src/app-opentui/adapters/tasks.ts
+function rawRecord(record, key) {
+  const direct = record[key];
+  if (direct !== undefined && direct !== null)
+    return direct;
+  const raw = record.raw;
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? raw[key] : undefined;
+}
+function optionalString(record, keys) {
+  for (const key of keys) {
+    const value = rawRecord(record, key);
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+      return String(value);
+  }
+  return;
+}
+function activeRunForRecord(record) {
+  const value = rawRecord(record, "activeRun");
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const activeRun = value;
+  const runId = optionalString(activeRun, ["runId", "id"]);
+  if (!runId)
+    return;
+  const status = optionalString(activeRun, ["status", "state"]);
+  const stage = optionalString(activeRun, ["stage", "phase"]);
+  return {
+    runId,
+    ...status ? { status } : {},
+    ...stage ? { stage } : {}
+  };
+}
+function activeRunIdFromTaskLike(task) {
+  return activeRunForRecord(task)?.runId;
+}
+
+// packages/cli/src/app-opentui/render/graphics.ts
+import { FrameBufferRenderable, RGBA as RGBA2 } 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 panelCellRect(layout, panel) {
+  const left = Math.max(0, Math.min(layout.width - 1, layout.centerLeft + (panel.left ?? 0)));
+  const desiredWidth = panel.width ?? layout.centerWidth;
+  const width = Math.max(1, Math.min(layout.width - left, desiredWidth));
+  const top = Math.max(0, Math.min(layout.height - 1, layout.centerTop + panel.top));
+  const height = Math.max(1, Math.min(layout.height - top, panel.height));
+  if (width <= 3 || height <= 3)
+    return null;
+  const right = left + width - 1;
+  const bottom = top + height - 1;
+  const headerHeight = panel.chrome === "ad-terminal" ? Math.max(3, Math.min(height - 2, panel.headerHeight ?? 3)) : 0;
+  const dividerY = headerHeight ? Math.min(bottom - 1, top + headerHeight) : top;
+  return { left, top, width, height, right, bottom, headerHeight, dividerY };
+}
+function panelContentRect(layout, panel) {
+  const rect = panelCellRect(layout, panel);
+  if (!rect)
+    return null;
+  const chromeInset = panel.chrome === "ad-terminal" ? 1 : 0;
+  const left = rect.left + chromeInset;
+  const top = rect.top + rect.headerHeight + chromeInset;
+  const width = Math.max(1, Math.min(layout.width - left, rect.width - chromeInset * 2));
+  const height = Math.max(1, Math.min(layout.height - top, rect.height - rect.headerHeight - chromeInset * 2));
+  const paddingX = panel.paddingX ?? (panel.chrome === "ad-terminal" ? 5 : 2);
+  const paddingY = panel.paddingY ?? (panel.chrome === "ad-terminal" ? 2 : 1);
+  const contentWidth = Math.max(1, width - paddingX * 2 - 1);
+  return { left, top, width, height, paddingX, paddingY, contentWidth };
+}
+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/graphics.ts
-import { FrameBufferRenderable, RGBA } from "@opentui/core";
-var TRANSPARENT = RGBA.fromValues(0, 0, 0, 0);
-var BACKDROP = RGBA.fromHex(RIG_UI.bg);
-var PANEL_BG = RGBA.fromInts(16, 17, 21, 184);
-var PANEL_HEADER_BG = RGBA.fromInts(16, 17, 21, 188);
-var PANEL_LINE = RGBA.fromInts(255, 255, 255, 20);
-var PANEL_LINE_DIM = RGBA.fromInts(255, 255, 255, 8);
-var PANEL_TEXT_DIM = RGBA.fromInts(108, 110, 121, 255);
+var TRANSPARENT = RGBA2.fromValues(0, 0, 0, 0);
+var BACKDROP = RGBA2.fromHex(RIG_UI.bg);
+var PANEL_BG = RGBA2.fromInts(16, 17, 21, 184);
+var PANEL_HEADER_BG = RGBA2.fromInts(16, 17, 21, 188);
+var PANEL_LINE = RGBA2.fromInts(255, 255, 255, 20);
+var PANEL_LINE_DIM = RGBA2.fromInts(255, 255, 255, 8);
+var PANEL_TEXT_DIM = RGBA2.fromInts(108, 110, 121, 255);
 var AC_RGB = [204, 255, 77];
 var C2_RGB = [86, 216, 255];
 var MG_RGB = [255, 121, 176];
@@ -576,7 +1504,7 @@ function paletteColor(ac, c2, mg, ink) {
   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 RGBA.fromInts(Math.round(r * lift), Math.round(g * lift), Math.round(b * lift), 255);
+  return RGBA2.fromInts(Math.round(r * lift), Math.round(g * lift), Math.round(b * lift), 255);
 }
 function clearCanvas(canvas) {
   canvas.ac.fill(0);
@@ -885,14 +1813,6 @@ function resizeGraphicsLayer(layer, layout) {
 function clearGraphicsLayer(layer) {
   layer.frameBuffer.clear(BACKDROP);
 }
-function panelRect(layout, panel) {
-  const left = Math.max(0, Math.min(layout.width - 1, layout.centerLeft + (panel.left ?? 0)));
-  const desiredWidth = panel.width ?? layout.centerWidth;
-  const width = Math.max(1, Math.min(layout.width - left, desiredWidth));
-  const top = Math.max(0, Math.min(layout.height - 1, layout.centerTop + panel.top));
-  const height = Math.max(1, Math.min(layout.height - top, panel.height));
-  return width > 3 && height > 3 ? { left, top, width, height } : null;
-}
 function writeCell(layer, x, y, char, fg, bg) {
   layer.frameBuffer.setCellWithAlphaBlending(x, y, char, fg, bg);
 }
@@ -915,14 +1835,10 @@ function drawRoundedFill(layer, left, top, right, bottom, dividerY) {
   drawCornerCut(layer, right, bottom, "\u2598", PANEL_BG);
 }
 function drawAdTerminalPanel(layer, layout, panel) {
-  const rect = panelRect(layout, panel);
+  const rect = panelCellRect(layout, panel);
   if (!rect)
     return;
-  const { left, top, width, height } = rect;
-  const right = left + width - 1;
-  const bottom = top + height - 1;
-  const headerHeight = Math.max(3, Math.min(height - 2, panel.headerHeight ?? 3));
-  const dividerY = Math.min(bottom - 1, top + headerHeight);
+  const { left, top, width, right, bottom, headerHeight, dividerY } = rect;
   drawRoundedFill(layer, left, top, right, bottom, dividerY);
   if (dividerY > top && dividerY < bottom) {
     for (let x = left + 2;x < right - 1; x += 1) {
@@ -941,14 +1857,62 @@ function drawPanelChrome(layer, layout, panels) {
       drawAdTerminalPanel(layer, layout, panel);
   }
 }
-function drawAmbientField(layer, layout, tick, scene = "fleet") {
-  layer.__rigMarketingCanvas?.render(layer, scene, tick);
+function staticFleetTick(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 asciiFleetColor(char, row) {
+  if (char === "@" || char === "$" || char === "o")
+    return RGBA2.fromHex(RIG_UI.lime);
+  if (char === "%" || char === "!" || char === "/" || char === "\\" || char === "|")
+    return RGBA2.fromHex(RIG_UI.cyan);
+  if (char === "." || char === "'" || char === "_" || row < 3 || row > FLEET_GRID_HEIGHT - 4)
+    return RGBA2.fromInts(108, 110, 121, 170);
+  return RGBA2.fromHex(RIG_UI.limeDim);
+}
+function drawAmbientField(layer, layout, _tick, scene = "fleet") {
+  const fb = layer.frameBuffer;
+  fb.clear(BACKDROP);
+  const rows = fleetRows(staticFleetTick(scene), { animate: true });
+  const left = Math.floor((layout.width - FLEET_GRID_WIDTH) / 2);
+  const top = Math.floor((layout.height - FLEET_GRID_HEIGHT) / 2);
+  for (let row = 0;row < rows.length; row += 1) {
+    const y = top + row;
+    if (y < 0 || y >= layout.height)
+      continue;
+    const line = rows[row];
+    for (let col = 0;col < line.length; col += 1) {
+      const x = left + col;
+      if (x < 0 || x >= layout.width)
+        continue;
+      const char = line[col];
+      if (char === " ")
+        continue;
+      fb.setCellWithAlphaBlending(x, y, char, asciiFleetColor(char, row), TRANSPARENT);
+    }
+  }
 }
 
 // packages/cli/src/app-opentui/render/image-visual-layer.ts
 import { Worker } from "worker_threads";
 import { deflateSync } from "zlib";
-import { allocateImageId, deleteKittyImage, getCapabilities } from "@earendil-works/pi-tui";
+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 BG = [7, 8, 9, 255];
 var PANEL = [16, 17, 21, 184];
 var PANEL_HEADER = [16, 17, 21, 190];
@@ -962,12 +1926,10 @@ 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 = 5;
+var PANEL_BLUR_SCALE = 1;
 var PANEL_MASK_CACHE_LIMIT = 16;
 var ZLIB_LEVEL = 1;
 var DEFAULT_IMAGE_RESOLUTION_SCALE = 1;
-var DEFAULT_DRONE_LAYER_SCALE = 0.18;
-var DEFAULT_IMAGE_FPS = 24;
 var panelMaskCache = new Map;
 var BG_WORD = rgbaWord(BG);
 function imageTransport() {
@@ -982,24 +1944,6 @@ function imageResolutionScale() {
     return Math.max(0.25, Math.min(1, raw));
   return DEFAULT_IMAGE_RESOLUTION_SCALE;
 }
-function droneLayerScale() {
-  const raw = Number.parseFloat(process.env.RIG_OPENTUI_DRONE_SCALE ?? "");
-  if (Number.isFinite(raw) && raw > 0)
-    return Math.max(0.15, Math.min(1, raw));
-  return DEFAULT_DRONE_LAYER_SCALE;
-}
-function scaledPixelSize(size, scale, layout) {
-  return {
-    width: Math.max(layout.width, Math.floor(size.width * scale)),
-    height: Math.max(layout.height, Math.floor(size.height * scale))
-  };
-}
-function imageFps() {
-  const raw = Number.parseFloat(process.env.RIG_OPENTUI_IMAGE_FPS ?? "");
-  if (Number.isFinite(raw) && raw > 0)
-    return Math.max(10, Math.min(60, raw));
-  return DEFAULT_IMAGE_FPS;
-}
 function rgbaWord(color) {
   return (color[3] << 24 | color[2] << 16 | color[1] << 8 | color[0]) >>> 0;
 }
@@ -1015,6 +1959,109 @@ function fillRgba(data, color, word = rgbaWord(color)) {
     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) {
+  const rows = fleetRows(sceneStaticTick(scene), { animate: true });
+  const cellWidth = width / Math.max(1, layout.width);
+  const cellHeight = height / Math.max(1, layout.height);
+  const leftCells = 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.03);
+  drawGlow2(data, width, height, width * 0.18, height * 0.22, Math.min(width, height) * 0.28, CYAN, 0.022);
+  drawGlow2(data, width, height, width * 0.82, height * 0.78, Math.min(width, height) * 0.22, MAGENTA, 0.014);
+  for (let row = 0;row < rows.length; row += 1) {
+    const line = rows[row];
+    for (let col = 0;col < line.length; col += 1) {
+      const char = line[col];
+      if (char === " ")
+        continue;
+      const x = fleetLeft + col * cellWidth;
+      const y = fleetTop + row * cellHeight;
+      const color = charColor(char, row, rows.length);
+      drawAsciiGlyph(data, width, height, x + cellWidth * 0.07, y + cellHeight * 0.05, cellWidth, cellHeight, char, color, 0.52);
+      if (char === "@" || char === "$" || char === "%") {
+        drawGlow2(data, width, height, x + cellWidth * 0.5, y + cellHeight * 0.5, Math.max(cellWidth, cellHeight) * 0.95, color, 0.02);
+      }
+    }
+  }
+}
+function applyStaticAtmosphere(data, width, height) {
+  const cx = width * 0.5;
+  const cy = height * 0.42;
+  const radius = Math.max(width, height) * 0.78;
+  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(0.1, 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.03);
+  drawGlow2(data, width, height, width * 0.12, height * 0.18, Math.min(width, height) * 0.16, CYAN, 0.022);
+}
 function makeCrcTable() {
   const table = new Uint32Array(256);
   for (let n = 0;n < 256; n += 1) {
@@ -1085,9 +2132,6 @@ function kittyImageSequence(base64, options) {
   }
   return chunks.join("");
 }
-function isModernImageTerminal(protocol) {
-  return protocol === "kitty";
-}
 function clampByte(value) {
   return Math.max(0, Math.min(255, Math.round(value)));
 }
@@ -1099,23 +2143,6 @@ function blendOver(data, index, color, alphaScale = 1) {
   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));
@@ -1133,30 +2160,6 @@ function drawGlow2(data, width, height, cx, cy, radius, color, alpha = 0.18) {
     }
   }
 }
-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 drawDrone(data, width, height, x, y, scale, tick, color) {
-  const wobble = Math.sin(tick * 0.055) * scale * 0.35;
-  const cy = y + wobble;
-  drawGlow2(data, width, height, x, cy, scale * 7, color, 0.18);
-  drawDisc(data, width, height, x, cy, scale * 1.45, color, 0.92);
-  drawDisc(data, width, height, x, cy, scale * 0.55, [235, 255, 176, 255], 0.85);
-  const arm = scale * 4.1;
-  const rotor = scale * 1.6;
-  const arms = [[-arm, -arm * 0.72], [arm, -arm * 0.72], [-arm, arm * 0.72], [arm, arm * 0.72]];
-  for (const [dx, dy] of arms) {
-    drawLine2(data, width, height, x, cy, x + dx, cy + dy, color, 0.42, Math.max(1, scale * 0.22));
-    drawGlow2(data, width, height, x + dx, cy + dy, rotor * 2.6, color, 0.1);
-    drawDisc(data, width, height, x + dx, cy + dy, rotor, color, 0.34 + 0.12 * Math.sin(tick * 0.15));
-  }
-}
 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));
@@ -1165,18 +2168,8 @@ function roundRectAlpha(px, py, x, y, w, h, r) {
   const dist = Math.sqrt(dx * dx + dy * dy);
   return Math.max(0, Math.min(1, r + 0.75 - dist));
 }
-function panelRect2(layout, panel, size) {
-  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 > 8 && height > 8 ? { left, top, width, height } : null;
+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));
@@ -1325,7 +2318,8 @@ function getPanelMask(width, height, rect, headerPx, blurScale) {
 function compositePanel(data, width, height, rect, headerPx) {
   const blurScale = PANEL_BLUR_SCALE;
   const sampled = downsampleRegion(data, width, height, rect, blurScale);
-  const blurred = blurRgb(sampled.pixels, sampled.width, sampled.height, 4);
+  const blurRadius = Math.max(8, Math.min(28, Math.round(Math.min(rect.width, rect.height) * 0.018)));
+  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];
@@ -1343,161 +2337,10 @@ function compositePanel(data, width, height, rect, headerPx) {
     blendOver(data, mask.dividerIndices[i], PANEL_LINE2, 0.28);
   }
 }
-function visualSceneKind(scene) {
-  if (scene === "tasks")
-    return "loop";
-  if (scene === "help")
-    return "carrier";
-  return "dispatch";
-}
-function seededUnit(seed) {
-  let value = seed >>> 0;
-  value = value * 1664525 + 1013904223 >>> 0;
-  return value / 4294967295;
-}
-function sceneCore(width, height, kind) {
-  if (kind === "dispatch")
-    return { x: width * 0.3, y: height * 0.45 };
-  if (kind === "carrier")
-    return { x: width * 0.5, y: height * 0.54 };
-  return { x: width * 0.09, y: height * 0.56 };
-}
-function dispatchLane(width, index, count) {
-  const a = seededUnit(28672 + index * 101);
-  const b = seededUnit(36864 + index * 131);
-  const c = seededUnit(45056 + index * 151);
-  const ang = (-0.9 + 1.8 * (index / Math.max(1, count - 1))) * (Math.PI * 0.5);
-  return { ang, len: width * (0.32 + a * 0.42), curve: (b - 0.5) * 0.7, phase: c * Math.PI * 2 };
-}
-function lanePoint(width, height, lane, p, kind = "dispatch") {
-  const core = sceneCore(width, height, kind);
-  const dist = lane.len * p;
-  const bend = Math.sin(p * Math.PI) * lane.curve * Math.min(width, height) * 0.035;
-  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 };
-}
-function drawMarketingRails(data, width, height, kind, tick) {
-  const ys = kind === "loop" ? [0.18, 0.5, 0.82] : kind === "carrier" ? [0.24, 0.54, 0.82] : [0.18, 0.58, 0.82];
-  ys.forEach((ratio, index) => {
-    const y = height * ratio + Math.sin(tick * 0.018 + index) * Math.max(2, height * 0.0025);
-    const color = index === 2 ? CYAN : index === 1 ? LIME : LIME_DIM;
-    drawLine2(data, width, height, width * 0.06, y, width * 0.94, y + Math.sin(index) * height * 0.002, color, index === 1 ? 0.11 : 0.07, Math.max(0.8, height * 0.0012));
-    for (let p = (tick * 0.004 + index * 0.21) % 1;p < 1; p += 0.18 + index * 0.02) {
-      const x = width * (0.06 + 0.88 * p);
-      drawDisc(data, width, height, x, y, Math.max(1.2, height * (0.0017 + index * 0.0004)), color, 0.24);
-      drawGlow2(data, width, height, x, y, Math.max(5, height * 0.006), color, 0.035);
-    }
-  });
-}
-function drawDispatchScene(data, width, height, tick) {
-  const core = sceneCore(width, height, "dispatch");
-  const min = Math.min(width, height);
-  drawGlow2(data, width, height, core.x, core.y, min * 0.085, LIME, 0.12);
-  drawDisc(data, width, height, core.x, core.y, min * 0.0065, LIME, 0.85);
-  const laneCount = width < 1000 ? 7 : 12;
-  const lanes = Array.from({ length: laneCount }, (_, index) => dispatchLane(width, index, laneCount));
-  lanes.forEach((lane) => {
-    let prev = lanePoint(width, height, lane, 0);
-    for (let step = 1;step <= 32; step += 1) {
-      const next = lanePoint(width, height, lane, step / 32);
-      drawLine2(data, width, height, prev.x, prev.y, next.x, next.y, lane.phase > Math.PI ? CYAN : LIME_DIM, 0.045, Math.max(0.7, min * 0.0009));
-      prev = next;
-    }
-  });
-  const packets = width < 1000 ? 70 : 150;
-  for (let i = 0;i < packets; i += 1) {
-    const lane = lanes[i % lanes.length];
-    const speed = 0.003 + seededUnit(12288 + i * 17) * 0.009;
-    const p = (seededUnit(16384 + i * 19) + tick * speed) % 1;
-    const pt = lanePoint(width, height, lane, p);
-    const wobble = (seededUnit(20480 + i * 23) - 0.5) * min * 0.012;
-    const fade = p < 0.1 ? p / 0.1 : p > 0.88 ? (1 - p) / 0.12 : 1;
-    const color = seededUnit(24576 + i * 29) < 0.22 ? CYAN : LIME_DIM;
-    const y = pt.y + wobble * Math.sin(p * Math.PI * 2);
-    drawLine2(data, width, height, pt.x - min * 0.012, y - min * 0.002, pt.x, y, color, 0.08 * fade, Math.max(0.7, min * 0.0008));
-    drawDisc(data, width, height, pt.x, y, Math.max(1.3, min * 0.0022), color, 0.5 * fade);
-    drawGlow2(data, width, height, pt.x, y, Math.max(4, min * 0.008), color, 0.045 * fade);
-  }
-  for (let i = 0;i < (width < 1000 ? 4 : 8); i += 1) {
-    const lane = lanes[i % lanes.length];
-    const p = (tick * 0.002 + i * 0.13) % 1;
-    const pt = lanePoint(width, height, lane, p);
-    drawDrone(data, width, height, pt.x, pt.y + Math.sin(tick * 0.04 + i) * min * 0.004, min * (0.006 + i % 2 * 0.0015), tick + i * 11, i % 3 === 0 ? CYAN : LIME_DIM);
-  }
-}
-function drawLoopScene(data, width, height, tick) {
-  const min = Math.min(width, height);
-  const y = height * 0.56;
-  const x0 = width * 0.09;
-  const x1 = width * 0.91;
-  drawLine2(data, width, height, x0, y, x1, y, LIME_DIM, 0.12, Math.max(0.8, min * 0.001));
-  const gates = width < 1000 ? 4 : 5;
-  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));
-    const color = i === active ? LIME : i <= active ? LIME_DIM : INK_DIM;
-    drawLine2(data, width, height, x, y - min * 0.05, x, y + min * 0.05, color, i === active ? 0.25 : 0.08, Math.max(0.8, min * 0.001));
-    drawDisc(data, width, height, x, y, i === active ? min * 0.006 : min * 0.0035, color, i === active ? 0.72 : 0.25);
-    drawGlow2(data, width, height, x, y, i === active ? min * 0.018 : min * 0.01, color, i === active ? 0.1 : 0.035);
-  }
-  const packets = width < 1000 ? 36 : 84;
-  for (let i = 0;i < packets; i += 1) {
-    const p = (seededUnit(33024 + i * 13) + tick * (0.0022 + seededUnit(33280 + i * 17) * 0.004)) % 1;
-    const x = x0 + (x1 - x0) * p;
-    const segment = Math.min(gates - 1, Math.floor(p * gates));
-    const color = segment < active ? LIME_DIM : segment === active ? CYAN : INK_DIM;
-    const py = y + (seededUnit(33536 + i * 19) - 0.5) * min * 0.018 * Math.sin(p * Math.PI * 2);
-    drawLine2(data, width, height, x - min * 0.014, py, x, py, color, 0.1, Math.max(0.7, min * 0.0008));
-    drawDisc(data, width, height, x, py, Math.max(1.2, min * 0.002), color, color === INK_DIM ? 0.22 : 0.58);
-  }
-  drawDrone(data, width, height, x0 + (x1 - x0) * (tick * 0.003 % 1), y - min * 0.04, min * 0.0065, tick, LIME_DIM);
-  drawDrone(data, width, height, x0 + (x1 - x0) * ((tick * 0.002 + 0.5) % 1), y + min * 0.036, min * 0.0055, tick + 40, MAGENTA);
-}
-function drawCarrierScene(data, width, height, tick) {
-  const min = Math.min(width, height);
-  const core = sceneCore(width, height, "carrier");
-  drawGlow2(data, width, height, core.x, core.y, min * 0.075, LIME, 0.12);
-  drawDisc(data, width, height, core.x, core.y, min * 0.0065, LIME, 0.92);
-  const nodes = width < 1000 ? 5 : 7;
-  const rx = width * 0.36;
-  const ry = 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;
-    const color = i % 2 ? CYAN : LIME_DIM;
-    drawLine2(data, width, height, core.x, core.y, x, y, color, 0.055, Math.max(0.7, min * 0.0008));
-    drawGlow2(data, width, height, x, y, min * 0.018, color, 0.055);
-    drawDisc(data, width, height, x, y, min * 0.0048, color, 0.62);
-    drawDrone(data, width, height, x, y - min * 0.018, min * 0.005, tick + i * 9, color);
-  }
-  const packets = width < 1000 ? 30 : 72;
-  for (let i = 0;i < packets; i += 1) {
-    const lane = i % 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 p = (seededUnit(37120 + i * 37) + tick * (0.003 + seededUnit(37376 + i * 43) * 0.009)) % 1;
-    const x = core.x + (nx - core.x) * p;
-    const y = core.y + (ny - core.y) * p;
-    const color = seededUnit(37632 + i * 47) < 0.35 ? CYAN : LIME_DIM;
-    drawDisc(data, width, height, x, y, Math.max(1.2, min * 0.002), color, 0.48);
-    drawGlow2(data, width, height, x, y, min * 0.008, color, 0.035);
-  }
-}
-function drawBackground(data, width, height, tick, scene) {
+function drawBackground(data, width, height, _tick, scene, layout) {
   fillRgba(data, BG, BG_WORD);
-  const kind = visualSceneKind(scene);
-  drawGlow2(data, width, height, width * 0.82, height * 0.04, Math.min(width, height) * 0.22, LIME, 0.035);
-  drawGlow2(data, width, height, width * 0.12, height * 0.18, Math.min(width, height) * 0.17, CYAN, 0.025);
-  drawMarketingRails(data, width, height, kind, tick);
-  if (kind === "loop")
-    drawLoopScene(data, width, height, tick);
-  else if (kind === "carrier")
-    drawCarrierScene(data, width, height, tick);
-  else
-    drawDispatchScene(data, width, height, tick);
+  drawStaticAsciiFleetBackground(data, width, height, scene, layout);
+  applyStaticAtmosphere(data, width, height);
 }
 function imageVisualFrameKey(input) {
   const width = Math.max(1, Math.floor(input.pixelSize.width));
@@ -1522,18 +2365,80 @@ function encodeKittyFrame(width, height, data, input) {
     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);
-  drawBackground(data, width, height, input.tick, input.scene);
+  drawBackground(data, width, height, 0, input.scene, input.layout);
+  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 = panelRect2(input.layout, panel, { width, height });
+    const rect = panelRect(input.layout, panel, { width, height });
     if (!rect)
       continue;
     const cellH = height / input.layout.height;
@@ -1542,8 +2447,11 @@ function renderImageVisualFrame(input) {
   }
   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 (process.env.RIG_OPENTUI_IMAGE_WORKER === "0")
+  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);
@@ -1559,24 +2467,8 @@ function createImageWorker() {
   }
 }
 var RECENT_WRITTEN_LIMIT = 24;
-var DEFAULT_PANEL_FPS = 24;
-var DEFAULT_PANEL_LAYER_SCALE = 0.22;
 var DEFAULT_IMAGE_OUTPUT_BACKLOG_BYTES = 256 * 1024;
 var DEFAULT_IMAGE_OUTPUT_BYTES_PER_SECOND = 850 * 1024;
-var MIN_BACKGROUND_BUDGET_BYTES = 24 * 1024;
-var MIN_PANEL_BUDGET_BYTES = 56 * 1024;
-function panelFps() {
-  const raw = Number.parseFloat(process.env.RIG_OPENTUI_PANEL_FPS ?? "");
-  if (Number.isFinite(raw) && raw > 0)
-    return Math.max(4, Math.min(60, raw));
-  return DEFAULT_PANEL_FPS;
-}
-function panelLayerScale() {
-  const raw = Number.parseFloat(process.env.RIG_OPENTUI_PANEL_SCALE ?? "");
-  if (Number.isFinite(raw) && raw > 0)
-    return Math.max(0.18, Math.min(1, raw));
-  return DEFAULT_PANEL_LAYER_SCALE;
-}
 function imageOutputBacklogBytes() {
   const raw = Number.parseInt(process.env.RIG_OPENTUI_IMAGE_BACKLOG_BYTES ?? "", 10);
   if (Number.isFinite(raw) && raw > 0)
@@ -1598,36 +2490,30 @@ class ImageVisualLayer {
   panelImageIds = Array.from({ length: 8 }, () => allocateImageId());
   panelChromeImageIds = Array.from({ length: 8 }, () => allocateImageId());
   stdout;
+  onFrameReady;
   protocol;
   transport = imageTransport();
-  frameIntervalMs = 1000 / imageFps();
-  panelIntervalMs = 1000 / panelFps();
   maxOutputBacklogBytes = imageOutputBacklogBytes();
   outputBytesPerSecond = imageOutputBytesPerSecond();
   outputBudgetBytes = imageOutputBytesPerSecond();
   lastBudgetAtMs = Date.now();
   motionSlot = this.createSlot();
-  panelSlot = this.createSlot();
-  chromeSlot = this.createSlot();
+  workersStarted = false;
   pendingFrames = new Map;
   recentWrittenKeys = [];
   imagesVisible = false;
+  flushPaused = false;
   requestId = 0;
-  lastMotionFrameIndex = -1;
-  lastPanelFrameIndex = -1;
-  lastChromeKey = "";
+  lastBackgroundKey = "";
+  fatalWorkerError = null;
   destroyed = false;
-  constructor(stdout = process.stdout) {
+  constructor(stdout = process.stdout, onFrameReady) {
     this.stdout = stdout;
-    this.protocol = getCapabilities().images;
-    if (this.enabled) {
-      this.startWorker(this.motionSlot);
-      this.startWorker(this.panelSlot);
-      this.startWorker(this.chromeSlot);
-    }
+    this.onFrameReady = onFrameReady;
+    this.protocol = getRigTerminalCapabilities().imageProtocol;
   }
   get enabled() {
-    return isModernImageTerminal(this.protocol);
+    return this.protocol === "kitty";
   }
   clear() {
     if (this.enabled) {
@@ -1637,16 +2523,10 @@ class ImageVisualLayer {
       this.pendingFrames.clear();
       this.recentWrittenKeys.length = 0;
       this.resetSlot(this.motionSlot);
-      this.resetSlot(this.panelSlot);
-      this.resetSlot(this.chromeSlot);
-      this.lastMotionFrameIndex = -1;
-      this.lastPanelFrameIndex = -1;
-      this.lastChromeKey = "";
+      this.lastBackgroundKey = "";
       this.outputBudgetBytes = this.outputBytesPerSecond;
       this.lastBudgetAtMs = Date.now();
       this.motionSlot.clearedThroughRequestId = this.requestId;
-      this.panelSlot.clearedThroughRequestId = this.requestId;
-      this.chromeSlot.clearedThroughRequestId = this.requestId;
     }
   }
   destroy() {
@@ -1654,19 +2534,31 @@ class ImageVisualLayer {
       return;
     this.clear();
     this.destroyed = true;
-    const workers = [this.motionSlot.worker, this.panelSlot.worker, this.chromeSlot.worker];
+    const workers = [this.motionSlot.worker];
     this.motionSlot.worker = null;
-    this.panelSlot.worker = null;
-    this.chromeSlot.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)
@@ -1674,54 +2566,32 @@ class ImageVisualLayer {
     if (this.isOutputBackedUp())
       return;
     this.refillOutputBudget();
-    const now = Date.now();
-    const visualTick = Math.floor(now / (1000 / 60));
-    const useDynamicSplit = Boolean(this.motionSlot.worker && this.panelSlot.worker && this.chromeSlot.worker && this.transport === "png" && process.env.RIG_OPENTUI_DYNAMIC_SPLIT !== "0");
-    if (!useDynamicSplit) {
-      const frameIndex = Math.floor(now / this.frameIntervalMs);
-      if (!input.force && frameIndex === this.lastMotionFrameIndex)
-        return;
-      this.scheduleRender(this.motionSlot, { ...input, tick: visualTick, layer: "full" }, this.imageId, -10, input.force);
-      this.lastMotionFrameIndex = frameIndex;
-      return;
-    }
-    const motionFrameIndex = Math.floor(now / this.frameIntervalMs);
-    if ((input.force || motionFrameIndex !== this.lastMotionFrameIndex) && this.outputBudgetBytes >= MIN_BACKGROUND_BUDGET_BYTES) {
-      this.scheduleRender(this.motionSlot, { ...input, pixelSize: scaledPixelSize(input.pixelSize, droneLayerScale(), input.layout), panels: [], tick: visualTick, layer: "background" }, this.imageId, -30, input.force);
-      this.lastMotionFrameIndex = motionFrameIndex;
-    }
-    const panelFrameIndex = Math.floor(now / this.panelIntervalMs);
-    if ((input.force || panelFrameIndex !== this.lastPanelFrameIndex) && this.outputBudgetBytes >= MIN_PANEL_BUDGET_BYTES) {
-      this.scheduleRender(this.panelSlot, { ...input, pixelSize: scaledPixelSize(input.pixelSize, panelLayerScale(), input.layout), tick: visualTick, layer: "panel-patches" }, this.imageId, -12, input.force, this.panelImageIds);
-      this.lastPanelFrameIndex = panelFrameIndex;
-    }
-    const chromeInput = { ...input, tick: 0, layer: "panel-chrome" };
-    const chromeKey = imageVisualFrameKey(chromeInput);
-    if (input.force || chromeKey !== this.lastChromeKey) {
-      this.scheduleRender(this.chromeSlot, chromeInput, this.imageId, -8, input.force, this.panelChromeImageIds);
-      this.lastChromeKey = chromeKey;
+    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 chrome = this.pendingFrames.get("panel-chrome");
+      const retainedSplit = this.pendingFrames.get("split");
       this.pendingFrames.clear();
-      if (chrome)
-        this.pendingFrames.set("panel-chrome", chrome);
+      if (retainedSplit)
+        this.pendingFrames.set("split", retainedSplit);
       return false;
     }
     const framePriority = (frame) => {
       const layer = pendingLayerKey(frame.key);
-      if (layer === "panel-chrome")
-        return 0;
-      if (layer === "background")
+      if (layer === "split")
         return 1;
-      if (layer === "panel-patches")
-        return 2;
-      return 2;
+      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";
@@ -1733,12 +2603,14 @@ class ImageVisualLayer {
     for (const frame of frames) {
       const candidate = sequence + frame.sequence;
       const candidateBytes = Buffer.byteLength(prefix + candidate + suffix);
-      if (candidateBytes <= this.outputBudgetBytes) {
+      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 (pendingLayerKey(frame.key) === "panel-chrome") {
-        retained.set(pendingLayerKey(frame.key), frame);
+      } else if (layer === "split") {
+        retained.set(layer, frame);
       }
     }
     this.pendingFrames.clear();
@@ -1757,7 +2629,7 @@ class ImageVisualLayer {
     return accepted;
   }
   createSlot() {
-    return { worker: null, busy: false, queuedRequest: null, inFlightKey: "", queuedKey: "", clearedThroughRequestId: 0 };
+    return { worker: null, busy: false, queuedRequest: null, inFlightKey: "", queuedKey: "", clearedThroughRequestId: 0, latestRequestId: 0 };
   }
   resetSlot(slot) {
     slot.busy = false;
@@ -1785,7 +2657,23 @@ class ImageVisualLayer {
   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;
@@ -1798,53 +2686,59 @@ class ImageVisualLayer {
       requestId: ++this.requestId,
       key
     };
-    if (slot.worker) {
-      this.enqueueWorkerRender(slot, request);
+    slot.latestRequestId = request.requestId;
+    if (!slot.worker) {
+      this.renderInline(slot, request);
       return;
     }
-    this.renderSync(slot, request);
+    this.enqueueWorkerRender(slot, request);
   }
-  startWorker(slot) {
+  startWorker(slot, name) {
     const worker = createImageWorker();
     if (!worker)
       return;
     slot.worker = worker;
     worker.on("message", (message) => this.handleWorkerMessage(slot, message));
-    worker.once("error", () => this.disableWorker(slot));
-    worker.once("exit", () => this.disableWorker(slot));
+    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}.`);
+    });
   }
-  disableWorker(slot) {
-    if (this.destroyed)
-      return;
-    slot.worker = null;
-    slot.busy = false;
-    slot.inFlightKey = "";
-    const queued = slot.queuedRequest;
-    slot.queuedRequest = null;
-    slot.queuedKey = "";
-    if (queued?.layer === "full")
-      this.renderSync(slot, queued);
+  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) {
-    if (!slot.worker) {
-      this.renderSync(slot, request);
-      return;
-    }
+    this.throwIfFatal();
     if (slot.busy) {
       slot.queuedRequest = request;
       slot.queuedKey = request.key;
       return;
     }
     this.dispatchWorkerRender(slot, request);
-  }
-  dispatchWorkerRender(slot, request) {
-    if (!slot.worker) {
-      this.renderSync(slot, request);
-      return;
-    }
+  }
+  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;
-    slot.worker.postMessage(request);
+    try {
+      slot.worker.postMessage(request);
+    } catch (error) {
+      this.failWorker(String(request.layer ?? "visual"), error);
+    }
   }
   handleWorkerMessage(slot, message) {
     if (this.destroyed || !message || typeof message !== "object")
@@ -1852,14 +2746,14 @@ class ImageVisualLayer {
     const response = message;
     slot.busy = false;
     slot.inFlightKey = "";
-    if (response.requestId <= slot.clearedThroughRequestId)
-      return;
-    if (response.error) {
-      this.disableWorker(slot);
-      return;
-    }
-    if (response.sequence && !this.isKnownKey(slot, response.key) && (!this.isOutputBackedUp() || pendingLayerKey(response.key) === "panel-chrome")) {
-      this.stageFrame({ key: response.key, sequence: response.sequence });
+    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;
@@ -1867,12 +2761,6 @@ class ImageVisualLayer {
     if (next && !this.isKnownKey(slot, next.key))
       this.dispatchWorkerRender(slot, next);
   }
-  renderSync(slot, request) {
-    const result = renderImageVisualFrame(request);
-    if (!result || this.isKnownKey(slot, result.key) || this.isOutputBackedUp())
-      return;
-    this.stageFrame(result);
-  }
 }
 function pixelSizeForRenderer(renderer) {
   const resolution = renderer.resolution;
@@ -1884,11 +2772,12 @@ function pixelSizeForRenderer(renderer) {
   };
 }
 function forceModernImageVisuals() {
-  return isModernImageTerminal(getCapabilities().images);
+  return getRigTerminalCapabilities().supportsKittyImages;
 }
 
 // packages/cli/src/app-opentui/render/text.ts
-import { TextAttributes as TextAttributes2, TextRenderable } from "@opentui/core";
+import { RGBA as RGBA3, TextAttributes as TextAttributes3, TextRenderable } from "@opentui/core";
+var TRANSPARENT2 = RGBA3.fromInts(0, 0, 0, 0);
 function selectableMouseHandler(currentLineRef, onLineMouseDown) {
   return (event) => {
     const currentLine = currentLineRef();
@@ -1939,7 +2828,8 @@ function applyTextLine(renderable, line, top, left, width) {
   renderable.width = width;
   renderable.content = line?.styledText ?? line?.text ?? "";
   renderable.fg = line?.fg ?? RIG_UI.ink2;
-  renderable.attributes = line?.bold ? TextAttributes2.BOLD : line?.dim ? TextAttributes2.DIM : 0;
+  renderable.bg = line?.bg ?? TRANSPARENT2;
+  renderable.attributes = line?.bold ? TextAttributes3.BOLD : line?.dim ? TextAttributes3.DIM : 0;
 }
 function applyFlowTextLine(renderable, line, width) {
   renderable.setRigSceneLine?.(line);
@@ -1948,7 +2838,8 @@ function applyFlowTextLine(renderable, line, width) {
   renderable.width = Math.max(1, width);
   renderable.content = line?.styledText ?? line?.text ?? "";
   renderable.fg = line?.fg ?? RIG_UI.ink2;
-  renderable.attributes = line?.bold ? TextAttributes2.BOLD : line?.dim ? TextAttributes2.DIM : 0;
+  renderable.bg = line?.bg ?? TRANSPARENT2;
+  renderable.attributes = line?.bold ? TextAttributes3.BOLD : line?.dim ? TextAttributes3.DIM : 0;
 }
 function clearTextLines(renderables, from = 0) {
   for (let index = from;index < renderables.length; index += 1) {
@@ -1958,26 +2849,27 @@ function clearTextLines(renderables, from = 0) {
     renderable.top = -1;
     renderable.left = 0;
     renderable.width = 1;
+    renderable.bg = TRANSPARENT2;
   }
 }
 
 // packages/cli/src/app-opentui/render/panels.ts
-import { RGBA as RGBA2, ScrollBoxRenderable } from "@opentui/core";
-var TRANSPARENT2 = RGBA2.fromInts(0, 0, 0, 0);
+import { RGBA as RGBA4, ScrollBoxRenderable } from "@opentui/core";
+var TRANSPARENT3 = RGBA4.fromInts(0, 0, 0, 0);
 var MAX_PANEL_LINES = 420;
 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 RGBA2.fromInts(14, 15, 17, alpha);
-  return RGBA2.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255, alpha);
+    return RGBA4.fromInts(14, 15, 17, alpha);
+  return RGBA4.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255, alpha);
 }
 function panelBackground(panel) {
   return hexToRgba(panel.backgroundColor ?? RIG_UI.panel, panel.backgroundAlpha ?? 184);
 }
 function panelBorder(panel) {
-  return panel.borderColor ? hexToRgba(panel.borderColor, panel.borderAlpha ?? 54) : TRANSPARENT2;
+  return panel.borderColor ? hexToRgba(panel.borderColor, panel.borderAlpha ?? 54) : TRANSPARENT3;
 }
 function createScrollPanelLayer(renderer, id, onLineMouseDown) {
   const panel = new ScrollBoxRenderable(renderer, {
@@ -1987,7 +2879,7 @@ function createScrollPanelLayer(renderer, id, onLineMouseDown) {
     top: -2,
     width: 1,
     height: 1,
-    backgroundColor: TRANSPARENT2,
+    backgroundColor: TRANSPARENT3,
     border: false,
     shouldFill: true,
     opacity: 1,
@@ -2003,7 +2895,7 @@ function createScrollPanelLayer(renderer, id, onLineMouseDown) {
       visible: false,
       width: 1,
       trackOptions: {
-        backgroundColor: TRANSPARENT2,
+        backgroundColor: TRANSPARENT3,
         foregroundColor: hexToRgba(RIG_UI.ink4, 84)
       }
     },
@@ -2011,18 +2903,24 @@ function createScrollPanelLayer(renderer, id, onLineMouseDown) {
       height: 0,
       visible: false,
       trackOptions: {
-        backgroundColor: TRANSPARENT2,
-        foregroundColor: TRANSPARENT2
+        backgroundColor: TRANSPARENT3,
+        foregroundColor: TRANSPARENT3
       }
     }
   });
   panel.__rigTextLines = [];
-  for (let index = 0;index < MAX_PANEL_LINES; index += 1) {
-    const line = createFlowTextLine(renderer, `${id}-line-${index}`, onLineMouseDown);
+  panel.__rigRenderer = renderer;
+  panel.__rigOnLineMouseDown = onLineMouseDown;
+  return panel;
+}
+function ensurePanelLineCount(panel, desiredCount) {
+  const target = Math.min(MAX_PANEL_LINES, Math.max(0, desiredCount));
+  while (panel.__rigTextLines.length < target) {
+    const index = panel.__rigTextLines.length;
+    const line = createFlowTextLine(panel.__rigRenderer, `${panel.id}-line-${index}`, panel.__rigOnLineMouseDown);
     panel.__rigTextLines.push(line);
     panel.add(line);
   }
-  return panel;
 }
 function hidePanel(panel) {
   panel.visible = false;
@@ -2030,7 +2928,7 @@ function hidePanel(panel) {
   panel.left = 0;
   panel.width = 1;
   panel.height = 1;
-  panel.backgroundColor = TRANSPARENT2;
+  panel.backgroundColor = TRANSPARENT3;
   panel.border = false;
   panel.__rigPanelId = undefined;
   panel.__rigTextLines.forEach((line) => applyFlowTextLine(line, undefined, 1));
@@ -2042,19 +2940,12 @@ function applyScrollPanels(panels, layout, scenePanels) {
       hidePanel(renderable);
       return;
     }
-    const cardLeft = Math.max(0, Math.min(layout.width - 1, layout.centerLeft + (panel.left ?? 0)));
-    const desiredWidth = panel.width ?? layout.centerWidth;
-    const cardWidth = Math.max(1, Math.min(layout.width - cardLeft, desiredWidth));
-    const cardTop = Math.max(0, Math.min(layout.height - 1, layout.centerTop + panel.top));
-    const cardHeight = Math.max(1, Math.min(layout.height - cardTop, panel.height));
-    const headerHeight = panel.chrome === "ad-terminal" ? Math.max(3, Math.min(cardHeight - 2, panel.headerHeight ?? 3)) : 0;
-    const left = cardLeft + (panel.chrome === "ad-terminal" ? 1 : 0);
-    const top = cardTop + headerHeight + (panel.chrome === "ad-terminal" ? 1 : 0);
-    const width = Math.max(1, Math.min(layout.width - left, cardWidth - (panel.chrome === "ad-terminal" ? 2 : 0)));
-    const height = Math.max(1, Math.min(layout.height - top, cardHeight - headerHeight - (panel.chrome === "ad-terminal" ? 2 : 0)));
-    const paddingX = panel.paddingX ?? (panel.chrome === "ad-terminal" ? 5 : 2);
-    const paddingY = panel.paddingY ?? (panel.chrome === "ad-terminal" ? 2 : 1);
-    const contentWidth = Math.max(1, width - paddingX * 2 - 1);
+    const contentRect = panelContentRect(layout, panel);
+    if (!contentRect) {
+      hidePanel(renderable);
+      return;
+    }
+    const { left, top, width, height, paddingX, paddingY, contentWidth } = contentRect;
     renderable.visible = true;
     renderable.left = left;
     renderable.top = top;
@@ -2062,7 +2953,7 @@ function applyScrollPanels(panels, layout, scenePanels) {
     renderable.height = height;
     renderable.zIndex = panel.zIndex ?? 6;
     renderable.opacity = panel.opacity ?? 1;
-    renderable.backgroundColor = panel.chrome === "ad-terminal" ? TRANSPARENT2 : panelBackground(panel);
+    renderable.backgroundColor = panel.chrome === "ad-terminal" ? TRANSPARENT3 : panelBackground(panel);
     renderable.border = panel.chrome === "ad-terminal" ? false : panel.border ?? false;
     renderable.borderColor = panelBorder(panel);
     renderable.paddingX = paddingX;
@@ -2075,56 +2966,31 @@ function applyScrollPanels(panels, layout, scenePanels) {
       renderable.__rigPanelId = panel.id;
       renderable.scrollTo(0);
     }
+    const lineCount = Math.min(panel.lines.length, MAX_PANEL_LINES);
+    ensurePanelLineCount(renderable, lineCount);
     renderable.__rigTextLines.forEach((line, lineIndex) => {
-      applyFlowTextLine(line, panel.lines[lineIndex], contentWidth);
+      applyFlowTextLine(line, lineIndex < lineCount ? panel.lines[lineIndex] : undefined, contentWidth);
     });
   });
 }
 
 // packages/cli/src/app-opentui/render/type-bar.ts
-import { InputRenderable, InputRenderableEvents, TextRenderable as TextRenderable2 } from "@opentui/core";
-function createTypeBar(renderer) {
-  const prefix = new TextRenderable2(renderer, {
-    id: "rig-typebar-prefix",
-    content: " rig \u203A",
-    position: "absolute",
-    left: 0,
-    top: 0,
-    fg: RIG_UI.lime,
-    selectable: true
-  });
-  const input = new InputRenderable(renderer, {
-    id: "rig-typebar-input",
-    position: "absolute",
-    left: 7,
-    top: 0,
-    width: 40,
-    placeholder: "fleet \xB7 tasks \xB7 run next \xB7 help",
-    textColor: RIG_UI.ink,
-    cursorColor: RIG_UI.lime,
-    cursorStyle: { style: "block", blinking: false },
-    showCursor: true,
-    selectable: true
-  });
-  const footer = new TextRenderable2(renderer, {
-    id: "rig-footer",
-    content: "",
-    position: "absolute",
-    left: 0,
-    top: 1,
-    width: "100%",
-    fg: RIG_UI.ink4,
-    selectable: true
-  });
-  input.focus();
-  return { input, prefix, footer };
-}
+import { BoxRenderable, InputRenderable, InputRenderableEvents, RGBA as RGBA5, TextRenderable as TextRenderable2 } from "@opentui/core";
+var TYPEBAR_BG = RGBA5.fromInts(20, 25, 14, 224);
+var TYPEBAR_BORDER = RGBA5.fromInts(204, 255, 77, 92);
 function positionTypeBar(renderables, input, footer, width, typeBarTop, footerTop) {
-  renderables.prefix.content = " rig \u203A";
+  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 = " \u203A";
+  renderables.prefix.left = 2;
   renderables.prefix.top = typeBarTop;
   renderables.input.top = typeBarTop;
-  renderables.input.left = 7;
-  renderables.input.width = Math.max(10, width - 9);
+  renderables.input.left = 5;
+  renderables.input.width = Math.max(10, width - 8);
   renderables.input.placeholder = input.placeholder;
   renderables.input.showCursor = true;
   renderables.footer.top = footerTop;
@@ -2134,6 +3000,8 @@ function positionTypeBar(renderables, input, footer, width, typeBarTop, footerTo
     renderables.input.focus();
 }
 function hideTypeBar(renderables, height) {
+  renderables.background.visible = false;
+  renderables.background.top = height + 1;
   renderables.prefix.content = "";
   renderables.prefix.top = height + 1;
   renderables.input.value = "";
@@ -2145,17 +3013,22 @@ function hideTypeBar(renderables, height) {
   renderables.footer.content = "";
   renderables.footer.top = height + 1;
 }
-function bindTypeBar(renderables, handlers) {
-  renderables.input.on(InputRenderableEvents.INPUT, (value) => handlers.onInput(value));
-  renderables.input.on(InputRenderableEvents.ENTER, (value) => handlers.onEnter(value));
+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 formatFooter(footer, width) {
+  const safeMessage = safeFooterMessage(footer.message);
   const parts = [
-    footer.project ? `project ${footer.project}` : null,
-    footer.server ? `server ${footer.server}` : null,
-    footer.auth ? `auth ${footer.auth}` : null,
+    footer.project ? "workspace" : null,
+    footer.server ? "server selected" : null,
+    footer.auth ? "auth ready" : null,
     footer.run ? `run ${footer.run}` : null,
-    footer.message ?? null
+    safeMessage
   ].filter((part) => Boolean(part));
   return ` ${truncateText(parts.join("  \xB7  "), Math.max(8, width - 2))}`;
 }
@@ -2167,9 +3040,6 @@ function line(text, options = {}) {
 function blank() {
   return { text: "" };
 }
-function center(text, fg = RIG_UI.ink2, bold = false) {
-  return { text, fg, bold, align: "center" };
-}
 function deckRow(input) {
   const prefix = input.active ? "\u25B8" : " ";
   const label = input.label.toUpperCase().padEnd(10);
@@ -2180,6 +3050,9 @@ function deckRow(input) {
     activateOnClick: input.activateOnClick
   });
 }
+function kv(label, value, fg = RIG_UI.ink2) {
+  return line(`  ${label.toUpperCase().padEnd(10)} ${value}`, { fg });
+}
 function fitSceneLine(input, layout) {
   const fitted = truncateText(input.text, layout.centerWidth);
   return {
@@ -2194,9 +3067,52 @@ function makeSceneFrame(input) {
   return input;
 }
 
+// packages/cli/src/app-opentui/render/preloader.ts
+var PRELOADER_MIN_DURATION_MS = 520;
+var PRELOADER_MAX_DURATION_MS = 5000;
+function maybeStartPreloaderTransition(transition, scene, now = Date.now()) {
+  if (transition.scene === scene)
+    return;
+  transition.scene = scene;
+  transition.startedAtMs = now;
+  transition.minUntilMs = now + PRELOADER_MIN_DURATION_MS;
+}
+function isPreloaderActive(transition, targetReady, now = Date.now()) {
+  if (now < transition.minUntilMs)
+    return true;
+  if (!targetReady && now - transition.startedAtMs < PRELOADER_MAX_DURATION_MS)
+    return true;
+  return false;
+}
+function preloaderLine(line2, options = {}) {
+  return { text: line2, bg: RIG_UI.bg, ...options };
+}
+function blockLine(text, leftPad, fg) {
+  return preloaderLine(`${" ".repeat(Math.max(0, leftPad))}${text.padEnd(FLEET_GRID_WIDTH)}`, { fg });
+}
+function renderAsciiPreloaderFrame(scene, layout, tick) {
+  const sprite = fleetRows(tick);
+  const leftPad = Math.max(0, Math.floor((layout.width - FLEET_GRID_WIDTH) / 2));
+  const blank2 = () => preloaderLine("");
+  const body = [
+    ...sprite.map((text, index) => blockLine(text, leftPad, index >= 7 && index <= 18 ? RIG_UI.lime : RIG_UI.limeDim))
+  ];
+  const topPadding = Math.max(0, Math.floor((layout.height - body.length) / 2));
+  const bottomPadding = Math.max(0, layout.height - body.length - topPadding);
+  return {
+    scene,
+    title: "Preloader",
+    lines: [...Array.from({ length: topPadding }, blank2), ...body, ...Array.from({ length: bottomPadding }, blank2)],
+    live: true,
+    fullScreen: true,
+    hideTypeBar: true,
+    footer: { message: "" }
+  };
+}
+
 // packages/cli/src/app-opentui/drone.ts
-import { RGBA as RGBA3, StyledText, TextAttributes as TextAttributes3 } from "@opentui/core";
-var MINI_DRONE = [
+import { RGBA as RGBA6, StyledText as StyledText2, TextAttributes as TextAttributes4 } from "@opentui/core";
+var MINI_DRONE2 = [
   "(!!!)   (!!!)",
   "  \\%==%/  ",
   "   %%?%%   ",
@@ -2211,13 +3127,13 @@ var LEAD_MARK = [
 var BLADE_FRAMES = ["---", "\\\\\\", "|||", "///"];
 var EYE_FRAMES = ["o", "@", "\u2022", "."];
 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)
+  body: RGBA6.fromHex(RIG_UI.lime),
+  mini: RGBA6.fromHex(RIG_UI.limeDim),
+  rotor: RGBA6.fromHex(RIG_UI.cyan),
+  path: RGBA6.fromHex(RIG_UI.cyan),
+  eye: RGBA6.fromHex(RIG_UI.ink),
+  dim: RGBA6.fromHex(RIG_UI.ink4),
+  ink: RGBA6.fromHex(RIG_UI.ink2)
 };
 function bladeForTick(tick, phase = 0) {
   return BLADE_FRAMES[(Math.floor(tick / 3) + phase) % BLADE_FRAMES.length];
@@ -2227,12 +3143,12 @@ function eyeForTick(tick, phase = 0) {
   return pulse > 0.55 ? EYE_FRAMES[1] : pulse > 0.1 ? EYE_FRAMES[0] : pulse > -0.45 ? EYE_FRAMES[2] : EYE_FRAMES[3];
 }
 function chunk2(text, fg, bold = false, dim = false) {
-  let attributes = TextAttributes3.NONE;
+  let attributes = TextAttributes4.NONE;
   if (bold)
-    attributes |= TextAttributes3.BOLD;
+    attributes |= TextAttributes4.BOLD;
   if (dim)
-    attributes |= TextAttributes3.DIM;
-  return { __isChunk: true, text, fg, ...attributes !== TextAttributes3.NONE ? { attributes } : {} };
+    attributes |= TextAttributes4.DIM;
+  return { __isChunk: true, text, fg, ...attributes !== TextAttributes4.NONE ? { attributes } : {} };
 }
 function styledLine(text, colorFor) {
   const chunks = [];
@@ -2244,600 +3160,312 @@ function styledLine(text, colorFor) {
     chunks.push(chunk2(run, COLOR[runColor], runColor === "body" || runColor === "eye", runColor === "dim"));
     run = "";
   };
-  for (const char of text) {
-    const next = colorFor(char);
-    if (next !== runColor) {
-      flush();
-      runColor = next;
-    }
-    run += char;
-  }
-  flush();
-  return new StyledText(chunks.length > 0 ? chunks : [chunk2("", COLOR.ink)]);
-}
-function droneColor(char) {
-  if (char === "?" || char === "o" || char === "@" || char === "\u2022")
-    return "eye";
-  if (char === "%" || char === "=")
-    return "mini";
-  if (char === "$")
-    return "body";
-  if (char === "(" || char === ")" || char === "/" || char === "\\" || char === "|" || char === "-")
-    return "rotor";
-  if (char === "\xB7" || char === "\u2022" || char === "'" || char === ".")
-    return "path";
-  if (char.trim() === "")
-    return "dim";
-  return "ink";
-}
-function motionColor(char) {
-  if (char === "\u25CF" || char === "\u25C6" || char === "\u25C9")
-    return "body";
-  if (char === "\u2022" || char === "\xB7" || char === "\u2500" || char === "\u2502" || char === "\u2571" || char === "\u2572" || char === "\u256D" || char === "\u256E" || char === "\u2570" || char === "\u256F")
-    return "path";
-  if (char === "\u258C" || char === "\u2590" || char === "\u2581" || char === "\u2594")
-    return "mini";
-  return droneColor(char);
-}
-function materializeDrone(lines, tick, phase = 0) {
-  const blade = bladeForTick(tick, phase);
-  const eye = eyeForTick(tick, phase);
-  return lines.map((line2) => line2.replaceAll("!!!", blade).replaceAll("?", eye));
-}
-function brandFleetLines(tick, align = "center") {
-  const left = materializeDrone(MINI_DRONE, tick, 0);
-  const right = materializeDrone(MINI_DRONE, tick, 2);
-  const lead = materializeDrone(LEAD_MARK, tick, 1);
-  const packet = ["\xB7", "\u2022", "\u25CF", "\u2022"][Math.floor(tick / 2) % 4];
-  const bridge = [
-    `    ${left[0]}       ${lead[0]}       ${right[0]}`,
-    `    ${left[1]}   \xB7\u2500\u2500${packet}\u2500\u2500\xB7   ${lead[1]}   \xB7\u2500\u2500${packet}\u2500\u2500\xB7   ${right[1]}`,
-    `    ${left[2]}  \xB7'       '${lead[2]}'       '\xB7  ${right[2]}`,
-    `    ${left[3]}       \u2572  signal bus  \u2571       ${right[3]}`,
-    `    ${left[4]}    \xB7\u2500\u2500\u2500${packet}\u2500\u2500\u2500\u2500\u2500\u2500${packet}\u2500\u2500\u2500\xB7    ${right[4]}`
-  ];
-  return bridge.map((text) => ({
-    text,
-    styledText: styledLine(text, motionColor),
-    fg: RIG_UI.limeDim,
-    align
-  }));
-}
-function errorDrone(tick) {
-  return brandFleetLines(tick).map((line2, index) => ({
-    ...line2,
-    fg: index % 2 === 0 ? RIG_UI.red : line2.fg
-  }));
-}
-
-// packages/cli/src/app-opentui/scenes/error.ts
-function renderErrorScene(state) {
-  const message = state.error?.message ?? "Unknown Rig app error";
-  const hint = state.error?.hint ?? "type main, help, or retry after fixing the issue";
-  return makeSceneFrame({
-    scene: "error",
-    title: "Rig error",
-    lines: [
-      ...errorDrone(state.tick).slice(2, 16),
-      blank(),
-      center("DRONE SIGNAL DEGRADED", RIG_UI.red, true),
-      center(message, RIG_UI.ink2),
-      blank(),
-      center(hint, RIG_UI.limeDim)
-    ],
-    typeBarPlaceholder: hint,
-    live: true
-  });
-}
-
-// packages/cli/src/app-opentui/scenes/help.ts
-var COMMANDS = [
-  ["runs", "show runs"],
-  ["tasks", "show task source"],
-  ["type in Runs", "search loaded runs"],
-  ["type in Tasks", "search loaded tasks"],
-  ["tasks open", "filter to open tasks"],
-  ["tasks all", "show every task returned by the source"],
-  ["tasks mine", "show tasks assigned to @me"],
-  ["tasks blocked", "show blocked work"],
-  ["tasks closed", "show closed work"],
-  ["tasks sort priority", "rank by priority"],
-  ["tasks sort recency", "rank by update time"],
-  ["tasks sort status", "group by status"],
-  ["run <task-id>", "dispatch selected task id"],
-  ["run next", "dispatch next runnable task"],
-  ["attach <run>", "open bundled Pi for a run"],
-  ["tab / \u2192", "next screen"],
-  ["\u2190", "previous screen"],
-  ["\u2191 \u2193", "move selection in Runs/Tasks"],
-  ["j k", "move selection outside search-first list screens"],
-  ["enter", "activate selected row"],
-  ["mouse wheel", "scroll panel under cursor"],
-  ["ctrl-]", "detach from embedded Pi"],
-  ["ctrl-c / q", "exit"]
-];
-function panelWidth(layout) {
-  return layout?.centerWidth ?? 100;
-}
-function panelHeight(layout, top = 3) {
-  return Math.max(4, (layout?.centerHeight ?? 24) - top);
-}
-function clip(value, width) {
-  if (width <= 0)
-    return "";
-  return value.length <= width ? value : `${value.slice(0, Math.max(0, width - 1))}\u2026`;
-}
-function commandRow(width, label, detail, index) {
-  const keyWidth = Math.min(22, Math.max(12, Math.floor(width * 0.28)));
-  const key = clip(label, keyWidth).padEnd(keyWidth);
-  return line(`${key}  ${clip(detail, Math.max(8, width - keyWidth - 4))}`, { fg: index < 3 ? RIG_UI.ink : RIG_UI.ink2 });
-}
-function unsupportedCommand(state) {
-  const value = state.intent.action.payload?.unsupported ?? state.intent.action.payload?.unknown;
-  return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function renderHelpScene(state, layout) {
-  const width = panelWidth(layout);
-  const unsupported = unsupportedCommand(state);
-  const panelTop = 0;
-  const panelLines = [
-    ...unsupported ? [
-      line(`${unsupported} uses the plain CLI path.`, { fg: RIG_UI.yellow, bold: true }),
-      line("Exit and rerun with RIG_PLAIN=1 if you want legacy text output.", { fg: RIG_UI.ink3 }),
-      line("", { fg: RIG_UI.ink3 })
-    ] : [],
-    line("COMMAND                 ACTION", { fg: RIG_UI.ink3, bold: true }),
-    line("", { fg: RIG_UI.ink3 }),
-    ...COMMANDS.map(([label, detail], index) => commandRow(width - 6, label, detail, index))
-  ];
-  return makeSceneFrame({
-    scene: "help",
-    title: "Rig help",
-    lines: [
-      line("", { fg: RIG_UI.ink4 }),
-      line("   rig help", { fg: RIG_UI.ink3 })
-    ],
-    panels: [{
-      id: "help-reference",
-      top: panelTop,
-      width,
-      height: panelHeight(layout, panelTop),
-      lines: panelLines,
-      backgroundColor: RIG_UI.panel,
-      backgroundAlpha: 184,
-      opacity: 1,
-      border: false,
-      chrome: "ad-terminal",
-      headerText: "rig help",
-      headerHeight: 3,
-      paddingX: layout?.compact ? 2 : 3,
-      paddingY: 1
-    }],
-    typeBarPlaceholder: "runs \xB7 tasks \xB7 help \xB7 attach <run>",
-    footer: { message: "help" },
-    live: true
-  });
-}
-
-// packages/cli/src/app-opentui/scenes/main.ts
-var CONFIGURED_OPTIONS = [
-  ["runs", "run list and attach"],
-  ["tasks", "task source and dispatch"],
-  ["help", "command reference"]
-];
-function renderMainScene(state) {
-  const configured = state.data.projectConfigured === true;
-  const selected = configured ? Math.max(0, Math.min(CONFIGURED_OPTIONS.length - 1, state.selection.index)) : Math.max(0, Math.min(1, state.selection.index));
-  const lines = [
-    center(configured ? "rig" : "rig setup", RIG_UI.ink, true),
-    center(configured ? "runs \xB7 tasks \xB7 help" : "initialize this repo", RIG_UI.ink3),
-    blank()
-  ];
-  if (!configured) {
-    lines.push(deckRow({ label: "init", detail: "create config and server link", index: 0, active: selected === 0 }), deckRow({ label: "help", detail: "show command reference", index: 1, active: selected === 1 }), blank(), line("enter opens selection", { fg: RIG_UI.ink4, align: "center" }));
-  } else {
-    CONFIGURED_OPTIONS.forEach(([label, detail], index) => {
-      lines.push(deckRow({ label, detail, index, active: index === selected }));
-    });
-    lines.push(blank(), line(`  ${state.actionLabel ?? "ready"}`, { fg: state.status === "action" ? RIG_UI.cyan : RIG_UI.ink4 }));
-  }
-  return makeSceneFrame({
-    scene: "main",
-    title: "Rig",
-    lines,
-    typeBarPlaceholder: configured ? "runs \xB7 tasks \xB7 help" : "init \xB7 help",
-    live: true
-  });
-}
-
-// packages/cli/src/app-opentui/pi-pty-host.ts
-import { fileURLToPath } from "url";
-import { basename } from "path";
-import { RGBA as RGBA4, StyledText as StyledText2, TextAttributes as TextAttributes4 } from "@opentui/core";
-import { Terminal as XtermTerminal } from "@xterm/headless";
-var MIN_COLS = 40;
-var MIN_ROWS = 12;
-var MAX_ROWS = 300;
-var MAX_SNAPSHOT_LINES = 360;
-var STYLED_SNAPSHOT_MARGIN = 24;
-var SNAPSHOT_DELAY_MS = 33;
-var fallbackChildScriptPath = fileURLToPath(new URL("./pi-host-child.ts", import.meta.url));
-var activeHost = null;
-function clampCols(cols) {
-  return Math.max(MIN_COLS, Math.trunc(cols || 100));
-}
-function clampRows(rows) {
-  return Math.max(MIN_ROWS, Math.min(MAX_ROWS, 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 RGBA4.fromIndex(value);
-  }
-  if (mode === 3 || mode === XTERM_COLOR_MODE_RGB) {
-    return RGBA4.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255);
-  }
-  return;
-}
-function textAttributesFromCell(cell) {
-  let attributes = TextAttributes4.NONE;
-  if (cell.isBold())
-    attributes |= TextAttributes4.BOLD;
-  if (cell.isDim())
-    attributes |= TextAttributes4.DIM;
-  if (cell.isItalic())
-    attributes |= TextAttributes4.ITALIC;
-  if (cell.isUnderline())
-    attributes |= TextAttributes4.UNDERLINE;
-  if (cell.isBlink())
-    attributes |= TextAttributes4.BLINK;
-  if (cell.isInverse())
-    attributes |= TextAttributes4.INVERSE;
-  if (cell.isInvisible())
-    attributes |= TextAttributes4.HIDDEN;
-  if (cell.isStrikethrough())
-    attributes |= TextAttributes4.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(line2, cols) {
-  if (!line2)
-    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 = line2.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)) {
+  for (const char of text) {
+    const next = colorFor(char);
+    if (next !== runColor) {
       flush();
-      runStyle = style;
+      runColor = next;
     }
-    run += cell.getChars() || " ";
+    run += char;
   }
   flush();
-  return new StyledText2(chunks.length > 0 ? chunks : [{ __isChunk: true, text: "" }]);
-}
-function childCommandPrefix() {
-  const execName = basename(process.execPath).toLowerCase();
-  const currentEntry = process.argv[1];
-  if ((execName === "bun" || execName === "bun.exe") && currentEntry) {
-    return [process.execPath, currentEntry, "__opentui-pi-host"];
-  }
-  if (currentEntry)
-    return [process.execPath, "__opentui-pi-host"];
-  return [process.execPath, fallbackChildScriptPath];
+  return new StyledText2(chunks.length > 0 ? chunks : [chunk2("", COLOR.ink)]);
 }
-function withEnv(base) {
-  const env = {};
-  for (const [key, value] of Object.entries(base ?? process.env)) {
-    if (key === "RIG_PLAIN" || key === "RIG_CLI_PLAIN_HELP")
-      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"
-  };
+function droneColor(char) {
+  if (char === "?" || char === "o" || char === "@" || char === "\u2022")
+    return "eye";
+  if (char === "%" || char === "=")
+    return "mini";
+  if (char === "$")
+    return "body";
+  if (char === "(" || char === ")" || char === "/" || char === "\\" || char === "|" || char === "-")
+    return "rotor";
+  if (char === "\xB7" || char === "\u2022" || char === "'" || char === ".")
+    return "path";
+  if (char.trim() === "")
+    return "dim";
+  return "ink";
 }
-function getActivePiHost() {
-  return activeHost && !activeHost.disposed ? activeHost : null;
+function motionColor(char) {
+  if (char === "\u25CF" || char === "\u25C6" || char === "\u25C9")
+    return "body";
+  if (char === "\u2022" || char === "\xB7" || char === "\u2500" || char === "\u2502" || char === "\u2571" || char === "\u2572" || char === "\u256D" || char === "\u256E" || char === "\u2570" || char === "\u256F")
+    return "path";
+  if (char === "\u258C" || char === "\u2590" || char === "\u2581" || char === "\u2594")
+    return "mini";
+  return droneColor(char);
 }
-function stopActivePiHost(reason = "detach") {
-  activeHost?.dispose(reason);
-  activeHost = null;
+function materializeDrone(lines, tick, phase = 0) {
+  const blade = bladeForTick(tick, phase);
+  const eye = eyeForTick(tick, phase);
+  return lines.map((line2) => line2.replaceAll("!!!", blade).replaceAll("?", eye));
 }
-
-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";
-  exitCode;
-  signal;
-  notifyTimer = null;
-  _disposed = false;
-  constructor(options) {
-    this.runId = options.runId;
-    this.projectRoot = options.projectRoot;
-    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: 5000
-    });
-    this.registerTerminalResponders();
-  }
-  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. Rig OpenTUI Pi host requires Bun.Terminal.");
-    }
-    const spawnOptions = {
-      cwd: this.projectRoot,
-      env: withEnv(process.env),
-      terminal: {
-        cols: this.cols,
-        rows: this.rows,
-        name: "xterm-256color",
-        data: (_terminal, data) => this.handlePtyData(data)
-      }
-    };
-    const proc = Bun.spawn([
-      ...childCommandPrefix(),
-      "--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 Rig";
-    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 (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);
-  }
-  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 (activeHost === this)
-      activeHost = 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, () => 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 styledStart = Math.max(start, end - this.rows - STYLED_SNAPSHOT_MARGIN);
-    const lines = [];
-    const styledLines = [];
-    for (let row = start;row < end; row += 1) {
-      const line2 = buffer.getLine(row);
-      lines.push((line2?.translateToString(false) ?? "").slice(0, this.cols));
-      if (row >= styledStart)
-        styledLines[lines.length - 1] = lineToStyledText(line2, this.cols);
-    }
-    while (lines.length < this.rows) {
-      lines.push("");
-      styledLines[lines.length - 1] = new StyledText2([{ __isChunk: true, text: "" }]);
-    }
-    return {
-      runId: this.runId,
-      status: this.status,
-      cols: this.cols,
-      rows: this.rows,
+function brandFleetLines(tick, align = "center") {
+  const left = materializeDrone(MINI_DRONE2, tick, 0);
+  const right = materializeDrone(MINI_DRONE2, tick, 2);
+  const lead = materializeDrone(LEAD_MARK, tick, 1);
+  const packet = ["\xB7", "\u2022", "\u25CF", "\u2022"][Math.floor(tick / 2) % 4];
+  const bridge = [
+    `    ${left[0]}       ${lead[0]}       ${right[0]}`,
+    `    ${left[1]}   \xB7\u2500\u2500${packet}\u2500\u2500\xB7   ${lead[1]}   \xB7\u2500\u2500${packet}\u2500\u2500\xB7   ${right[1]}`,
+    `    ${left[2]}  \xB7'       '${lead[2]}'       '\xB7  ${right[2]}`,
+    `    ${left[3]}       \u2572  signal bus  \u2571       ${right[3]}`,
+    `    ${left[4]}    \xB7\u2500\u2500\u2500${packet}\u2500\u2500\u2500\u2500\u2500\u2500${packet}\u2500\u2500\u2500\xB7    ${right[4]}`
+  ];
+  return bridge.map((text) => ({
+    text,
+    styledText: styledLine(text, motionColor),
+    fg: RIG_UI.limeDim,
+    align
+  }));
+}
+function errorDrone(tick) {
+  return brandFleetLines(tick).map((line2, index) => ({
+    ...line2,
+    fg: index % 2 === 0 ? RIG_UI.red : line2.fg
+  }));
+}
+
+// packages/cli/src/app-opentui/scenes/error.ts
+function renderErrorScene(state) {
+  const message = state.error?.message ?? "Unknown app error";
+  const hint = state.error?.hint ?? "Use the actions below to recover.";
+  const selected = Math.max(0, Math.min(3, state.selection.index));
+  return makeSceneFrame({
+    scene: "error",
+    title: "Error",
+    lines: [
+      ...errorDrone(state.tick).slice(2, 10)
+    ],
+    panels: [{
+      id: "error-recovery",
+      top: 2,
+      width: 96,
+      height: 18,
+      lines: [
+        line("DRONE SIGNAL DEGRADED", { fg: RIG_UI.red, bold: true }),
+        line(message, { fg: RIG_UI.ink2 }),
+        ...hint ? [line(hint, { fg: RIG_UI.yellow })] : [],
+        line("", { fg: RIG_UI.ink3 }),
+        line("ACTIONS", { fg: RIG_UI.ink3, bold: true }),
+        deckRow({ label: "main", detail: "return to dashboard", index: 0, active: selected === 0, activateOnClick: true }),
+        deckRow({ label: "doctor", detail: "run diagnostics", index: 1, active: selected === 1, activateOnClick: true }),
+        deckRow({ label: "server", detail: "open server controls", index: 2, active: selected === 2, activateOnClick: true }),
+        deckRow({ label: "repair", detail: "repair project/server/auth link", index: 3, active: selected === 3, activateOnClick: true })
+      ],
+      backgroundColor: RIG_UI.panel,
+      backgroundAlpha: 184,
+      opacity: 1,
+      border: false,
+      chrome: "ad-terminal",
+      headerText: "recovery",
+      headerHeight: 3,
+      paddingX: 3,
+      paddingY: 1
+    }],
+    footer: { message: "enter/click a recovery action" },
+    hideTypeBar: true,
+    live: true
+  });
+}
+
+// packages/cli/src/app-opentui/scenes/help.ts
+var ACTIONS = [
+  ["runs", "show live/completed runs"],
+  ["tasks", "browse task source and dispatch work"],
+  ["run next", "dispatch next runnable task"],
+  ["server", "local/remote server controls"],
+  ["init", "setup/reconfigure/repair wizard"],
+  ["doctor", "diagnose project/server/auth"],
+  ["github", "GitHub auth/repo actions"],
+  ["plugin", "plugin and source actions"],
+  ["setup", "bootstrap/check/preflight"],
+  ["inspect", "inspect project/server state"],
+  ["stats", "run/task metrics"],
+  ["repo", "repo utilities"],
+  ["profile", "profile/config actions"],
+  ["review", "review automation"],
+  ["browser", "browser tooling/wizards"],
+  ["pi", "Pi install/attach/status"],
+  ["queue", "queue operations"],
+  ["agent", "agent/runtime operations"],
+  ["inspector", "inspector tools"],
+  ["dist", "distribution helpers"],
+  ["workspace", "workspace/project utilities"],
+  ["remote", "remote endpoint utilities"],
+  ["git", "git helper actions"],
+  ["harness", "harness operations"],
+  ["test", "test helpers"]
+];
+var SHORTCUTS = [
+  ["tab / \u2192", "next workspace"],
+  ["\u2190 / esc", "previous/back or clear search"],
+  ["\u2191 \u2193 / j k", "move selection"],
+  ["enter / space / click", "activate selected action"],
+  ["mouse wheel", "scroll panel under cursor"],
+  ["ctrl-]", "detach from embedded Pi/command terminal"],
+  ["ctrl-c / q", "exit"]
+];
+function panelWidth(layout) {
+  return layout?.centerWidth ?? 100;
+}
+function panelHeight(layout, top = 1) {
+  return Math.max(8, (layout?.centerHeight ?? 24) - top);
+}
+function unsupportedCommand(state) {
+  const value = state.intent.action.payload?.unsupported ?? state.intent.action.payload?.unknown;
+  if (typeof value !== "string" || !value.trim())
+    return null;
+  const reason = state.intent.action.payload?.reason;
+  return { command: value.trim(), ...typeof reason === "string" && reason.trim() ? { reason: reason.trim() } : {} };
+}
+function renderHelpScene(state, layout) {
+  const unsupported = unsupportedCommand(state);
+  const selected = Math.max(0, Math.min(ACTIONS.length - 1, state.selection.index));
+  const panelLines = [
+    ...unsupported ? [
+      line(`${unsupported.command} needs the action catalog.`, { fg: RIG_UI.yellow, bold: true }),
+      line(unsupported.reason ?? "Pick an action below; explicit plain mode remains available with RIG_PLAIN=1.", { fg: RIG_UI.ink3 }),
+      line("", { fg: RIG_UI.ink3 })
+    ] : [],
+    line("ACTIONS", { fg: RIG_UI.ink3, bold: true }),
+    ...ACTIONS.map(([label, detail], index) => deckRow({ label, detail, index, active: selected === index, activateOnClick: true })),
+    line("", { fg: RIG_UI.ink3 }),
+    line("KEYS / MOUSE", { fg: RIG_UI.ink3, bold: true }),
+    ...SHORTCUTS.map(([label, detail]) => line(`${label.padEnd(22)} ${detail}`, { fg: RIG_UI.ink2 }))
+  ];
+  return makeSceneFrame({
+    scene: "help",
+    title: "Command catalog",
+    lines: [
+      line("", { fg: RIG_UI.ink4 }),
+      line("   command catalog \xB7 TUI-first Rig", { fg: RIG_UI.ink3, bold: true })
+    ],
+    panels: [{
+      id: "help-reference",
+      top: 0,
+      width: panelWidth(layout),
+      height: panelHeight(layout),
+      lines: panelLines,
+      backgroundColor: RIG_UI.panel,
+      backgroundAlpha: 184,
+      opacity: 1,
+      border: false,
+      chrome: "ad-terminal",
+      headerText: "actions",
+      headerHeight: 3,
+      paddingX: layout?.compact ? 2 : 3,
+      paddingY: 1
+    }],
+    hideTypeBar: true,
+    footer: { message: "enter/click opens a workspace" },
+    live: true
+  });
+}
+
+// packages/cli/src/app-opentui/scenes/main.ts
+var CONFIGURED_MENU = [
+  ["init", "setup, reconfigure, repair project state"],
+  ["server", "local/remote target, auth, linkage"],
+  ["github", "auth, selected repo, stored token"],
+  ["tasks", "browse, filter, dispatch, attach active work"],
+  ["runs", "attach, stop, resume, inspect live sessions"],
+  ["inbox", "approve, reject, answer, attach"],
+  ["doctor", "diagnose and repair broken surfaces"],
+  ["help", "all actions, shortcuts, mouse controls"]
+];
+var UNCONFIGURED_MENU = [
+  ["init", "full setup wizard and reconfigure flow"],
+  ["server", "select local/remote target"],
+  ["github", "connect or import authentication"],
+  ["doctor", "find missing setup pieces"],
+  ["help", "all actions and controls"]
+];
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function serverSummary(state) {
+  const server = record(state.data.server);
+  const auth = record(server?.auth);
+  const signedIn = auth?.signedIn === true || auth?.authenticated === true || auth?.status === "authenticated";
+  const login = typeof auth?.login === "string" && auth.login.trim() ? auth.login.trim() : undefined;
+  return {
+    label: typeof server?.label === "string" && server.label.trim() ? server.label.trim() : state.footer.server ?? "not checked yet",
+    target: typeof server?.kind === "string" ? `${server.kind} endpoint` : "open Server to probe",
+    health: server ? server.reachable === false ? "unreachable" : "reachable" : "pending",
+    auth: server ? signedIn ? `signed in${login ? ` as ${login}` : ""}` : "not signed in / unknown" : "pending"
+  };
+}
+function panelWidth2(layout) {
+  return layout?.centerWidth ?? 118;
+}
+function panelHeight2(layout) {
+  return Math.max(22, layout?.centerHeight ?? 36);
+}
+function actionRows(state, configured) {
+  const options = configured ? CONFIGURED_MENU : UNCONFIGURED_MENU;
+  const selected = Math.max(0, Math.min(options.length - 1, state.selection.index));
+  return options.map(([label, detail], index) => deckRow({ label, detail, index, active: index === selected, activateOnClick: true }));
+}
+function renderMainScene(state, layout) {
+  const configured = state.data.projectConfigured === true;
+  const server = serverSummary(state);
+  const lines = [
+    line("PROJECT COCKPIT", { fg: RIG_UI.ink3, bold: true }),
+    line("click a row or use arrows + enter \xB7 esc returns here \xB7 ctrl-c exits", { fg: RIG_UI.ink4 }),
+    blank(),
+    line("ACTIONS", { fg: RIG_UI.ink3, bold: true }),
+    ...actionRows(state, configured),
+    blank(),
+    line("CONTEXT", { fg: RIG_UI.ink3, bold: true }),
+    kv("workspace", "current repository", RIG_UI.ink2),
+    kv("config", configured ? "configured" : "needs setup", configured ? RIG_UI.limeDim : RIG_UI.yellow),
+    kv("server", server.label, server.health === "reachable" ? RIG_UI.limeDim : RIG_UI.yellow),
+    kv("target", server.target, RIG_UI.ink3),
+    kv("github", server.auth, server.auth.startsWith("signed in") ? RIG_UI.limeDim : RIG_UI.yellow),
+    blank(),
+    line(state.actionLabel ?? "ready", { fg: state.status === "action" ? RIG_UI.cyan : RIG_UI.ink4 })
+  ];
+  return makeSceneFrame({
+    scene: "main",
+    title: "Project cockpit",
+    lines: [],
+    panels: [{
+      id: "project-cockpit",
+      top: 0,
+      width: panelWidth2(layout),
+      height: panelHeight2(layout),
       lines,
-      styledLines,
-      message,
-      ...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`);
-    }
-  }
+      backgroundColor: RIG_UI.panel,
+      backgroundAlpha: 184,
+      opacity: 0.98,
+      border: false,
+      chrome: "ad-terminal",
+      headerText: "project cockpit",
+      paddingX: layout?.compact ? 3 : 5,
+      paddingY: 2
+    }],
+    live: true,
+    hideTypeBar: true
+  });
 }
 
 // packages/cli/src/app-opentui/runtime.ts
+init_pi_pty_host();
 var MAX_SCENE_LINES = 200;
 var MAX_SCENE_PANELS = 5;
-var FRAME_MS = 16;
-var ANIMATION_SLOWDOWN = 3;
+var ANIMATION_SLOWDOWN = 1;
+var PRELOADER_BACKDROP = RGBA7.fromHex(RIG_UI.bg);
 var PRIMARY_NAV = [
+  { scene: "main", argv: ["main"], label: "Project menu" },
   { scene: "fleet", argv: ["runs"], label: "Opening runs" },
   { scene: "tasks", argv: ["tasks"], label: "Opening tasks" },
   { scene: "help", argv: ["help"], label: "Opening help" }
 ];
 function primaryNavIntent(scene) {
   const entry = PRIMARY_NAV.find((item) => item.scene === scene) ?? PRIMARY_NAV[0];
-  return { scene: entry.scene, argv: entry.argv, action: { kind: entry.scene === "help" ? "none" : "refresh", label: entry.label } };
+  const kind = entry.scene === "help" || entry.scene === "main" ? "none" : "refresh";
+  return { scene: entry.scene, argv: entry.argv, action: { kind, label: entry.label } };
 }
 function nextPrimaryScene(current, delta) {
   const currentIndex = PRIMARY_NAV.findIndex((entry) => entry.scene === current);
@@ -2858,10 +3486,10 @@ function defaultSceneRenderer(state) {
     scene: state.scene,
     title,
     lines: [
-      { text: title.toUpperCase(), fg: RIG_UI.ink, bold: true, align: "center" },
-      { text: state.actionLabel ?? "adapter scene pending", fg: RIG_UI.limeDim, align: "center" },
-      { text: "support state", fg: RIG_UI.ink3, align: "center" },
-      { text: "runs \xB7 tasks \xB7 help", fg: RIG_UI.ink4, align: "center" }
+      { text: `  ${title.toUpperCase()}`, fg: RIG_UI.ink, bold: true },
+      { text: `  ${state.actionLabel ?? "adapter scene pending"}`, fg: RIG_UI.limeDim },
+      { text: "  choose an action from the available rows", fg: RIG_UI.ink3 },
+      { text: "  esc returns home \xB7 arrows select \xB7 enter activates", fg: RIG_UI.ink4 }
     ],
     typeBarPlaceholder: "runs \xB7 tasks \xB7 help",
     live: false
@@ -2887,9 +3515,9 @@ function requestRender(renderer) {
 function recordArray(value) {
   return Array.isArray(value) ? value.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
 }
-function stringField(record, keys) {
+function stringField2(record2, keys) {
   for (const key of keys) {
-    const value = record[key];
+    const value = record2[key];
     if (typeof value === "string" && value.trim())
       return value.trim();
     if (typeof value === "number" && Number.isFinite(value))
@@ -2897,33 +3525,84 @@ function stringField(record, keys) {
   }
   return;
 }
-function mainSelectableItems(_state) {
+function mainSelectableItems(state) {
+  const configured = state.data.projectConfigured === true;
+  const common = [
+    { id: "init", label: "init", intent: { scene: "command", argv: ["init"], action: { kind: "command-run", label: "Run init" } }, message: "run setup/reconfigure flow" },
+    { id: "server", label: "server", intent: { scene: "server", argv: ["server", "status"], action: { kind: "refresh", label: "Checking server" } }, message: "check selected server" },
+    { id: "github", label: "github", intent: { scene: "server", argv: ["github", "auth", "status"], action: { kind: "refresh", label: "Checking GitHub auth" } }, message: "check GitHub auth" }
+  ];
+  if (!configured) {
+    return [
+      ...common,
+      { id: "doctor", label: "doctor", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Running doctor" } }, message: "diagnose missing setup" },
+      { id: "help", label: "help", intent: { scene: "help", argv: ["help"], action: { kind: "none", label: "Opening help" } }, message: "selected help" }
+    ];
+  }
   return [
-    { id: "runs", label: "runs", intent: { scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } }, message: "selected runs" },
+    ...common,
     { id: "tasks", label: "tasks", intent: { scene: "tasks", argv: ["tasks"], action: { kind: "refresh", label: "Opening tasks" } }, message: "selected tasks" },
+    { id: "runs", label: "runs", intent: { scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } }, message: "selected runs" },
+    { id: "inbox", label: "inbox", intent: { scene: "inbox", argv: ["inbox"], action: { kind: "refresh", label: "Loading inbox" } }, message: "selected inbox" },
+    { id: "doctor", label: "doctor", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Running doctor" } }, message: "diagnose project" },
     { id: "help", label: "help", intent: { scene: "help", argv: ["help"], action: { kind: "none", label: "Opening help" } }, message: "selected help" }
   ];
 }
+function fleetRecoveryItems() {
+  return [
+    { id: "tasks", label: "tasks", intent: { scene: "tasks", argv: ["tasks"], action: { kind: "refresh", label: "Open tasks" } }, message: "open tasks and dispatch work" },
+    { id: "repair", label: "repair", intent: { scene: "command", argv: ["init", "--repair"], action: { kind: "command-run", label: "Repair project link" } }, message: "repair project/server/auth link" },
+    { id: "server", label: "server", intent: { scene: "server", argv: ["server", "status"], action: { kind: "refresh", label: "Open server controls" } }, message: "server controls" },
+    { id: "doctor", label: "doctor", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Run doctor" } }, message: "diagnose project" }
+  ];
+}
 function fleetSelectableItems(state) {
   const fleet = state.data.fleet;
   const runs = fleet && typeof fleet === "object" && !Array.isArray(fleet) ? recordArray(fleet.runs) : [];
-  return filterRunsForSearch(runs, listSearchQuery(state)).flatMap((run) => {
-    const runId = stringField(run, ["runId", "id"]);
+  const visibleRuns = filterRunsForSearch(runs, listSearchQuery(state));
+  if (visibleRuns.length === 0)
+    return fleetRecoveryItems();
+  return visibleRuns.flatMap((run) => {
+    const runId = stringField2(run, ["runId", "id"]);
     if (!runId)
       return [];
-    const title = stringField(run, ["title", "taskTitle", "taskId"]) ?? "run";
+    const title = stringField2(run, ["title", "taskTitle", "taskId"]) ?? "run";
     return [{ id: runId, label: title, data: { selectedRunId: runId }, intent: { scene: "handoff", argv: ["attach", runId], action: { kind: "run-attach", payload: { runId }, label: `Attach Pi ${runId.slice(0, 8)}` } }, message: `attach Pi to ${runId.slice(0, 8)}` }];
   });
 }
+function taskRecoveryItems() {
+  return [
+    { id: "refresh", label: "refresh", intent: { scene: "tasks", argv: ["tasks"], action: { kind: "refresh", label: "Refresh tasks" } }, message: "refresh task source" },
+    { id: "next", label: "next", intent: { scene: "command", argv: ["task", "run", "--next"], action: { kind: "command-run", label: "Run next task" } }, message: "dispatch next runnable task" },
+    { id: "repair", label: "repair", intent: { scene: "command", argv: ["init", "--repair"], action: { kind: "command-run", label: "Repair task source" } }, message: "repair project/task source" },
+    { id: "server", label: "server", intent: { scene: "server", argv: ["server", "status"], action: { kind: "refresh", label: "Open server controls" } }, message: "server controls" },
+    { id: "doctor", label: "doctor", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Run doctor" } }, message: "diagnose task source" }
+  ];
+}
 function taskSelectableItems(state) {
   const tasks = state.data.tasks;
   const records = tasks && typeof tasks === "object" && !Array.isArray(tasks) ? recordArray(tasks.records) : [];
-  return filterTasksForSearch(records, listSearchQuery(state)).flatMap((task) => {
-    const taskId = stringField(task, ["id", "taskId", "number"]);
+  const visibleTasks = filterTasksForSearch(records, listSearchQuery(state));
+  if (visibleTasks.length === 0)
+    return taskRecoveryItems();
+  return visibleTasks.flatMap((task) => {
+    const taskId = stringField2(task, ["id", "taskId", "number"]);
     if (!taskId)
       return [];
-    const title = stringField(task, ["title", "name", "summary"]) ?? "task";
-    return [{ id: taskId, label: title, data: { selectedTaskId: taskId }, intent: { scene: "tasks", argv: ["run", taskId], action: { kind: "task-run-id", payload: { task: taskId }, label: `Dispatching ${taskId}` } }, message: `dispatch task ${taskId}` }];
+    const title = stringField2(task, ["title", "name", "summary"]) ?? "task";
+    const activeRunId = activeRunIdFromTaskLike(task);
+    if (activeRunId) {
+      const item2 = {
+        id: taskId,
+        label: title,
+        data: { selectedTaskId: taskId, selectedRunId: activeRunId },
+        intent: { scene: "handoff", argv: ["attach", activeRunId], action: { kind: "run-attach", payload: { runId: activeRunId }, label: `Attach Pi ${activeRunId.slice(0, 8)}` } },
+        message: `attach Pi to ${activeRunId.slice(0, 8)}`
+      };
+      return [item2];
+    }
+    const item = { id: taskId, label: title, data: { selectedTaskId: taskId }, intent: { scene: "tasks", argv: ["run", taskId], action: { kind: "task-run-id", payload: { task: taskId }, label: `Dispatching ${taskId}` } }, message: `dispatch task ${taskId}` };
+    return [item];
   });
 }
 function selectedRunId(state) {
@@ -2944,21 +3623,126 @@ function selectedRunId(state) {
   }
   return;
 }
+function inboxRecoveryItems() {
+  return [
+    { id: "refresh", label: "refresh", intent: { scene: "inbox", argv: ["inbox"], action: { kind: "refresh", label: "Refresh inbox" } }, message: "refresh inbox" },
+    { id: "runs", label: "runs", intent: { scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Open runs" } }, message: "open runs" },
+    { id: "tasks", label: "tasks", intent: { scene: "tasks", argv: ["tasks"], action: { kind: "refresh", label: "Open tasks" } }, message: "open tasks" },
+    { id: "doctor", label: "doctor", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Run doctor" } }, message: "diagnose inbox" }
+  ];
+}
 function inboxSelectableItems(state) {
   const inbox = state.data.inbox;
   if (!inbox || typeof inbox !== "object" || Array.isArray(inbox))
-    return [];
-  const record = inbox;
-  const approvals = recordArray(record.approvals).map((entry) => ({ ...entry, kind: "approvals" }));
-  const inputs = recordArray(record.inputs).map((entry) => ({ ...entry, kind: "inputs" }));
+    return inboxRecoveryItems();
+  const record2 = inbox;
+  const approvals = recordArray(record2.approvals).map((entry) => ({ ...entry, kind: "approvals" }));
+  const inputs = recordArray(record2.inputs).map((entry) => ({ ...entry, kind: "inputs" }));
+  if (approvals.length === 0 && inputs.length === 0)
+    return inboxRecoveryItems();
   return [...approvals, ...inputs].flatMap((item) => {
-    const requestId = stringField(item, ["requestId", "id"]);
-    if (!requestId)
+    const requestId = stringField2(item, ["requestId", "id"]);
+    const runId = stringField2(item, ["runId"]);
+    if (!requestId || !runId)
       return [];
-    const kind = item.kind === "inputs" ? "answer" : "approve/reject";
-    return [{ id: requestId, label: kind, data: { selectedInboxRequestId: requestId }, message: `selected request ${requestId}; type ${kind} ${requestId}` }];
+    if (item.kind === "approvals") {
+      return [
+        { id: `${requestId}:approve`, label: "approve", data: { selectedInboxRequestId: requestId }, intent: { scene: "inbox", argv: ["inbox", "approve", requestId], action: { kind: "inbox-approve", payload: { requestId }, label: `Approve ${requestId}` } }, message: `approve ${requestId}` },
+        { id: `${requestId}:reject`, label: "reject", data: { selectedInboxRequestId: requestId }, intent: { scene: "inbox", argv: ["inbox", "reject", requestId], action: { kind: "inbox-reject", payload: { requestId }, label: `Reject ${requestId}` } }, message: `reject ${requestId}` },
+        { id: `${requestId}:attach`, label: "attach", data: { selectedInboxRequestId: requestId, selectedRunId: runId }, intent: { scene: "handoff", argv: ["attach", runId], action: { kind: "run-attach", payload: { runId }, label: `Attach Pi ${runId.slice(0, 8)}` } }, message: `attach run ${runId.slice(0, 8)}` }
+      ];
+    }
+    return [
+      { id: `${requestId}:answer`, label: "answer", data: { selectedInboxRequestId: requestId, selectedRunId: runId }, intent: { scene: "command", argv: ["inbox", "respond", "--run", runId, "--request", requestId], action: { kind: "command-run", label: `Answer ${requestId}` } }, message: `answer ${requestId}` },
+      { id: `${requestId}:attach`, label: "attach", data: { selectedInboxRequestId: requestId, selectedRunId: runId }, intent: { scene: "handoff", argv: ["attach", runId], action: { kind: "run-attach", payload: { runId }, label: `Attach Pi ${runId.slice(0, 8)}` } }, message: `attach run ${runId.slice(0, 8)}` }
+    ];
+  });
+}
+function serverSelectableItems(_state) {
+  return [
+    { id: "refresh", label: "refresh", intent: { scene: "server", argv: ["server", "status"], action: { kind: "refresh", label: "Refresh server" } }, message: "refresh selected server" },
+    { id: "local", label: "local", intent: { scene: "command", argv: ["server", "use", "local"], action: { kind: "command-run", label: "Use local server" } }, message: "switch this repo to local" },
+    { id: "remote", label: "remote", intent: { scene: "command", argv: ["server", "use"], action: { kind: "command-run", label: "Choose remote server" } }, message: "choose a saved remote alias" },
+    { id: "list", label: "list", intent: { scene: "command", argv: ["server", "list"], action: { kind: "command-run", label: "List saved servers" } }, message: "list saved server aliases" },
+    { id: "auth", label: "auth", intent: { scene: "command", argv: ["github", "auth", "import-gh"], action: { kind: "command-run", label: "Import GitHub auth" } }, message: "import gh auth" },
+    { id: "doctor", label: "doctor", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Run doctor" } }, message: "verify server/auth" }
+  ];
+}
+function initSelectableItems(_state) {
+  return [
+    { id: "wizard", label: "wizard", intent: { scene: "command", argv: ["init"], action: { kind: "command-run", label: "Run init wizard" } }, message: "full init wizard" },
+    { id: "reconfigure", label: "reconfigure", intent: { scene: "command", argv: ["init", "--repair"], action: { kind: "command-run", label: "Reconfigure project" } }, message: "verify or rewrite generated config" },
+    { id: "demo", label: "demo", intent: { scene: "command", argv: ["init", "--demo", "--repair"], action: { kind: "command-run", label: "Seed demo project" } }, message: "offline demo project" },
+    { id: "remote", label: "remote", intent: { scene: "command", argv: ["init"], action: { kind: "command-run", label: "Run init remote wizard" } }, message: "choose remote server in init wizard" },
+    { id: "auth", label: "auth", intent: { scene: "command", argv: ["github", "auth", "import-gh"], action: { kind: "command-run", label: "Import GitHub auth" } }, message: "import gh auth" },
+    { id: "doctor", label: "doctor", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Run doctor" } }, message: "verify setup" }
+  ];
+}
+var CLI_CATALOG_ACTIONS = [
+  { id: "runs", label: "runs", argv: ["runs"], scene: "fleet", kind: "refresh", detail: "show live/completed runs" },
+  { id: "tasks", label: "tasks", argv: ["tasks"], scene: "tasks", kind: "refresh", detail: "browse task source" },
+  { id: "run-next", label: "run next", argv: ["task", "run", "--next"], detail: "dispatch next runnable task" },
+  { id: "server", label: "server", argv: ["server", "status"], scene: "server", kind: "refresh", detail: "local/remote controls" },
+  { id: "init", label: "init", argv: ["init"], detail: "setup/reconfigure/repair wizard" },
+  { id: "doctor", label: "doctor", argv: ["doctor"], scene: "doctor", kind: "doctor-run", detail: "diagnose project/server/auth" },
+  { id: "github", label: "github", argv: ["github"], detail: "GitHub auth/repo actions" },
+  { id: "plugin", label: "plugin", argv: ["plugin"], detail: "plugin/source actions" },
+  { id: "setup", label: "setup", argv: ["setup"], detail: "bootstrap/check/preflight" },
+  { id: "inspect", label: "inspect", argv: ["inspect"], detail: "inspect project/server state" },
+  { id: "stats", label: "stats", argv: ["stats"], detail: "run/task metrics" },
+  { id: "repo", label: "repo", argv: ["repo"], detail: "repo utilities" },
+  { id: "profile", label: "profile", argv: ["profile"], detail: "profile/config actions" },
+  { id: "review", label: "review", argv: ["review"], detail: "review automation" },
+  { id: "browser", label: "browser", argv: ["browser"], detail: "browser tooling/wizards" },
+  { id: "pi", label: "pi", argv: ["pi"], detail: "Pi install/attach/status" },
+  { id: "queue", label: "queue", argv: ["queue"], detail: "queue operations" },
+  { id: "agent", label: "agent", argv: ["agent"], detail: "agent/runtime operations" },
+  { id: "inspector", label: "inspector", argv: ["inspector"], detail: "inspector tools" },
+  { id: "dist", label: "dist", argv: ["dist"], detail: "distribution helpers" },
+  { id: "workspace", label: "workspace", argv: ["workspace"], detail: "workspace/project utilities" },
+  { id: "remote", label: "remote", argv: ["remote"], detail: "remote endpoint utilities" },
+  { id: "git", label: "git", argv: ["git"], detail: "git helper actions" },
+  { id: "harness", label: "harness", argv: ["harness"], detail: "harness operations" },
+  { id: "test", label: "test", argv: ["test"], detail: "test helpers" }
+];
+function helpSelectableItems() {
+  return CLI_CATALOG_ACTIONS.map((entry) => {
+    const scene = entry.scene ?? "command";
+    const kind = entry.kind ?? "command-run";
+    return {
+      id: entry.id,
+      label: entry.label,
+      intent: { scene, argv: entry.argv, action: { kind, label: `Open ${entry.label}` } },
+      message: entry.detail
+    };
   });
 }
+function handoffSelectableItems(state) {
+  const runId = typeof state.data.selectedRunId === "string" ? state.data.selectedRunId : undefined;
+  return runId ? [
+    { id: "attach", label: "attach", intent: { scene: "handoff", argv: ["attach", runId], action: { kind: "run-attach", payload: { runId }, label: `Attach Pi ${runId.slice(0, 8)}` } }, message: "open bundled Pi" },
+    { id: "runs", label: "runs", intent: { scene: "fleet", argv: ["fleet"], action: { kind: "refresh", label: "Back to fleet" } }, message: "back to fleet" }
+  ] : [
+    { id: "runs", label: "runs", intent: { scene: "fleet", argv: ["fleet"], action: { kind: "refresh", label: "Open runs" } }, message: "select a run first" },
+    { id: "tasks", label: "tasks", intent: { scene: "tasks", argv: ["tasks"], action: { kind: "refresh", label: "Open tasks" } }, message: "open tasks" }
+  ];
+}
+function errorSelectableItems() {
+  return [
+    { id: "main", label: "main", intent: { scene: "main", argv: [], action: { kind: "refresh", label: "Back to dashboard" } }, message: "back to dashboard" },
+    { id: "doctor", label: "doctor", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Run doctor" } }, message: "run diagnostics" },
+    { id: "server", label: "server", intent: { scene: "server", argv: ["server", "status"], action: { kind: "refresh", label: "Open server controls" } }, message: "open server controls" },
+    { id: "repair", label: "repair", intent: { scene: "command", argv: ["init", "--repair"], action: { kind: "command-run", label: "Repair project link" } }, message: "repair project link" }
+  ];
+}
+function doctorSelectableItems() {
+  return [
+    { id: "run", label: "run", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Run doctor" } }, message: "run diagnostics" },
+    { id: "server", label: "server", intent: { scene: "server", argv: ["server", "status"], action: { kind: "refresh", label: "Open server controls" } }, message: "open server controls" },
+    { id: "repair", label: "repair", intent: { scene: "command", argv: ["init", "--repair"], action: { kind: "command-run", label: "Repair project link" } }, message: "repair project link" },
+    { id: "tasks", label: "tasks", intent: { scene: "tasks", argv: ["tasks"], action: { kind: "refresh", label: "Open tasks" } }, message: "open tasks" }
+  ];
+}
 function runDetailSelectableItems(state) {
   const runId = selectedRunId(state);
   if (!runId)
@@ -2973,12 +3757,24 @@ function selectableItems(state) {
   switch (state.scene) {
     case "main":
       return mainSelectableItems(state);
+    case "error":
+      return errorSelectableItems();
+    case "help":
+      return helpSelectableItems();
     case "fleet":
       return fleetSelectableItems(state);
     case "tasks":
       return taskSelectableItems(state);
     case "inbox":
       return inboxSelectableItems(state);
+    case "handoff":
+      return handoffSelectableItems(state);
+    case "server":
+      return serverSelectableItems(state);
+    case "init":
+      return initSelectableItems(state);
+    case "doctor":
+      return doctorSelectableItems();
     case "run-detail":
       return runDetailSelectableItems(state);
     default:
@@ -3058,13 +3854,18 @@ async function launchRigOpenTuiApp(options) {
   let renderer = null;
   let graphics = null;
   let imageVisuals = null;
+  let preloaderBackdrop = null;
   const scrollPanels = [];
   let typeBar = null;
+  let brandText = null;
   const textLines = [];
-  let tickTimer = null;
+  let renderTimer = null;
   let destroyed = false;
   let runnerPromise = null;
   let renderedSelectableItems = [];
+  const preloaderTransition = { scene: null, startedAtMs: 0, minUntilMs: 0 };
+  const resources = new RuntimeResources;
+  const focusManager = new AppFocusManager;
   const emitAsyncError = (label, error) => {
     const normalized = normalizeError(error);
     events.emit({ type: "action.failed", label, message: normalized.message, hint: normalized.hint, cause: normalized.cause });
@@ -3072,6 +3873,23 @@ async function launchRigOpenTuiApp(options) {
   const runAppAction = (label, action) => {
     action().catch((error) => emitAsyncError(label, error));
   };
+  const renderApp = () => {
+    if (!renderer || destroyed)
+      return;
+    const currentState = store.getState();
+    renderedSelectableItems = renderNow(renderer, graphics, imageVisuals, preloaderBackdrop, scrollPanels, typeBar, brandText, textLines, currentState, options.sceneRenderers, preloaderTransition, scheduleAppRender);
+    focusManager.restoreTypeBarFocus(typeBar, { hidden: currentState.scene === "handoff" });
+  };
+  const scheduleAppRender = (delayMs = 0) => {
+    if (destroyed)
+      return;
+    if (renderTimer)
+      return;
+    renderTimer = resources.setTimeout(() => {
+      renderTimer = null;
+      renderApp();
+    }, Math.max(0, delayMs));
+  };
   const runtime = {
     getState: () => store.getState(),
     patchState: (patch) => store.patch(patch),
@@ -3098,29 +3916,35 @@ async function launchRigOpenTuiApp(options) {
     },
     getRunnerContext: async () => {
       if (!options.initializeRuntime)
-        throw new Error("Rig runtime initializer was not provided to the OpenTUI app.");
+        throw new Error("Runtime initializer was not provided to the OpenTUI app.");
       runnerPromise ??= options.initializeRuntime();
       return runnerPromise;
     },
     suspend: () => renderer?.suspend(),
     resume: () => {
       renderer?.resume();
-      if (renderer && !destroyed)
-        renderedSelectableItems = renderNow(renderer, graphics, imageVisuals, scrollPanels, typeBar, textLines, store.getState(), options.sceneRenderers);
+      renderApp();
     },
     destroy: () => renderer?.destroy()
   };
-  events.subscribe((event) => store.patch(reduceAppEvent(store.getState(), event)));
-  store.subscribe(() => {
-    if (!destroyed && renderer)
-      renderedSelectableItems = renderNow(renderer, graphics, imageVisuals, scrollPanels, typeBar, textLines, store.getState(), options.sceneRenderers);
-  });
+  resources.add(events.subscribe((event) => store.patch(reduceAppEvent(store.getState(), event))));
+  resources.add(store.subscribe(() => {
+    scheduleAppRender(0);
+  }));
+  resources.setInterval(() => {
+    const state = store.getState();
+    if (state.scene === "handoff" && getActivePiHost())
+      return;
+    if (state.scene === "command" && getActiveCommandHost())
+      return;
+    store.patch({ tick: state.tick + 1 });
+  }, 96);
   try {
     renderer = await createCliRenderer({
       screenMode: "alternate-screen",
       exitOnCtrlC: false,
-      targetFps: 60,
-      maxFps: 60,
+      targetFps: 30,
+      maxFps: 30,
       useMouse: true,
       autoFocus: false,
       useKittyKeyboard: {
@@ -3132,24 +3956,41 @@ async function launchRigOpenTuiApp(options) {
       openConsoleOnError: false,
       backgroundColor: "transparent"
     });
-    renderer.setTerminalTitle?.("Rig \u2014 operator cockpit");
+    renderer.setTerminalTitle?.("Operator cockpit");
     const layout = computeStageLayout(renderer.width, renderer.height);
-    imageVisuals = forceModernImageVisuals() ? new ImageVisualLayer(process.stdout) : null;
+    imageVisuals = forceModernImageVisuals() ? new ImageVisualLayer(process.stdout, () => scheduleAppRender(0)) : null;
     if (imageVisuals?.enabled) {
-      renderer.setFrameCallback(async () => {
+      const flushImageVisuals = async () => {
         imageVisuals?.flush();
-      });
+      };
+      renderer.setFrameCallback(flushImageVisuals);
+      resources.add(() => renderer?.removeFrameCallback(flushImageVisuals));
     }
     if (!imageVisuals?.enabled) {
       graphics = createGraphicsLayer(renderer, layout);
       renderer.root.add(graphics);
     }
+    preloaderBackdrop = new BoxRenderable2(renderer, {
+      id: "rig-preloader-backdrop",
+      position: "absolute",
+      left: 0,
+      top: 0,
+      width: layout.width,
+      height: layout.height,
+      backgroundColor: PRELOADER_BACKDROP,
+      border: false,
+      zIndex: 100,
+      visible: false
+    });
+    renderer.root.add(preloaderBackdrop);
     for (let index = 0;index < MAX_SCENE_PANELS; index += 1) {
       const panel = createScrollPanelLayer(renderer, `rig-scroll-panel-${index}`, (line2) => {
         const selectableIndex = line2.selectableIndex;
         if (selectableIndex === undefined)
           return;
         selectIndex(store, selectableIndex, renderedSelectableItems);
+        if (line2.activateOnClick)
+          runAppAction("Activate selection", () => activateSelection(runtime, renderedSelectableItems));
       });
       scrollPanels.push(panel);
       renderer.root.add(panel);
@@ -3160,146 +4001,84 @@ async function launchRigOpenTuiApp(options) {
         if (selectableIndex === undefined)
           return;
         selectIndex(store, selectableIndex, renderedSelectableItems);
+        if (line2.activateOnClick)
+          runAppAction("Activate selection", () => activateSelection(runtime, renderedSelectableItems));
       });
       textLines.push(textLine);
       renderer.root.add(textLine);
     }
-    typeBar = createTypeBar(renderer);
-    renderer.root.add(typeBar.prefix);
-    renderer.root.add(typeBar.input);
-    renderer.root.add(typeBar.footer);
-    bindTypeBar(typeBar, {
-      onInput(value) {
-        const scene = store.getState().scene;
-        events.emit({
-          type: "typebar.patch",
-          typeBar: {
-            value,
-            ...isListSearchScene(scene) ? { message: value.trim() ? `search ${JSON.stringify(value.trim())}` : undefined } : {}
-          }
-        });
-      },
-      onEnter(value) {
-        const scene = store.getState().scene;
-        if (isListSearchScene(scene) && value.trim()) {
-          if (renderedSelectableItems.length === 0) {
-            events.emit({ type: "typebar.patch", typeBar: { message: "no search match" } });
-            return;
-          }
-          const snapshot = renderedSelectableItems;
-          typeBar?.input && (typeBar.input.value = "");
-          events.emit({ type: "typebar.patch", typeBar: { value: "" } });
-          runAppAction("Activate search result", () => activateSelection(runtime, snapshot));
-          return;
-        }
-        typeBar?.input && (typeBar.input.value = "");
-        events.emit({ type: "typebar.patch", typeBar: { value: "" } });
-        if (value.trim() === "") {
-          runAppAction("Activate selection", () => activateSelection(runtime, renderedSelectableItems));
-          return;
-        }
-        runAppAction("Run command", () => runtime.runIntent(intentFromTypeBar(value)));
-      }
+    brandText = new TextRenderable3(renderer, {
+      id: "brand-mark",
+      content: "RIG",
+      position: "absolute",
+      left: layout.centerLeft,
+      top: Math.max(0, layout.centerTop - 1),
+      fg: RIG_UI.lime,
+      zIndex: 8,
+      selectable: false
     });
-    renderer.keyInput.on("keypress", (key) => {
-      const host = getActivePiHost();
-      if (host && store.getState().scene === "handoff") {
-        if (key.ctrl && key.name === "]") {
-          stopActivePiHost("operator detach");
-          events.emit({ type: "typebar.patch", typeBar: { value: "", message: "detached from Pi" } });
-          runAppAction("Opening runs", () => runtime.runIntent({ scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } }));
-          return;
-        }
-        const sequence = key.raw || key.sequence;
-        if (sequence)
-          host.write(sequence);
-        if (typeBar)
-          typeBar.input.value = "";
-        return;
-      }
-      if (key.ctrl && key.name === "c") {
-        renderer?.destroy();
-        return;
-      }
-      const currentScene = store.getState().scene;
-      const searchScene = isListSearchScene(currentScene);
-      const inputValue = typeBar?.input.value ?? "";
-      const typeBarEmpty = inputValue.trim() === "";
-      if (typeBarEmpty && (key.name === "right" || key.name === "tab")) {
-        runAppAction("Navigate", () => runtime.runIntent(primaryNavIntent(nextPrimaryScene(store.getState().scene, 1))));
-        return;
-      }
-      if (typeBarEmpty && key.name === "left") {
-        runAppAction("Navigate", () => runtime.runIntent(primaryNavIntent(nextPrimaryScene(store.getState().scene, -1))));
-        return;
-      }
-      if (!searchScene && typeBarEmpty && key.name === "r") {
-        runAppAction("Opening runs", () => runtime.runIntent(primaryNavIntent("fleet")));
-        return;
-      }
-      if (!searchScene && typeBarEmpty && key.name === "t") {
-        runAppAction("Opening tasks", () => runtime.runIntent(primaryNavIntent("tasks")));
-        return;
-      }
-      if (!searchScene && typeBarEmpty && (key.name === "h" || key.sequence === "?")) {
-        runAppAction("Opening help", () => runtime.runIntent(primaryNavIntent("help")));
-        return;
-      }
-      if (searchScene && key.name === "up" || !searchScene && typeBarEmpty && (key.name === "up" || key.name === "k")) {
-        if (moveSelection(store, -1, renderedSelectableItems))
+    renderer.root.add(brandText);
+    typeBar = null;
+    const onKeyPress = (key) => {
+      handleAppKeyPress({
+        renderer: () => renderer,
+        runtime,
+        getState: () => store.getState(),
+        getTypeBar: () => typeBar,
+        getRenderedSelectableItems: () => renderedSelectableItems,
+        emitTypeBarPatch: (typeBarPatch) => events.emit({ type: "typebar.patch", typeBar: typeBarPatch }),
+        runAppAction,
+        primaryNavIntent,
+        nextPrimaryScene,
+        moveSelection: (delta, items) => moveSelection(store, delta, items),
+        activateSelection: (items) => activateSelection(runtime, items)
+      }, key);
+    };
+    renderer.keyInput.on("keypress", onKeyPress);
+    resources.add(() => renderer?.keyInput.off("keypress", onKeyPress));
+    const onPaste = (event) => {
+      const state = store.getState();
+      if (state.scene === "handoff") {
+        const host = getActivePiHost();
+        if (!host)
           return;
-      }
-      if (searchScene && key.name === "down" || !searchScene && typeBarEmpty && (key.name === "down" || key.name === "j")) {
-        if (moveSelection(store, 1, renderedSelectableItems))
+        host.write(event.bytes);
+      } else if (state.scene === "command") {
+        const host = getActiveCommandHost();
+        if (!host)
           return;
+        host.write(event.bytes);
       }
-      if (typeBarEmpty && (key.name === "return" || key.name === "enter")) {
-        runAppAction("Activate selection", () => activateSelection(runtime, renderedSelectableItems));
-        return;
-      }
-      if (!searchScene && key.name === "q" && typeBarEmpty) {
-        renderer?.destroy();
-        return;
-      }
-      if (key.name === "escape") {
-        if (inputValue) {
-          if (typeBar)
-            typeBar.input.value = "";
-          events.emit({ type: "typebar.patch", typeBar: { value: "", message: undefined } });
-        } else {
-          runAppAction("Opening runs", () => runtime.runIntent({ scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } }));
-        }
-      }
-    });
-    renderer.keyInput.on("paste", (event) => {
-      const host = getActivePiHost();
-      if (!host || store.getState().scene !== "handoff")
-        return;
-      host.write(event.bytes);
-      if (typeBar)
-        typeBar.input.value = "";
-    });
-    renderer.on("selection", (selection) => {
+    };
+    renderer.keyInput.on("paste", onPaste);
+    resources.add(() => renderer?.keyInput.off("paste", onPaste));
+    const onSelection = (selection) => {
       const selectedText = selection.getSelectedText();
       if (!selectedText)
         return;
       renderer?.copyToClipboardOSC52?.(selectedText);
       events.emit({ type: "typebar.patch", typeBar: { message: "copied selection" } });
-    });
-    renderer.on("resize", () => {
-      if (renderer)
-        renderedSelectableItems = renderNow(renderer, graphics, imageVisuals, scrollPanels, typeBar, textLines, store.getState(), options.sceneRenderers);
-    });
-    renderer.on("destroy", () => {
+    };
+    renderer.on("selection", onSelection);
+    resources.add(() => renderer?.off("selection", onSelection));
+    const onResize = () => {
+      renderApp();
+    };
+    renderer.on("resize", onResize);
+    resources.add(() => renderer?.off("resize", onResize));
+    const onDestroy = () => {
       destroyed = true;
       stopActivePiHost("renderer destroyed");
+      stopActiveCommandHost("renderer destroyed");
       imageVisuals?.destroy();
-      if (tickTimer)
-        clearInterval(tickTimer);
-      tickTimer = null;
-    });
-    renderer.requestLive?.();
-    renderedSelectableItems = renderNow(renderer, graphics, imageVisuals, scrollPanels, typeBar, textLines, store.getState(), options.sceneRenderers);
+      if (renderTimer)
+        clearTimeout(renderTimer);
+      renderTimer = null;
+      resources.disposeAll();
+    };
+    renderer.on("destroy", onDestroy);
+    resources.add(() => renderer?.off("destroy", onDestroy));
+    renderApp();
     requestRender(renderer);
     queueMicrotask(() => {
       (async () => {
@@ -3317,46 +4096,77 @@ async function launchRigOpenTuiApp(options) {
         }
       })();
     });
-    tickTimer = setInterval(() => {
-      if (destroyed)
-        return;
-      const state = store.getState();
-      if (state.scene === "handoff" && getActivePiHost())
-        return;
-      store.patch({ tick: state.tick + 1 });
-    }, FRAME_MS);
-    await new Promise((resolveDestroy) => renderer?.on("destroy", resolveDestroy));
+    await new Promise((resolveDestroy) => {
+      renderer?.on("destroy", resolveDestroy);
+      resources.add(() => renderer?.off("destroy", resolveDestroy));
+    });
   } finally {
     destroyed = true;
-    if (tickTimer)
-      clearInterval(tickTimer);
-    tickTimer = null;
+    if (renderTimer)
+      clearTimeout(renderTimer);
+    renderTimer = null;
+    resources.disposeAll();
     imageVisuals?.destroy();
     stopActivePiHost("app shutdown");
-    try {
-      renderer?.dropLive?.();
-    } catch {}
+    stopActiveCommandHost("app shutdown");
     if (renderer && !renderer.isDestroyed)
       renderer.destroy();
   }
 }
-function renderNow(renderer, graphics, imageVisuals, scrollPanels, typeBar, textLines, state, renderers) {
+function renderNow(renderer, graphics, imageVisuals, preloaderBackdrop, scrollPanels, typeBar, brandText, textLines, state, renderers, preloaderTransition, scheduleRenderAfter) {
   const layout = computeStageLayout(renderer.width, renderer.height);
   const animationTick = Math.floor(state.tick / ANIMATION_SLOWDOWN);
   const renderState = animationTick === state.tick ? state : { ...state, tick: animationTick };
-  const frame = rendererForScene(renderState.scene, renderers)(renderState, layout);
-  if (frame.terminalActive) {
+  const now = Date.now();
+  const sceneJustChanged = preloaderTransition.scene !== renderState.scene;
+  maybeStartPreloaderTransition(preloaderTransition, renderState.scene, now);
+  const targetFrame = rendererForScene(renderState.scene, renderers)(renderState, layout);
+  const targetContentLayout = targetFrame.fullScreen ? { ...layout, centerWidth: layout.width, centerLeft: 0, centerTop: 0, centerHeight: Math.min(layout.height, MAX_SCENE_LINES) } : layout;
+  const targetPanelsForImages = (targetFrame.panels ?? []).map((panel) => ({ ...panel }));
+  let targetVisualReady = true;
+  if (targetFrame.terminalActive) {
     getActivePiHost()?.resize(layout.width, Math.max(1, layout.height));
   }
+  if (renderState.scene === "command") {
+    getActiveCommandHost()?.resize(Math.max(40, targetContentLayout.centerWidth - 12), Math.max(10, targetContentLayout.centerHeight - 6));
+  }
+  if (imageVisuals && targetFrame.terminalActive) {
+    imageVisuals.clear();
+  } else if (imageVisuals && !targetFrame.fullScreen && !sceneJustChanged) {
+    const visualInput = {
+      layout: targetContentLayout,
+      pixelSize: pixelSizeForRenderer(renderer),
+      panels: targetPanelsForImages,
+      scene: state.scene,
+      tick: state.tick
+    };
+    imageVisuals.render(visualInput);
+    targetVisualReady = imageVisuals.isReady(visualInput);
+  }
+  const preloaderActive = sceneJustChanged || isPreloaderActive(preloaderTransition, targetVisualReady, now);
+  imageVisuals?.setFlushPaused(preloaderActive);
+  const frame = preloaderActive ? renderAsciiPreloaderFrame(renderState.scene, layout, state.tick) : targetFrame;
   if (graphics) {
     resizeGraphicsLayer(graphics, layout);
-    if (frame.terminalActive || frame.fullScreen)
+    if (targetFrame.terminalActive || targetFrame.fullScreen || preloaderActive)
       clearGraphicsLayer(graphics);
     else
       drawAmbientField(graphics, layout, animationTick, state.scene);
   }
-  if (imageVisuals && (frame.terminalActive || frame.fullScreen)) {
-    imageVisuals.clear();
+  if (preloaderBackdrop) {
+    preloaderBackdrop.visible = preloaderActive;
+    preloaderBackdrop.left = 0;
+    preloaderBackdrop.top = 0;
+    preloaderBackdrop.width = layout.width;
+    preloaderBackdrop.height = layout.height;
+    preloaderBackdrop.zIndex = 100;
+    preloaderBackdrop.backgroundColor = PRELOADER_BACKDROP;
+  }
+  if (brandText) {
+    brandText.visible = !targetFrame.terminalActive && !preloaderActive;
+    brandText.content = "RIG";
+    brandText.left = layout.centerLeft;
+    brandText.top = Math.max(0, layout.centerTop - 1);
   }
   const contentLayout = frame.fullScreen ? { ...layout, centerWidth: layout.width, centerLeft: 0, centerTop: 0, centerHeight: Math.min(layout.height, MAX_SCENE_LINES) } : layout;
   const sceneLines = fitSceneLines(frame.lines, contentLayout);
@@ -3382,18 +4192,13 @@ function renderNow(renderer, graphics, imageVisuals, scrollPanels, typeBar, text
     ...panel,
     lines: panel.lines.map(remapSelectableLine)
   }));
-  if (imageVisuals && !frame.terminalActive && !frame.fullScreen) {
-    imageVisuals.render({
-      layout: contentLayout,
-      pixelSize: pixelSizeForRenderer(renderer),
-      panels: renderedPanels,
-      scene: state.scene,
-      tick: state.tick
-    });
-  }
   if (graphics && !frame.terminalActive)
     drawPanelChrome(graphics, contentLayout, renderedPanels);
-  renderedSceneLines.forEach((entry, index) => applyTextLine(textLines[index], entry, contentLayout.centerTop + index, contentLayout.centerLeft, contentLayout.centerWidth));
+  renderedSceneLines.forEach((entry, index) => {
+    const textLine = textLines[index];
+    textLine.zIndex = preloaderActive ? 102 : 5;
+    applyTextLine(textLine, entry, contentLayout.centerTop + index, contentLayout.centerLeft, contentLayout.centerWidth);
+  });
   clearTextLines(textLines, renderedSceneLines.length);
   applyScrollPanels(scrollPanels, contentLayout, renderedPanels);
   if (typeBar) {
@@ -3407,6 +4212,10 @@ function renderNow(renderer, graphics, imageVisuals, scrollPanels, typeBar, text
     }
   }
   requestRender(renderer);
+  if (preloaderActive) {
+    const minDelay = Math.max(0, preloaderTransition.minUntilMs - Date.now());
+    scheduleRenderAfter?.(sceneJustChanged ? 0 : Math.max(32, Math.min(160, minDelay || 96)));
+  }
   return renderedSelectableItems;
 }
 export {