@h-rig/cli 0.0.6-alpha.89 → 0.0.6-alpha.90

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

@@ -1,4897 +0,0 @@
-// @bun
-// packages/cli/src/app-opentui/react/launch.tsx
-import { createCliRenderer as createCliRenderer2 } from "@opentui/core";
-import { createRoot } from "@opentui/react";
-
-// 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/intent.ts
-var NAV_SCENES = new Map([
-  ["", "main"],
-  ["main", "main"],
-  ["home", "main"],
-  ["fleet", "fleet"],
-  ["runs", "fleet"],
-  ["run", "fleet"],
-  ["tasks", "tasks"],
-  ["task", "tasks"],
-  ["inbox", "inbox"],
-  ["server", "server"],
-  ["init", "init"],
-  ["doctor", "doctor"],
-  ["pi", "pi"],
-  ["plugin", "plugin"],
-  ["repo", "repo"],
-  ["workspace", "workspace"],
-  ["inspect", "inspect"],
-  ["help", "help"]
-]);
-var TASK_VIEW_COMMANDS = new Set([
-  "",
-  "all",
-  "open",
-  "ready",
-  "blocked",
-  "closed",
-  "done",
-  "mine",
-  "me",
-  "sort",
-  "status",
-  "state",
-  "assignee",
-  "assigned",
-  "label",
-  "search",
-  "q"
-]);
-var HOLLOW_FAMILIES = new Set([
-  "browser",
-  "stats",
-  "dist",
-  "agent",
-  "queue",
-  "remote",
-  "harness",
-  "git",
-  "setup",
-  "profile",
-  "review",
-  "inspector",
-  "test"
-]);
-function familyIntent(family, argv, raw) {
-  return intent("family", argv, "refresh", { family }, `Opening ${family}`, raw);
-}
-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 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 parseSimpleTaskRunArgs(args) {
-  let next = false;
-  let task;
-  let detach = false;
-  for (let index = 0;index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "next" || arg === "--next") {
-      next = true;
-      continue;
-    }
-    if (arg === "--detach") {
-      detach = true;
-      continue;
-    }
-    if (arg === "--task") {
-      const value = args[index + 1];
-      if (!value || value.startsWith("-"))
-        return { ok: false, reason: "task run --task needs an id" };
-      if (task)
-        return { ok: false, reason: "task run received more than one task id" };
-      task = value;
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("-")) {
-      return { ok: false, reason: `task run option ${arg} uses the command workspace` };
-    }
-    if (task)
-      return { ok: false, reason: "task run received more than one task id" };
-    task = arg;
-  }
-  if (next && task)
-    return { ok: false, reason: "task run cannot combine next with a task id" };
-  return { ok: true, next, ...task ? { task } : {}, detach };
-}
-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 taskViewIntent(argv, command = "", rest = [], raw) {
-  const { payload, label } = taskViewPayload(command, rest);
-  return intent("tasks", argv, "refresh", payload, label, raw);
-}
-function routeServer(argv, command, rest, raw, checkingLabel) {
-  if (!command || command === "status" || command === "list") {
-    return intent("server", argv, "refresh", undefined, command ? checkingLabel : "Loading server", raw);
-  }
-  if (command === "use") {
-    const alias = firstNonOption(rest);
-    if (alias === "local")
-      return intent("server", argv, "server-use-local", undefined, "Use local server", raw);
-    if (alias)
-      return intent("server", argv, "server-use-remote", { alias }, `Use ${alias}`, raw);
-    return intent("server", argv, "refresh", undefined, "Select a remote alias in Server", raw);
-  }
-  if (command === "add")
-    return intent("server", argv, "server-add-remote", { argv: [...argv] }, "Add remote server", raw);
-  if (command === "repair-link")
-    return intent("server", argv, "remote-link-repair", undefined, "Repair remote link", raw);
-  return commandRunIntent(argv, raw);
-}
-function routeGithub(argv, command, rest, raw) {
-  if (command === "auth" && (rest[0]?.toLowerCase() ?? "status") === "status" && rest.length <= 1) {
-    return intent("server", argv, "refresh", undefined, "Checking GitHub auth", raw);
-  }
-  if (command === "auth" && rest[0]?.toLowerCase() === "import-gh" && rest.length <= 1) {
-    return intent("server", argv, "github-auth-import", undefined, "Import GitHub auth", raw);
-  }
-  return commandRunIntent(argv, raw);
-}
-function routeDoctor(argv, command, raw) {
-  return command ? commandRunIntent(argv, raw) : intent("doctor", argv, "doctor-run", undefined, "Running doctor", raw);
-}
-function routeInbox(argv, command, rest, raw) {
-  if (command === "watch")
-    return commandRunIntent(argv, raw);
-  if ((command === "approvals" || command === "inputs") && rest.length > 0)
-    return commandRunIntent(argv, raw);
-  return command && command !== "approvals" && command !== "inputs" ? commandRunIntent(argv, raw) : inboxActionIntent(argv, command, rest, raw);
-}
-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") : commandRunIntent(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 commandRunIntent(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")
-    return routeServer(argv, normalizedCommand, rest, undefined, "Checking server");
-  if (normalizedGroup === "github")
-    return routeGithub(argv, normalizedCommand, rest);
-  if (normalizedGroup === "init") {
-    if (!normalizedCommand)
-      return intent("init", argv, "refresh", undefined, "Open init");
-    if (rest.includes("--yes") || normalizedCommand === "--yes")
-      return intent("init", argv, "init-start", undefined, "Run init");
-    return intent("init", argv, "refresh", undefined, "Open init");
-  }
-  if (normalizedGroup === "doctor")
-    return routeDoctor(argv, normalizedCommand);
-  if (normalizedGroup === "inbox")
-    return routeInbox(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);
-  }
-  if (HOLLOW_FAMILIES.has(normalizedGroup)) {
-    if (!normalizedCommand || isHelpCommand(normalizedCommand))
-      return familyIntent(normalizedGroup, argv);
-    return commandRunIntent(argv);
-  }
-  const nav = NAV_SCENES.get(normalizedGroup);
-  if (nav && argv.length === 1)
-    return intent(nav, argv, "navigate", undefined, `Opening ${nav}`);
-  return commandRunIntent(argv);
-}
-function intentFromTypeBar(value) {
-  const raw = value.trim();
-  if (!raw)
-    return intent("main", [], "none", undefined, "Project menu", 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" || first === "task" && (second === "ready" || second === "status"))
-      return commandRunIntent(parts, value);
-    if (!isTaskViewCommand(second.toLowerCase()))
-      return commandRunIntent(parts, value);
-    return taskViewIntent(parts, second, rest, value);
-  }
-  if (first === "run") {
-    if (second === "attach") {
-      const runId = firstNonOption(rest);
-      return runId && rest.filter((part) => part.trim()).length === 1 ? intent("handoff", parts, "run-attach", { runId }, "Attaching run", value) : commandRunIntent(parts, value);
-    }
-    if (second === "stop") {
-      const runId = firstNonOption(rest);
-      return runId && rest.filter((part) => part.trim()).length === 1 ? intent("fleet", parts, "run-stop", { runId }, "Stopping run", value) : commandRunIntent(parts, value);
-    }
-    if (second === "next" || second === "--next" || second === "--task") {
-      const parsed = parseSimpleTaskRunArgs([second, ...rest]);
-      if (!parsed.ok)
-        return commandRunIntent(parts, value, parsed.reason);
-      const payload = parsed.detach ? { detach: true } : undefined;
-      if (parsed.next)
-        return intent("tasks", parts, "task-run-next", payload, parsed.detach ? "Dispatching next task detached" : "Dispatching next task", value);
-      if (parsed.task)
-        return intent("tasks", parts, "task-run-id", { ...payload ?? {}, task: parsed.task }, parsed.detach ? `Dispatching ${parsed.task} detached` : `Dispatching ${parsed.task}`, value);
-      return intent("tasks", parts, "refresh", undefined, "Select a task, then press Enter; or use run next", value);
-    }
-    if (second && !second.startsWith("-")) {
-      if (rest.length > 0)
-        return commandRunIntent(parts, value);
-      return intent("tasks", parts, "task-run-id", { task: second }, `Dispatching ${second}`, value);
-    }
-    if (second?.startsWith("-"))
-      return commandRunIntent(parts, value);
-    return intent("tasks", parts, "refresh", undefined, "Select a task, then press Enter; or use run next", value);
-  }
-  if (first === "init") {
-    if (!second)
-      return intent("init", parts, "refresh", undefined, "Open init", value);
-    if (parts.includes("--yes"))
-      return intent("init", parts, "init-start", undefined, "Run init", value);
-    return intent("init", parts, "refresh", undefined, "Open init", value);
-  }
-  if (first === "doctor")
-    return routeDoctor(parts, second, value);
-  if (first === "server")
-    return routeServer(parts, second, rest, value, "Loading server");
-  if (first === "github")
-    return routeGithub(parts, second, rest, value);
-  if (first === "inbox")
-    return routeInbox(parts, second, rest, 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 parts.length === 2 ? intent("handoff", parts, "run-attach", { runId: second }, `Attaching ${second}`, value) : commandRunIntent(parts, value);
-  }
-  return intentFromArgv(parts);
-}
-
-// packages/cli/src/app-opentui/state.ts
-function mergePatch(state, patch) {
-  return {
-    ...state,
-    ...patch,
-    typeBar: patch.typeBar ? { ...state.typeBar, ...patch.typeBar } : state.typeBar,
-    footer: patch.footer ? { ...state.footer, ...patch.footer } : state.footer,
-    selection: patch.selection ? { ...state.selection, ...patch.selection } : state.selection,
-    data: patch.data ? { ...state.data, ...patch.data } : state.data
-  };
-}
-function createInitialAppState(options) {
-  const initialIntent = intentFromArgv(options.argv);
-  const projectName = options.projectRoot.split(/[\\/]/).filter(Boolean).at(-1) ?? options.projectRoot;
-  return {
-    projectRoot: options.projectRoot,
-    scene: initialIntent.scene,
-    status: initialIntent.action.kind === "none" || initialIntent.action.kind === "navigate" ? "idle" : "loading",
-    tick: 0,
-    argv: options.argv,
-    intent: initialIntent,
-    typeBar: {
-      value: "",
-      placeholder: "/ search \xB7 : command \xB7 tab next \xB7 ? help",
-      mode: "nav"
-    },
-    history: [],
-    footer: {
-      project: projectName,
-      ...options.initialFooter ?? {}
-    },
-    selection: { index: 0, count: 0 },
-    data: {
-      projectConfigured: options.projectConfigured ?? false
-    },
-    runtimeReady: false,
-    actionLabel: initialIntent.action.label
-  };
-}
-function createAppStore(initialState) {
-  let state = initialState;
-  const listeners = new Set;
-  const notify = () => {
-    for (const listener of [...listeners])
-      listener(state);
-  };
-  return {
-    getState() {
-      return state;
-    },
-    setState(next) {
-      state = next;
-      notify();
-    },
-    patch(patch) {
-      state = mergePatch(state, patch);
-      notify();
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    }
-  };
-}
-function reduceAppEvent(state, event) {
-  switch (event.type) {
-    case "scene.change":
-      return {
-        scene: event.scene,
-        ...event.intent ? { intent: event.intent, actionLabel: event.intent.action.label } : {},
-        status: "idle",
-        error: undefined,
-        confirm: undefined,
-        typeBar: { message: undefined, value: "", mode: "nav", prompt: undefined }
-      };
-    case "action.started":
-      return {
-        status: "action",
-        actionLabel: event.label,
-        error: undefined,
-        confirm: undefined,
-        data: event.optimistic ?? {},
-        typeBar: { message: event.label }
-      };
-    case "action.progress":
-      return {
-        status: "action",
-        actionLabel: event.label,
-        data: event.data ?? {},
-        typeBar: { message: event.detail ?? event.label }
-      };
-    case "action.completed":
-      return {
-        status: "success",
-        actionLabel: event.label,
-        data: event.data ?? {},
-        dataUpdatedAtMs: Date.now(),
-        typeBar: { message: `${event.label} complete` }
-      };
-    case "action.failed":
-      return {
-        status: "error",
-        actionLabel: event.label,
-        error: { message: event.message, hint: event.hint, cause: event.cause },
-        typeBar: { message: event.message, placeholder: event.hint ?? "runs \xB7 tasks \xB7 help" },
-        data: {
-          optimisticRun: undefined,
-          pendingRunMessage: undefined,
-          inboxOptimistic: undefined,
-          dispatchingRun: undefined,
-          lastRefreshError: event.message
-        }
-      };
-    case "data.patch":
-      return { data: event.data, dataUpdatedAtMs: Date.now() };
-    case "confirm.request":
-      return {
-        confirm: event.confirm,
-        typeBar: { message: `${event.confirm.label} \u2014 enter to confirm \xB7 esc to cancel` }
-      };
-    case "confirm.cancel":
-      return { confirm: undefined, typeBar: { message: "cancelled" } };
-    case "footer.patch":
-      return { footer: event.footer };
-    case "typebar.patch":
-      return { typeBar: event.typeBar };
-    case "runtime.ready":
-      return { runtimeReady: true, footer: { message: "runtime ready" } };
-    case "runtime.failed":
-      return {
-        scene: "error",
-        status: "error",
-        runtimeReady: false,
-        error: { message: event.message, hint: event.hint, cause: event.cause }
-      };
-  }
-}
-
-// packages/cli/src/app-opentui/runtime.ts
-import { BoxRenderable as BoxRenderable3, RGBA as RGBA7, StyledText as StyledText3, TextRenderable as TextRenderable4, createCliRenderer } from "@opentui/core";
-
-// packages/cli/src/app-opentui/command-pty-host.ts
-import { basename } from "path";
-import { fileURLToPath } from "url";
-import { Terminal as XtermTerminal } from "@xterm/headless";
-var MIN_COLS = 40;
-var MIN_ROWS = 10;
-var MAX_ROWS = 300;
-var MAX_SNAPSHOT_LINES = 420;
-var SNAPSHOT_DELAY_MS = 80;
-var fallbackCliScriptPath = fileURLToPath(new URL("../../bin/rig.ts", import.meta.url));
-var activeHost = null;
-function clampCols(cols) {
-  return Math.max(MIN_COLS, Math.trunc(cols || 120));
-}
-function clampRows(rows) {
-  return Math.max(MIN_ROWS, Math.min(MAX_ROWS, Math.trunc(rows || 36)));
-}
-function childCommandPrefix() {
-  const execName = basename(process.execPath).toLowerCase();
-  const currentEntry = process.argv[1];
-  if (execName === "bun" || execName === "bun.exe") {
-    return currentEntry ? [process.execPath, currentEntry] : [process.execPath, fallbackCliScriptPath];
-  }
-  return [process.execPath];
-}
-function withEnv(base) {
-  const env = {};
-  for (const [key, value] of Object.entries(base ?? process.env)) {
-    if (key === "NO_COLOR")
-      continue;
-    if (typeof value === "string")
-      env[key] = value;
-  }
-  return {
-    ...env,
-    TERM: "xterm-256color",
-    COLORTERM: "truecolor",
-    FORCE_COLOR: env.FORCE_COLOR ?? "1",
-    RIG_PLAIN: "1",
-    RIG_OPENTUI_COMMAND_HOST: "1",
-    RIG_CLI_PLAIN_HELP: env.RIG_CLI_PLAIN_HELP ?? "1"
-  };
-}
-function commandLabel(argv, fallback) {
-  const command = argv.join(" ").trim();
-  return fallback?.trim() || (command ? `rig ${command}` : "rig");
-}
-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/commands/_help-catalog.ts
-import pc from "picocolors";
-function helpCatalog() {
-  return { sections: TOP_LEVEL_SECTIONS, groups: ALL_GROUPS };
-}
-var TOP_LEVEL_SECTIONS = [
-  {
-    title: "Pi console",
-    subtitle: "the operator surface \u2014 every attach opens the run's FULL Pi session",
-    commands: [
-      { command: "rig run attach <run-id>", description: "Open the run's Pi console: complete transcript (live AND finished runs), worker turns streaming in live." },
-      { command: "type a message", description: "Inside the console, plain text steers the worker mid-turn \u2014 it lands in the agent's context, not a local model." },
-      { command: "!<command>", description: "Inside the console, runs shell in the WORKER's workspace; output streams back into the transcript." },
-      { command: "/<command>", description: "The palette includes the WORKER session's slash commands ([worker]-tagged) next to /rig." },
-      { command: "/rig abort | /rig stop", description: "Abort the worker's current turn, or stop the whole run, from inside the console." },
-      { command: "rig run steer <id> --message <text>", description: "Steer without attaching \u2014 queue a message; the worker picks it up within seconds." }
-    ]
-  },
-  {
-    title: "Start here",
-    subtitle: "one-time setup, pick a server",
-    commands: [
-      { command: "rig init", description: "Wizard: config, GitHub auth, task source, server, Pi wiring." },
-      { command: "rig server use <alias|local>", description: "Pick which Rig server owns this repo (`rig server list` to see them)." },
-      { command: "rig server status", description: "Show the selected server for this repo." }
-    ]
-  },
-  {
-    title: "Work",
-    subtitle: "find a task, put an agent on it, answer what it asks",
-    commands: [
-      { command: "rig task list", description: "What's on the board (from the selected source/server)." },
-      { command: "rig task run --next", description: "Dispatch an agent on the next ready task; interactive mode drops you into its Pi console." },
-      { command: "rig run status", description: "Active and recent runs at a glance." },
-      { command: "rig run attach <id> --follow", description: "Same as plain attach \u2014 the Pi console is always the interactive surface." },
-      { command: "rig inbox approvals", description: "Approvals workers are waiting on (then `rig inbox approve \u2026`)." }
-    ]
-  },
-  {
-    title: "Watch",
-    subtitle: "fleet metrics and per-task forensics",
-    commands: [
-      { command: "rig stats [--since 7d]", description: "Fleet metrics: completion/failure rates, median run time, steering, stalls." },
-      { command: "rig inspect logs --task <id>", description: "Latest run log for a task." },
-      { command: "rig inspect diff --task <id>", description: "Changed files for a task." }
-    ]
-  },
-  {
-    title: "Unblock",
-    subtitle: "diagnose wiring, fix auth",
-    commands: [
-      { command: "rig doctor", description: "Check every part of the wiring \u2014 run this when anything feels off." },
-      { command: "rig github auth status", description: "GitHub auth state on the selected server." }
-    ]
-  },
-  {
-    title: "Extend",
-    subtitle: "plugins contribute validators, hooks, task sources, commands",
-    commands: [
-      { command: "rig plugin list", description: "What the rig.config.ts plugins contribute." },
-      { command: "rig plugin run <command-id>", description: "Execute a plugin-contributed CLI command." }
-    ]
-  }
-];
-var PRIMARY_GROUPS = [
-  {
-    name: "server",
-    summary: "Choose, inspect, and start the Rig server that owns tasks and runs.",
-    usage: ["rig server <status|list|add|use|repair-link|start> [options]"],
-    commands: [
-      { command: "status", description: "Show the selected server and remote project-root link for this repo.", primary: true },
-      { command: "use local", description: "Switch this repo to the local Rig server.", primary: true },
-      { command: "add <alias> <url>", description: "Save a remote Rig server URL.", primary: true },
-      { command: "use <alias>", description: "Select a saved remote server alias.", primary: true },
-      { command: "repair-link [--prepare|--backfill-only] [--repo owner/repo]", description: "Backfill or prepare the selected remote's server-host checkout link.", primary: true },
-      { command: "list", description: "List saved local/remote server aliases.", primary: true },
-      { command: "start [--host <host>] [--port <n>]", description: "Start a local rig-server process." }
-    ],
-    examples: [
-      "rig server status",
-      "rig server add prod https://where.rig-does.work",
-      "rig server use prod",
-      "rig server repair-link --repo owner/repo",
-      "rig server use local",
-      "rig server start --port 3773"
-    ],
-    next: ["Use `rig task list` to see server-owned work.", "Use `rig run list` or `rig run attach <id> --follow` to monitor runs."]
-  },
-  {
-    name: "task",
-    summary: "Find work, start Pi-backed runs, and validate task results.",
-    usage: ["rig task <list|next|show|run> [options]"],
-    commands: [
-      { command: "list [--assignee <login|me|@me>] [--state open|closed]", description: "List tasks from the selected server/source.", primary: true },
-      { command: "next [filters]", description: "Render the next matching task as a selected-task card.", primary: true },
-      { command: "show <id>|--task <id> [--raw]", description: "Show a human task summary; --raw prints the full payload.", primary: true },
-      { command: "run [#<issue>|<task-id>|--next|--task <id>]", description: "Submit a task run; interactive follows with bundled Pi.", primary: true },
-      { command: "ready", description: "List task IDs that are runnable now." },
-      { command: "validate|verify [--task <id>]", description: "Run configured task checks/review gates." },
-      { command: "details --task <id>", description: "Show full task info from the configured source." },
-      { command: "reopen [--task <id> | --all] [--reason <text>]", description: "Reopen closed task(s) in the configured source." },
-      { command: "artifacts|artifact-dir|artifact-write", description: "Inspect or write task artifacts." },
-      { command: "report-bug", description: "Create a structured bug report/task." }
-    ],
-    examples: [
-      "rig task list --assignee @me --limit 20",
-      "rig task next",
-      "rig task show 123 --raw",
-      "rig task run --next",
-      "rig task run #123 --runtime-adapter pi",
-      "rig task run --title 'Investigate deploy drift' --initial-prompt 'Check server health'"
-    ],
-    next: ["Use `--detach` to submit without attaching.", "Use `rig run attach <run-id> --follow` to rejoin a live run."]
-  },
-  {
-    name: "run",
-    summary: "Observe, attach to, and control Rig runs. `attach` opens the Pi console \u2014 the full worker session, live.",
-    usage: ["rig run <list|status|show|attach|steer|stop|resume|restart> [options]"],
-    commands: [
-      { command: "list", description: "List recent runs from the selected server or local state.", primary: true },
-      { command: "status", description: "Render active and recent run groups.", primary: true },
-      { command: "show <id>|--run <id> [--raw]", description: "Show a human run summary; --raw prints the full payload.", primary: true },
-      { command: "attach <run-id>|--run <id>", description: "Open the run's Pi console \u2014 see 'Inside the console' below. Works on live AND finished runs.", primary: true },
-      { command: "steer <run-id> --message <text>", description: "Queue a steering message into a live worker without attaching \u2014 delivered into the agent's context within seconds.", primary: true },
-      { command: "stop [<run-id>|--run <id>]", description: "Request stop for one run or local active runs.", primary: true },
-      { command: "resume [<run-id>]", description: "Resume an interrupted run on the selected server (defaults to the most recent resumable)." },
-      { command: "restart [<run-id>]", description: "Re-dispatch a run from a clean runtime, reopening its Pi session where possible." },
-      { command: "timeline --run <id> [--follow]", description: "Stream raw run timeline events (scripts; humans should attach)." },
-      { command: "replay <run-id>|--run <id> [--with-session]", description: "Print the run's consolidated run.jsonl as a merged timeline; --with-session interleaves the Pi session log." },
-      { command: "delete|cleanup", description: "Remove completed run records/artifacts." }
-    ],
-    examples: [
-      "rig run attach <run-id>          # full session console \u2014 live mirror, steering, worker shell",
-      "rig run steer <run-id> --message 'focus on the failing test first'",
-      "rig run list",
-      "rig run show <run-id>",
-      "rig run stop <run-id>"
-    ],
-    next: [
-      "Inside the console: the run's COMPLETE transcript loads on open (finished runs too), and new worker turns stream in live.",
-      "Inside the console: plain text = steering into the worker's context \xB7 !<cmd> = shell in the WORKER workspace \xB7 /<cmd> includes the worker session's commands \xB7 /rig abort stops the current turn.",
-      "The console is read-write but remote-only: nothing runs on your machine; the worker keeps running when you exit.",
-      "Use `rig task run --next` to create a new run; interactive mode drops you straight into its console.",
-      "Use `--json` when scripts need the full structured record."
-    ]
-  },
-  {
-    name: "inbox",
-    summary: "Review approval and user-input requests that block worker runs.",
-    usage: ["rig inbox <approvals|approve|inputs|respond> [options]"],
-    commands: [
-      { command: "approvals [--run <id>] [--task <id>]", description: "List pending approvals.", primary: true },
-      { command: "inputs [--run <id>] [--task <id>]", description: "List pending user-input requests.", primary: true },
-      { command: "approve --run <id> --request <id> --decision approve|reject", description: "Resolve an approval request." },
-      { command: "respond --run <id> --request <id> --answer key=value", description: "Answer a user-input request." }
-    ],
-    examples: [
-      "rig inbox approvals",
-      "rig inbox inputs --run <run-id>",
-      "rig inbox approve --run <run-id> --request <request-id> --decision approve"
-    ],
-    next: ["Rejoin the run after resolving a block: `rig run attach <run-id> --follow`."]
-  },
-  {
-    name: "stats",
-    summary: "Fleet metrics computed from on-disk run journals (no server required).",
-    usage: ["rig stats [show] [--since <7d|30d|ISO date>]"],
-    commands: [
-      { command: "show [--since <window>]", description: "Total runs, completion/failure/needs-attention rates, median run time, steering, stalls, approvals.", primary: true }
-    ],
-    examples: [
-      "rig stats",
-      "rig stats --since 7d",
-      "rig stats --since 2026-06-01 --json"
-    ],
-    next: ["Inspect outliers with `rig run list` and `rig run show <run-id>`.", "Use `--json` for the schema'd envelope (see docs/cli-json.md)."]
-  },
-  {
-    name: "inspect",
-    summary: "Inspect logs, artifacts, graphs, failures for a task.",
-    usage: ["rig inspect <logs|artifacts|failures|graph|audit|diff> --task <id>"],
-    commands: [
-      { command: "logs --task <id>", description: "Latest run log for a task (local or selected server).", primary: true },
-      { command: "artifacts --task <id>", description: "List the task's completion artifacts.", primary: true },
-      { command: "failures --task <id>", description: "Recorded failures for a task.", primary: true },
-      { command: "diff --task <id>", description: "Changed files for a task.", primary: true },
-      { command: "graph", description: "Task dependency graph." },
-      { command: "audit", description: "Controlled-command audit trail." }
-    ],
-    examples: ["rig inspect logs --task <id>", "rig inspect diff --task <id>"],
-    next: ["Use `rig stats` for fleet-level metrics across runs."]
-  },
-  {
-    name: "repo",
-    summary: "Repository sync/baseline helpers for the Rig-managed checkout.",
-    usage: ["rig repo <sync|reset-baseline>"],
-    commands: [
-      { command: "sync", description: "Sync project repository state.", primary: true },
-      { command: "reset-baseline", description: "Reset the managed baseline for the repo." }
-    ],
-    examples: ["rig repo sync"]
-  },
-  {
-    name: "plugin",
-    summary: "Plugin listing, validation, and plugin-contributed commands.",
-    usage: ["rig plugin <list|validate|run> [options]"],
-    commands: [
-      { command: "list", description: "List plugins declared in rig.config.ts and their contributions.", primary: true },
-      { command: "validate --task <id>", description: "Run plugin-contributed validators for a task.", primary: true },
-      { command: "run <command-id> [args...]", description: "Execute a plugin-contributed CLI command (also callable as `rig <command-id>`)." }
-    ],
-    examples: ["rig plugin list", "rig plugin run <command-id>"]
-  },
-  {
-    name: "init",
-    summary: "Set up Rig for this repo: server, GitHub auth, checkout strategy, task source, and Pi wiring.",
-    usage: ["rig init [--yes] [--server local|remote] [--repo owner/repo] [--remote-url <url>]"],
-    commands: [
-      { command: "init", description: "Interactive setup wizard for a new or existing Rig repo.", primary: true },
-      { command: "init --demo", description: "Offline demo project: files task source + 3 sample tasks, zero GitHub.", primary: true },
-      { command: "init --yes", description: "Non-interactive setup using detected/default settings.", primary: true },
-      { command: "init --server remote --remote-url <url>", description: "Link this repo to a remote Rig server.", primary: true },
-      { command: "init --repair", description: "Repair missing private state without replacing project config." }
-    ],
-    examples: [
-      "rig init",
-      "rig init --demo",
-      "rig init --yes --repo humanity-org/humanwork",
-      "rig init --server remote --remote-url https://where.rig-does.work --repo owner/repo"
-    ],
-    next: ["After init, run `rig server status`.", "Then use `rig task list` and `rig task run --next` for day-to-day work."]
-  },
-  {
-    name: "doctor",
-    summary: "Diagnostics for project/server/GitHub/Pi state.",
-    usage: ["rig doctor"],
-    commands: [
-      { command: "doctor", description: "Run setup and runtime diagnostics.", primary: true },
-      { command: "check", description: "Compatibility spelling for diagnostics." }
-    ],
-    examples: ["rig doctor", "rig doctor --json"],
-    next: ["Use `rig server status` and `rig github auth status` to inspect common failure points."]
-  },
-  {
-    name: "github",
-    summary: "GitHub auth helpers for the selected Rig server.",
-    usage: ["rig github auth <status|import-gh|token>"],
-    commands: [
-      { command: "auth status", description: "Show GitHub auth state.", primary: true },
-      { command: "auth import-gh", description: "Import the current `gh` token into the selected server." },
-      { command: "auth token --token <token>", description: "Store a token on the selected server." }
-    ],
-    examples: ["rig github auth status", "rig github auth import-gh"],
-    next: ["After auth is valid, use `rig task run --next`."]
-  }
-];
-var ADVANCED_GROUPS = [
-  {
-    name: "setup",
-    summary: "Bootstrap/check local setup.",
-    usage: ["rig setup <bootstrap|check|preflight>"],
-    commands: [
-      { command: "bootstrap", description: "Bootstrap local setup dependencies.", primary: true },
-      { command: "check", description: "Check local setup state (toolchain, deps, config).", primary: true },
-      { command: "preflight", description: "Run preflight checks before a run.", primary: true }
-    ]
-  },
-  {
-    name: "profile",
-    summary: "Runtime profile/model defaults.",
-    usage: ["rig profile <show|set>"],
-    commands: [
-      { command: "show", description: "Show the active execution profile.", primary: true },
-      { command: "set [--model <model>] [--runtime <runtime>] [--plugin <plugin>]", description: "Set model/runtime/plugin profile defaults.", primary: true }
-    ]
-  },
-  {
-    name: "review",
-    summary: "Inspect or change completion review gate policy.",
-    usage: ["rig review <show|set>"],
-    commands: [
-      { command: "show", description: "Show current review gate settings." },
-      { command: "set <off|advisory|required> [--provider <provider>]", description: "Change review strictness/provider (e.g. --provider greptile)." }
-    ],
-    examples: ["rig review show", "rig review set required --provider greptile"],
-    next: ["Use `rig inbox approvals` for blocked run handoffs."]
-  },
-  {
-    name: "browser",
-    summary: "Browser workstation actions for browser-required tasks: launch, check, CDP probe, profile reset, and app-specific smokes.",
-    usage: ["rig browser <help|explain|demo|hp-next|cdp-probe|profile-persistence|profile-lock-check|smoke-test> [options]"],
-    commands: [
-      { command: "help", description: "Rich browser command help (canonical: `rig browser help`).", primary: true },
-      { command: "explain", description: "Explain the browser-required task contract and runtime helper commands.", primary: true },
-      { command: "demo [--port <n>] [--profile <name>] [--state-dir <path>] [--target-url <url>] [--keep-open] [--no-build]", description: "Run a guided real browser/agent demo flow.", primary: true },
-      { command: "hp-next dev", description: "Start hp-next Rig Browser in dev/watch mode.", primary: true },
-      { command: "hp-next start", description: "Build/start the hp-next browser workstation without watch mode.", primary: true },
-      { command: "hp-next check", description: "Validate the hp-next CDP endpoint on the configured port.", primary: true },
-      { command: "hp-next e2e", description: "Run hp-next browser e2e smoke checks through Rig Browser.", primary: true },
-      { command: "hp-next reset", description: "Reset the hp-next browser profile when stale browser state is suspected.", primary: true },
-      { command: "cdp-probe", description: "Run an isolated CDP attach/evaluate/layout probe." },
-      { command: "profile-persistence", description: "Verify a named browser profile persists browser state." },
-      { command: "profile-lock-check", description: "Verify concurrent launches reject the same profile." },
-      { command: "smoke-test", description: "Run the browser package smoke test." }
-    ],
-    examples: [
-      "rig browser help",
-      "rig browser hp-next check",
-      "rig browser hp-next e2e",
-      "rig browser cdp-probe",
-      "rig browser profile-lock-check"
-    ],
-    next: ["Inside a task run, use rig-browser-launch, rig-browser-check, and rig-browser-attach-info from the worker PATH."]
-  },
-  {
-    name: "pi",
-    summary: "Manage Pi extension packages for this project (community extensions from npm/git).",
-    usage: ["rig pi <list|add|remove|search> [args]"],
-    commands: [
-      { command: "list", description: "Show project and user Pi extension packages." },
-      { command: "add <source>", description: "Add an npm/git Pi extension to .pi/settings.json (auto-installs at next session)." },
-      { command: "remove <source>", description: "Remove an operator-added Pi extension." },
-      { command: "search [term]", description: "Discover Pi extension packages on the npm registry." }
-    ],
-    examples: ["rig pi search subagents", "rig pi add pi-subagents", "rig pi list"],
-    next: ["Config-managed extensions: declare `runtime: { pi: { packages: [...] } }` in rig.config.ts \u2014 workers pick them up automatically."]
-  },
-  {
-    name: "queue",
-    summary: "Run task queues locally.",
-    usage: ["rig queue run [--workers <n>] [--max-tasks <n>] [--action validate|verify|pipeline] [--isolation off|worktree] [--no-runtime-reuse] [--fail-fast] [--skip-project-sync]"],
-    commands: [
-      { command: "run [--workers <n>] [--max-tasks <n>] [--action validate|verify|pipeline] [--isolation off|worktree] [--no-runtime-reuse] [--fail-fast] [--skip-project-sync]", description: "Process queue work: drain matching tasks with N workers, optional per-task action and isolation.", primary: true }
-    ]
-  },
-  {
-    name: "agent",
-    summary: "Runtime agent workspace helpers.",
-    usage: ["rig agent <list|prepare|run|cleanup>"],
-    commands: [
-      { command: "list", description: "List prepared agent runtimes.", primary: true },
-      { command: "prepare [--id <id>] [--mode <mode>] [--task <task>]", description: "Prepare an isolated agent runtime workspace.", primary: true },
-      { command: "run [--id <id>] [--mode <mode>] [--task <task>] [--skip-project-sync]", description: "Prepare (if needed) and run an agent in its workspace.", primary: true },
-      { command: "cleanup [--all] [--id <id>]", description: "Remove prepared agent workspaces.", primary: true }
-    ]
-  },
-  { name: "inspector", summary: "Event stream and drift scanners.", usage: ["rig inspector <stream|scan-upstream-drift>"], commands: [{ command: "stream", description: "Stream events." }] },
-  {
-    name: "dist",
-    summary: "Build/install packaged Rig CLI.",
-    usage: ["rig dist <build|install|doctor|rebuild-agent>"],
-    commands: [
-      { command: "build [--output-dir <dir>]", description: "Build the distributable Rig CLI.", primary: true },
-      { command: "install [--scope <scope>] [--path <path>]", description: "Install the built CLI to a scope/path.", primary: true },
-      { command: "doctor", description: "Diagnose the dist toolchain and install state.", primary: true },
-      { command: "rebuild-agent", description: "Rebuild the agent runtime image, pruning stale images.", primary: true }
-    ]
-  },
-  { name: "workspace", summary: "Workspace topology/service helpers.", usage: ["rig workspace <summary|topology|remote-hosts>"], commands: [{ command: "summary", description: "Show workspace summary." }] },
-  {
-    name: "remote",
-    summary: "Compatibility remote orchestration controls.",
-    usage: ["rig remote <status|tasks|watch|pause|resume|continue|stop|refresh|add-iterations|remove-iterations|endpoint ...>"],
-    commands: [
-      { command: "status [--remote <alias>]", description: "Show the remote orchestration state.", primary: true },
-      { command: "tasks [--remote <alias>]", description: "List the remote's tracked tasks.", primary: true },
-      { command: "watch [--remote <alias>] [--seconds <n>] [--event <type>]", description: "Stream remote orchestration events.", primary: true },
-      { command: "pause [--remote <alias>]", description: "Pause the running remote orchestration.", primary: true },
-      { command: "resume [--remote <alias>] [--max-workers <n>] [--max-iterations <n>] [--direct-merge]", description: "Resume the remote with optional tuning.", primary: true },
-      { command: "continue [--remote <alias>]", description: "Continue a paused remote orchestration.", primary: true },
-      { command: "stop [--remote <alias>]", description: "Stop the remote orchestration.", primary: true },
-      { command: "refresh [--remote <alias>]", description: "Refresh remote state.", primary: true },
-      { command: "add-iterations [--count <n>] [--remote <alias>]", description: "Grant the remote more iterations.", primary: true },
-      { command: "remove-iterations [--count <n>] [--remote <alias>]", description: "Reduce the remote's iteration budget.", primary: true },
-      { command: "endpoint list", description: "List configured remote endpoints.", primary: true },
-      { command: "endpoint add --alias <alias> --host <host> --port <n> [--token <token>]", description: "Register a remote endpoint.", primary: true },
-      { command: "endpoint remove --alias <alias>", description: "Remove a remote endpoint.", primary: true },
-      { command: "endpoint test [--alias <alias>]", description: "Test connectivity to a remote endpoint.", primary: true },
-      { command: "endpoint doctor", description: "Diagnose remote endpoint configuration.", primary: true }
-    ]
-  },
-  { name: "git", summary: "Pass through to Rig git-flow helper.", usage: ["rig git <args...>"], commands: [{ command: "<args...>", description: "Advanced git flow operations." }] },
-  { name: "harness", summary: "Pass through to runtime harness CLI.", usage: ["rig harness <args...>"], commands: [{ command: "<args...>", description: "Advanced harness operations." }] },
-  { name: "test", summary: "Project test wrappers.", usage: ["rig test <unit|e2e|all>"], commands: [{ command: "all", description: "Run configured project tests." }] }
-];
-var ALL_GROUPS = [...PRIMARY_GROUPS, ...ADVANCED_GROUPS];
-
-// packages/cli/src/app-opentui/surface-catalog.ts
-var NATIVE_FAMILY_SCENES = {
-  run: { scene: "fleet", kind: "refresh", argv: ["run", "status"], label: "Open runs" },
-  task: { scene: "tasks", kind: "refresh", argv: ["task", "list"], label: "Open tasks" },
-  inbox: { scene: "inbox", kind: "refresh", argv: ["inbox", "approvals"], label: "Open inbox" },
-  server: { scene: "server", kind: "refresh", argv: ["server", "status"], label: "Open server" },
-  init: { scene: "init", kind: "refresh", argv: ["init"], label: "Open init" },
-  doctor: { scene: "doctor", kind: "doctor-run", argv: ["doctor"], label: "Run doctor" }
-};
-var BESPOKE_FAMILIES = new Set([
-  "run",
-  "task",
-  "inbox",
-  "server",
-  "init",
-  "doctor",
-  "pi",
-  "plugin",
-  "repo",
-  "workspace",
-  "inspect"
-]);
-var SAFE_DIRECT_COMMANDS = new Set([
-  "server status",
-  "server list",
-  "server use local",
-  "task list",
-  "task next",
-  "task ready",
-  "run list",
-  "run status",
-  "inbox approvals",
-  "inbox inputs",
-  "stats show",
-  "plugin list",
-  "doctor doctor",
-  "doctor check",
-  "github auth status",
-  "browser help",
-  "browser explain",
-  "pi list",
-  "pi search",
-  "setup check",
-  "profile show",
-  "review show",
-  "repo sync",
-  "agent list",
-  "dist doctor",
-  "workspace summary",
-  "remote status"
-]);
-function normalizeCommandTemplate(command) {
-  return command.replace(/\s+/g, " ").trim();
-}
-function firstAlternative(value) {
-  return value.split("|")[0]?.trim() ?? value.trim();
-}
-function stripOptionalSegments(value) {
-  return value.replace(/\[[^\]]*\]/g, "").replace(/\s+/g, " ").trim();
-}
-function commandNeedsArguments(template) {
-  return /<[^>]+>|\.\.\.|\|/.test(template);
-}
-function commandKey(family, command) {
-  return `${family} ${normalizeCommandTemplate(command)}`.replace(/\s+/g, " ").trim();
-}
-function commandArgvForTemplate(group, command) {
-  const family = group.name;
-  const template = normalizeCommandTemplate(command.command);
-  if (!template || template === family)
-    return [family, "--help"];
-  const key = commandKey(family, template);
-  if (SAFE_DIRECT_COMMANDS.has(key))
-    return [family, ...stripOptionalSegments(template).split(/\s+/).filter(Boolean)];
-  const base = firstAlternative(stripOptionalSegments(template));
-  const parts = base.split(/\s+/).filter(Boolean);
-  if (!commandNeedsArguments(template) && parts.length > 0)
-    return [family, ...parts];
-  return [family, "--help"];
-}
-function promptArgvForTemplate(group, command) {
-  const base = stripOptionalSegments(firstAlternative(normalizeCommandTemplate(command.command)));
-  const words = [];
-  for (const part of base.split(/\s+/).filter(Boolean)) {
-    if (/[<>]|\.\.\./.test(part))
-      break;
-    words.push(part);
-  }
-  return [group.name, ...words];
-}
-function sceneForGroup(group) {
-  const native = NATIVE_FAMILY_SCENES[group.name];
-  if (native)
-    return native;
-  if (!BESPOKE_FAMILIES.has(group.name)) {
-    return { scene: "family", kind: "refresh", argv: [group.name], label: `Open ${group.name}` };
-  }
-  return { scene: "command", kind: "command-run", argv: [group.name, "--help"], label: `Open ${group.name}` };
-}
-function tuiSurfaceActions() {
-  const { groups } = helpCatalog();
-  return groups.flatMap((group) => {
-    const family = sceneForGroup(group);
-    const groupAction = {
-      id: `family:${group.name}`,
-      family: group.name,
-      label: group.name,
-      detail: group.summary,
-      argv: family.argv,
-      scene: family.scene,
-      kind: family.kind,
-      primary: true
-    };
-    const commandActions = group.commands.map((command, index) => {
-      const argv = commandArgvForTemplate(group, command);
-      const direct = argv[0] === group.name && argv.slice(1).join(" ") === stripOptionalSegments(firstAlternative(command.command));
-      const template = normalizeCommandTemplate(command.command);
-      const needsArgs = commandNeedsArguments(template) && argv.length === 2 && argv[1] === "--help";
-      const promptArgv = needsArgs ? promptArgvForTemplate(group, command) : undefined;
-      return {
-        id: `command:${group.name}:${index}:${command.command}`,
-        family: group.name,
-        label: `${group.name} ${command.command}`,
-        detail: direct ? command.description : needsArgs ? `${command.description} \xB7 enter args to run` : `${command.description} \xB7 opens ${group.name} command workspace/help`,
-        argv,
-        scene: "command",
-        kind: "command-run",
-        primary: command.primary,
-        template: `rig ${group.name} ${command.command}`.replace(/\s+/g, " ").trim(),
-        ...needsArgs ? { needsArgs: true, promptArgv } : {}
-      };
-    });
-    return [groupAction, ...commandActions];
-  });
-}
-function intentForSurfaceAction(action) {
-  return {
-    scene: action.scene,
-    argv: action.argv,
-    action: {
-      kind: action.kind,
-      label: action.kind === "command-run" ? `Open ${action.label}` : action.label,
-      payload: {
-        argv: [...action.argv],
-        family: action.family,
-        ...action.template ? { template: action.template } : {}
-      }
-    }
-  };
-}
-
-// packages/cli/src/app-opentui/autocomplete.ts
-var NAV_VERBS = ["runs", "tasks", "inbox", "server", "doctor", "help", "init", "main"];
-var cachedCandidates = null;
-function commandCandidates() {
-  if (cachedCandidates)
-    return cachedCandidates;
-  const set = new Set(NAV_VERBS);
-  for (const action of tuiSurfaceActions()) {
-    const argv = action.promptArgv ?? action.argv;
-    const command = argv.join(" ").trim();
-    if (command && !command.endsWith("--help"))
-      set.add(command);
-    if (action.family)
-      set.add(action.family);
-  }
-  cachedCandidates = [...set].sort((a, b) => a.localeCompare(b));
-  return cachedCandidates;
-}
-function matchesFor(base, candidates = commandCandidates()) {
-  const needle = base.trim().toLowerCase();
-  if (!needle)
-    return [];
-  return candidates.filter((candidate) => candidate.toLowerCase().startsWith(needle) && candidate.toLowerCase() !== needle);
-}
-function cycleCompletion(value, state, candidates = commandCandidates()) {
-  const base = state && matchesFor(state.base, candidates).includes(value) ? state.base : value;
-  const matches = matchesFor(base, candidates);
-  if (matches.length === 0)
-    return { value, state: undefined };
-  const startIndex = state && base === state.base ? state.index : -1;
-  const nextIndex = (startIndex + 1) % matches.length;
-  return { value: matches[nextIndex], state: { base, index: nextIndex } };
-}
-
-// packages/cli/src/app-opentui/keymap.ts
-var autocompleteState;
-function clearTypeBar(context, message) {
-  const typeBar = context.getTypeBar();
-  if (typeBar)
-    typeBar.input.value = "";
-  context.emitTypeBarPatch({ value: "", mode: "nav", prompt: undefined, message });
-}
-function handleEmbeddedTerminalKey(context, key) {
-  if (context.getState().scene !== "command")
-    return false;
-  const host = getActiveCommandHost();
-  if (!host)
-    return false;
-  if (key.ctrl && key.name === "]") {
-    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 printableChar(key) {
-  if (key.ctrl || key.meta || key.super || key.hyper)
-    return null;
-  if (key.name === "space")
-    return " ";
-  const seq = key.sequence;
-  if (seq && seq.length === 1 && seq >= " " && seq !== "\x7F")
-    return seq;
-  return null;
-}
-function enterInputMode(context, mode) {
-  context.emitTypeBarPatch({ mode, value: "", prompt: undefined, message: undefined });
-}
-function submitInput(context, state) {
-  const mode = state.typeBar.mode ?? "nav";
-  const value = state.typeBar.value.trim();
-  if (mode === "search") {
-    context.emitTypeBarPatch({ mode: "nav" });
-    return;
-  }
-  if (mode === "command") {
-    if (!value) {
-      clearTypeBar(context);
-      return;
-    }
-    const intent2 = intentFromTypeBar(value);
-    context.emitTypeBarPatch({ value: "", mode: "nav", prompt: undefined });
-    context.runAppAction(intent2.action.label ?? "Run command", () => context.runtime.runIntent(intent2));
-    return;
-  }
-  if (mode === "prompt") {
-    const prompt = state.typeBar.prompt;
-    if (!prompt || !value) {
-      clearTypeBar(context, prompt ? "enter a value" : undefined);
-      return;
-    }
-    const intent2 = prompt.appendValueToArgv ? {
-      scene: prompt.scene,
-      argv: [...prompt.argv, ...value.split(/\s+/).filter(Boolean)],
-      action: { kind: prompt.intentKind, label: `${prompt.label} ${value}`.trim(), payload: { ...prompt.payloadBase, argv: [...prompt.argv, ...value.split(/\s+/).filter(Boolean)] } }
-    } : {
-      scene: prompt.scene,
-      argv: prompt.argv,
-      action: { kind: prompt.intentKind, label: prompt.label, payload: { ...prompt.payloadBase, [prompt.payloadKey]: value } }
-    };
-    context.emitTypeBarPatch({ value: "", mode: "nav", prompt: undefined });
-    context.runAppAction(prompt.label, () => context.runtime.runIntent(intent2));
-    return;
-  }
-  clearTypeBar(context);
-}
-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 mode = state.typeBar.mode ?? "nav";
-  if (state.confirm) {
-    if (key.name === "return" || key.name === "enter" || key.sequence === "y") {
-      const intent2 = state.confirm.intent;
-      const label = state.confirm.label;
-      context.runAppAction(label, () => context.runtime.runIntent(intent2));
-      return;
-    }
-    if (key.name === "escape" || key.sequence === "n") {
-      context.runtime.emit({ type: "confirm.cancel" });
-      return;
-    }
-    return;
-  }
-  if (mode !== "nav") {
-    if (key.name === "escape") {
-      autocompleteState = undefined;
-      clearTypeBar(context);
-      return;
-    }
-    if (mode === "command" && key.name === "tab") {
-      const result = cycleCompletion(state.typeBar.value, autocompleteState, commandCandidates());
-      autocompleteState = result.state;
-      if (result.value !== state.typeBar.value)
-        context.emitTypeBarPatch({ value: result.value });
-      return;
-    }
-    if (key.name === "return" || key.name === "enter") {
-      autocompleteState = undefined;
-      if (mode === "command") {
-        const items = context.getRenderedSelectableItems();
-        if (items.length > 0) {
-          context.runAppAction("Run command", () => context.activateSelection(items));
-          return;
-        }
-      }
-      submitInput(context, state);
-      return;
-    }
-    if (key.name === "backspace" || key.sequence === "\x7F") {
-      context.emitTypeBarPatch({ value: state.typeBar.value.slice(0, -1) });
-      return;
-    }
-    if (key.name === "up" || key.name === "down") {
-      context.moveSelection(key.name === "up" ? -1 : 1, context.getRenderedSelectableItems());
-      return;
-    }
-    const char = printableChar(key);
-    if (char) {
-      context.emitTypeBarPatch({ value: state.typeBar.value + char });
-      return;
-    }
-    return;
-  }
-  const hasFilter = state.typeBar.value.trim() !== "";
-  if (key.sequence === "/" || key.sequence === ":") {
-    autocompleteState = undefined;
-    context.runtime.patchState({ selection: { index: 0, count: 0 } });
-    enterInputMode(context, "command");
-    return;
-  }
-  if (key.name === "right" || key.name === "tab") {
-    context.runAppAction("Navigate", () => context.runtime.runIntent(context.primaryNavIntent(context.nextPrimaryScene(context.getState().scene, 1))));
-    return;
-  }
-  if (key.name === "left") {
-    context.runAppAction("Navigate", () => context.runtime.runIntent(context.primaryNavIntent(context.nextPrimaryScene(context.getState().scene, -1))));
-    return;
-  }
-  if (key.name === "r") {
-    context.runAppAction("Opening runs", () => context.runtime.runIntent(context.primaryNavIntent("fleet")));
-    return;
-  }
-  if (key.name === "t") {
-    context.runAppAction("Opening tasks", () => context.runtime.runIntent(context.primaryNavIntent("tasks")));
-    return;
-  }
-  if (key.name === "h" || key.sequence === "?") {
-    context.runAppAction("Opening help", () => context.runtime.runIntent(context.primaryNavIntent("help")));
-    return;
-  }
-  const PAGE_ROWS = 16;
-  if (key.name === "pageup") {
-    context.scrollActiveBody(-PAGE_ROWS);
-    return;
-  }
-  if (key.name === "pagedown") {
-    context.scrollActiveBody(PAGE_ROWS);
-    return;
-  }
-  if (key.ctrl && key.name === "u") {
-    context.scrollActiveBody(-Math.round(PAGE_ROWS / 2));
-    return;
-  }
-  if (key.ctrl && key.name === "d") {
-    context.scrollActiveBody(Math.round(PAGE_ROWS / 2));
-    return;
-  }
-  if (key.name === "home" && !hasFilter) {
-    context.scrollActiveBody(-1e6);
-    return;
-  }
-  if (key.name === "end" && !hasFilter) {
-    context.scrollActiveBody(1e6);
-    return;
-  }
-  if (key.name === "up" || key.name === "k") {
-    if (context.moveSelection(-1, context.getRenderedSelectableItems()))
-      return;
-  }
-  if (key.name === "down" || key.name === "j") {
-    if (context.moveSelection(1, context.getRenderedSelectableItems()))
-      return;
-  }
-  if (key.name === "return" || key.name === "enter" || key.name === "space" || key.sequence === " ") {
-    context.runAppAction("Activate selection", () => context.activateSelection(context.getRenderedSelectableItems()));
-    return;
-  }
-  if (key.name === "q") {
-    if (currentScene === "main")
-      renderer?.destroy();
-    else
-      context.runAppAction("Back", () => context.runtime.goBack());
-    return;
-  }
-  if (key.name === "escape") {
-    if (hasFilter)
-      clearTypeBar(context);
-    else
-      context.runAppAction("Back", () => context.runtime.goBack());
-  }
-}
-
-// packages/cli/src/app-opentui/layout.ts
-var MIN_TERMINAL_WIDTH = 48;
-var MIN_TERMINAL_HEIGHT = 16;
-function computeStageLayout(width, height) {
-  const rawWidth = Math.trunc(width || 80);
-  const rawHeight = Math.trunc(height || 24);
-  const tooSmall = rawWidth < MIN_TERMINAL_WIDTH || rawHeight < MIN_TERMINAL_HEIGHT;
-  const safeWidth = Math.max(40, rawWidth);
-  const safeHeight = Math.max(18, rawHeight);
-  const compact = safeWidth < 92 || safeHeight < 30;
-  const horizontalGutter = compact ? 1 : 2;
-  const centerWidth = Math.max(36, safeWidth - horizontalGutter * 2);
-  const centerLeft = horizontalGutter;
-  const footerTop = Math.max(0, safeHeight - 1);
-  const typeBarTop = Math.max(0, footerTop - 1);
-  const centerTop = compact ? 1 : Math.max(1, Math.floor(safeHeight * 0.055));
-  const centerHeight = Math.max(6, typeBarTop - centerTop);
-  return { width: safeWidth, height: safeHeight, centerWidth, centerLeft, centerTop, centerHeight, typeBarTop, footerTop, compact, tooSmall };
-}
-function visibleWidth(text) {
-  return [...text].length;
-}
-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/commands/_server-events.ts
-import { WsTransport } from "@rig/client";
-import { RIG_WS_CHANNELS } from "@rig/contracts";
-
-// packages/cli/src/commands/_server-client.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, isAbsolute, resolve as resolve2 } from "path";
-
-// packages/cli/src/runner.ts
-import { EventBus } from "@rig/runtime/control-plane/runtime/events";
-import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
-import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
-import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
-
-class CliError extends RuntimeCliError {
-  hint;
-  constructor(message, exitCode = 1, options = {}) {
-    super(message, exitCode);
-    if (options.hint?.trim()) {
-      this.hint = options.hint.trim();
-    }
-  }
-}
-
-// packages/cli/src/commands/_server-client.ts
-import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
-
-// packages/cli/src/commands/_connection-state.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, resolve } from "path";
-function resolveGlobalConnectionsPath(env = process.env) {
-  const explicit = env.RIG_CONNECTIONS_FILE?.trim();
-  if (explicit)
-    return resolve(explicit);
-  const stateDir = env.RIG_GLOBAL_STATE_DIR?.trim();
-  if (stateDir)
-    return resolve(stateDir, "connections.json");
-  return resolve(homedir(), ".rig", "connections.json");
-}
-function resolveRepoConnectionPath(projectRoot) {
-  return resolve(projectRoot, ".rig", "state", "connection.json");
-}
-function readJsonFile(path) {
-  if (!existsSync(path))
-    return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch (error) {
-    throw new CliError(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1, { hint: "Fix or delete that file, then re-select a server with `rig server use <alias|local>`." });
-  }
-}
-function writeJsonFile(path, value) {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-function normalizeConnection(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const record = value;
-  if (record.kind === "local")
-    return { kind: "local", mode: "auto" };
-  if (record.kind === "remote" && typeof record.baseUrl === "string" && record.baseUrl.trim()) {
-    const baseUrl = record.baseUrl.trim().replace(/\/+$/, "");
-    return { kind: "remote", baseUrl };
-  }
-  return null;
-}
-function readGlobalConnections(options = {}) {
-  const path = resolveGlobalConnectionsPath(options.env ?? process.env);
-  const payload = readJsonFile(path);
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    return { connections: {} };
-  }
-  const rawConnections = payload.connections;
-  const connections = {};
-  if (rawConnections && typeof rawConnections === "object" && !Array.isArray(rawConnections)) {
-    for (const [alias, raw] of Object.entries(rawConnections)) {
-      const connection = normalizeConnection(raw);
-      if (connection)
-        connections[alias] = connection;
-    }
-  }
-  return { connections };
-}
-function readRepoConnection(projectRoot) {
-  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const record = payload;
-  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
-  if (!selected)
-    return null;
-  return {
-    selected,
-    project: typeof record.project === "string" ? record.project : undefined,
-    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
-    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined,
-    serverProjectRootAlias: typeof record.serverProjectRootAlias === "string" && record.serverProjectRootAlias.trim() ? record.serverProjectRootAlias.trim() : undefined,
-    serverProjectRootBaseUrl: typeof record.serverProjectRootBaseUrl === "string" && record.serverProjectRootBaseUrl.trim() ? record.serverProjectRootBaseUrl.trim().replace(/\/+$/, "") : undefined
-  };
-}
-function writeRepoConnection(projectRoot, state) {
-  writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
-}
-function rootAllowedForSelection(repo, connection) {
-  const root = repo.serverProjectRoot?.trim();
-  if (!root)
-    return;
-  if (connection.kind === "remote") {
-    if (repo.serverProjectRootAlias !== repo.selected)
-      return;
-    if (repo.serverProjectRootBaseUrl !== connection.baseUrl)
-      return;
-  } else if (repo.serverProjectRootAlias && repo.serverProjectRootAlias !== repo.selected) {
-    return;
-  }
-  return root;
-}
-function resolveSelectedConnection(projectRoot, options = {}) {
-  const repo = readRepoConnection(projectRoot);
-  if (!repo)
-    return null;
-  if (repo.selected === "local")
-    return { alias: "local", connection: { kind: "local", mode: "auto" }, serverProjectRoot: repo.serverProjectRoot };
-  const global = readGlobalConnections(options);
-  const connection = global.connections[repo.selected];
-  if (!connection) {
-    throw new CliError(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
-  }
-  return { alias: repo.selected, connection, serverProjectRoot: rootAllowedForSelection(repo, connection) };
-}
-function writeRepoServerProjectRoot(projectRoot, serverProjectRoot, metadata = {}) {
-  const repo = readRepoConnection(projectRoot);
-  if (!repo)
-    return;
-  let inferred = metadata;
-  if (!inferred.alias || !inferred.baseUrl) {
-    try {
-      const selected = resolveSelectedConnection(projectRoot);
-      if (selected?.connection.kind === "remote") {
-        inferred = {
-          alias: inferred.alias ?? selected.alias,
-          baseUrl: inferred.baseUrl ?? selected.connection.baseUrl
-        };
-      }
-    } catch {}
-  }
-  writeRepoConnection(projectRoot, {
-    ...repo,
-    ...metadata.project ? { project: metadata.project } : {},
-    serverProjectRoot,
-    ...inferred.alias ? { serverProjectRootAlias: inferred.alias } : {},
-    ...inferred.baseUrl ? { serverProjectRootBaseUrl: inferred.baseUrl.replace(/\/+$/, "") } : {}
-  });
-}
-function clearRepoServerProjectRoot(projectRoot) {
-  const repo = readRepoConnection(projectRoot);
-  if (!repo)
-    return;
-  writeRepoConnection(projectRoot, {
-    selected: repo.selected,
-    ...repo.project ? { project: repo.project } : {},
-    ...repo.linkedAt ? { linkedAt: repo.linkedAt } : {}
-  });
-}
-
-// packages/cli/src/commands/_server-client.ts
-var scopedGitHubBearerTokens = new Map;
-var serverPhaseListener = null;
-function reportServerPhase(label) {
-  serverPhaseListener?.(label);
-}
-function cleanToken(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : null;
-}
-function readRemoteAuthState(projectRoot) {
-  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
-  if (!existsSync2(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function readPrivateRemoteSessionToken(projectRoot) {
-  const parsed = readRemoteAuthState(projectRoot);
-  return parsed ? cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined) : null;
-}
-function readGitHubBearerTokenForRemote(projectRoot) {
-  const scopedKey = resolve2(projectRoot);
-  if (scopedGitHubBearerTokens.has(scopedKey))
-    return scopedGitHubBearerTokens.get(scopedKey) ?? null;
-  const privateSession = readPrivateRemoteSessionToken(projectRoot);
-  if (privateSession)
-    return privateSession;
-  return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
-}
-function readStoredGitHubAuthToken(projectRoot) {
-  const parsed = readRemoteAuthState(projectRoot);
-  return parsed ? cleanToken(typeof parsed.token === "string" ? parsed.token : undefined) : null;
-}
-function inferRemoteServerProjectRootCandidateFromAuthState(projectRoot, repoSlug) {
-  if (!/^[^/]+\/[^/]+$/.test(repoSlug))
-    return null;
-  const repo = readRepoConnection(projectRoot);
-  const auth = readRemoteAuthState(projectRoot);
-  const authUpdatedAt = typeof auth?.updatedAt === "string" ? Date.parse(auth.updatedAt) : Number.NaN;
-  const repoLinkedAt = typeof repo?.linkedAt === "string" ? Date.parse(repo.linkedAt) : Number.NaN;
-  if (Number.isFinite(authUpdatedAt) && Number.isFinite(repoLinkedAt) && authUpdatedAt + 1000 < repoLinkedAt)
-    return null;
-  const checkoutBaseDir = typeof auth?.checkoutBaseDir === "string" && auth.checkoutBaseDir.trim() ? auth.checkoutBaseDir.trim() : null;
-  if (!checkoutBaseDir)
-    return null;
-  return `${checkoutBaseDir.replace(/\/+$/, "")}/${repoSlug}`;
-}
-function readLocalConnectionFallbackToken(projectRoot) {
-  return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
-}
-function normalizeRepoSlug(value) {
-  const slug = value?.trim();
-  return slug && /^[^/\s]+\/[^/\s]+$/.test(slug) ? slug : null;
-}
-function readProjectLinkSlug(projectRoot) {
-  const path = resolve2(projectRoot, ".rig", "state", "project-link.json");
-  if (!existsSync2(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-      return null;
-    return normalizeRepoSlug(typeof parsed.repoSlug === "string" ? String(parsed.repoSlug) : null);
-  } catch {
-    return null;
-  }
-}
-function writeProjectLinkConnection(projectRoot, repoSlug, alias) {
-  const path = resolve2(projectRoot, ".rig", "state", "project-link.json");
-  mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync2(path, `${JSON.stringify({ repoSlug, connection: alias, linkedAt: new Date().toISOString() }, null, 2)}
-`, "utf8");
-}
-function remoteLinkRepairCommand(repoSlug) {
-  return repoSlug ? `rig server repair-link --repo ${repoSlug}` : "rig server repair-link --repo owner/repo";
-}
-function formatRemoteProjectLinkHint(resolution) {
-  const repair = remoteLinkRepairCommand(resolution.repoSlug);
-  if (resolution.status === "auth_required") {
-    return `Authenticate the selected remote${resolution.alias ? ` (${resolution.alias})` : ""}, then run \`${repair}\`. Use \`rig github auth import-gh\` or \`rig init --repair --server remote --github-auth device${resolution.repoSlug ? ` --repo ${resolution.repoSlug}` : ""}\`.`;
-  }
-  if (resolution.status === "missing_project") {
-    return `Record the repo slug, then run \`${repair}\` (or \`rig init --repo owner/repo --server remote --github-auth device\`).`;
-  }
-  if (resolution.status === "not_remote")
-    return "Select a remote server with `rig server use <alias>` before repairing a remote project link.";
-  return `Run \`${repair}\` to backfill or prepare a server-host checkout for the selected remote${resolution.alias ? ` (${resolution.alias})` : ""}.`;
-}
-function remoteProjectLinkFailure(input) {
-  const partial = {
-    status: input.status,
-    alias: input.alias,
-    baseUrl: input.baseUrl,
-    repoSlug: input.repoSlug
-  };
-  return {
-    ok: false,
-    ...input,
-    hint: formatRemoteProjectLinkHint(partial),
-    next: remoteLinkRepairCommand(input.repoSlug)
-  };
-}
-function remoteProjectLinkSuccess(input) {
-  return {
-    ok: true,
-    status: input.status,
-    alias: input.alias,
-    baseUrl: input.baseUrl,
-    repoSlug: input.repoSlug,
-    serverProjectRoot: input.serverProjectRoot,
-    source: input.source,
-    prepared: input.prepared ?? input.status === "prepared",
-    validated: input.validated ?? false,
-    message: input.message ?? `Remote project link ready for ${input.repoSlug}.`,
-    hint: "Remote-scoped task/run/status requests will send x-rig-project-root for this server-host checkout.",
-    next: "rig task list"
-  };
-}
-function localCheckoutPathCandidate(projectRoot, candidate) {
-  try {
-    const local = resolve2(projectRoot);
-    const resolved = resolve2(candidate);
-    return resolved === local || resolved.startsWith(`${local}/`);
-  } catch {
-    return false;
-  }
-}
-async function requestRemoteProjectLinkJson(baseUrl, pathname, authToken, init = {}) {
-  const requestUrl = new URL(`${baseUrl}${pathname}`);
-  if (authToken && queryAuthFallbackEnabled())
-    requestUrl.searchParams.set("rt", authToken);
-  const response = await fetch(requestUrl, {
-    ...init,
-    headers: mergeHeaders(init.headers, authToken)
-  });
-  const text = await response.text();
-  const payload = text.trim().length > 0 ? (() => {
-    try {
-      return JSON.parse(text);
-    } catch {
-      return null;
-    }
-  })() : null;
-  return { ok: response.ok, status: response.status, payload, text };
-}
-function payloadError(payload, fallback) {
-  if (payload && typeof payload === "object" && !Array.isArray(payload)) {
-    const record = payload;
-    const value = record.error ?? record.message ?? record.reason;
-    if (typeof value === "string" && value.trim())
-      return value.trim();
-  }
-  return fallback;
-}
-function checkoutPathsFromProjectPayload(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return [];
-  const project = payload.project;
-  if (!project || typeof project !== "object" || Array.isArray(project))
-    return [];
-  const checkouts = project.checkouts;
-  if (!Array.isArray(checkouts))
-    return [];
-  return [...checkouts].reverse().flatMap((entry) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry))
-      return [];
-    const path = entry.path;
-    return typeof path === "string" && path.trim() ? [path.trim()] : [];
-  });
-}
-function checkoutPathFromPreparePayload(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const checkout = payload.checkout;
-  if (!checkout || typeof checkout !== "object" || Array.isArray(checkout))
-    return null;
-  const path = checkout.path;
-  return typeof path === "string" && path.trim() ? path.trim() : null;
-}
-async function validateAndPersistRemoteRoot(input) {
-  const candidate = input.candidate.trim();
-  if (!candidate || !isAbsolute(candidate)) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      message: `Remote project root candidate is not an absolute server-host path: ${candidate || "(empty)"}.`
-    });
-  }
-  if (localCheckoutPathCandidate(input.projectRoot, candidate)) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      message: `Refusing to use local checkout path ${candidate} as a remote server project root.`
-    });
-  }
-  let response;
-  try {
-    response = await requestRemoteProjectLinkJson(input.baseUrl, "/api/server/project-root", input.authToken, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ projectRoot: candidate })
-    });
-  } catch (error) {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      message: `Could not validate remote project root ${candidate}: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-  if (response.status === 401 || response.status === 403) {
-    return remoteProjectLinkFailure({
-      status: "auth_required",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      statusCode: response.status,
-      message: `Remote server ${input.alias} requires authentication before validating project root ${candidate}.`
-    });
-  }
-  if (!response.ok) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      statusCode: response.status,
-      message: `Remote server rejected project root ${candidate} (${response.status}): ${payloadError(response.payload, response.text || "project-root validation failed")}`
-    });
-  }
-  const record = response.payload && typeof response.payload === "object" && !Array.isArray(response.payload) ? response.payload : {};
-  if (record.ok !== true) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      message: `Remote server did not accept project root ${candidate}: ${payloadError(response.payload, "project-root validation failed")}`
-    });
-  }
-  const accepted = typeof record.projectRoot === "string" && record.projectRoot.trim() ? record.projectRoot.trim() : typeof record.requestedProjectRoot === "string" && record.requestedProjectRoot.trim() ? record.requestedProjectRoot.trim() : candidate;
-  writeRepoServerProjectRoot(input.projectRoot, accepted, { alias: input.alias, baseUrl: input.baseUrl, project: input.repoSlug });
-  writeProjectLinkConnection(input.projectRoot, input.repoSlug, input.alias);
-  const status = input.status ?? (input.prepared ? "prepared" : "backfilled");
-  return remoteProjectLinkSuccess({
-    status,
-    alias: input.alias,
-    baseUrl: input.baseUrl,
-    repoSlug: input.repoSlug,
-    serverProjectRoot: accepted,
-    source: input.source,
-    prepared: input.prepared,
-    validated: true,
-    message: status === "ready" ? `Remote project link already points to ${accepted} and was validated on ${input.alias}.` : input.prepared ? `Prepared and linked remote checkout ${accepted} for ${input.repoSlug}.` : `Backfilled remote checkout ${accepted} for ${input.repoSlug}.`
-  });
-}
-async function ensureRemoteProjectRootLink(projectRoot, options = {}) {
-  let selected;
-  try {
-    selected = resolveSelectedConnection(projectRoot);
-  } catch (error) {
-    return remoteProjectLinkFailure({ status: "error", message: error instanceof Error ? error.message : String(error) });
-  }
-  if (!selected || selected.connection.kind !== "remote") {
-    return remoteProjectLinkFailure({ status: "not_remote", message: "No remote Rig server is selected for this repo." });
-  }
-  const repo = readRepoConnection(projectRoot);
-  const explicitRepoRequested = options.repoSlug !== undefined;
-  const explicitRepoSlug = explicitRepoRequested ? normalizeRepoSlug(options.repoSlug) : null;
-  const repoProjectSlug = normalizeRepoSlug(repo?.project);
-  const repoSlug = explicitRepoSlug ?? repoProjectSlug ?? readProjectLinkSlug(projectRoot);
-  const alias = selected.alias;
-  const baseUrl = selected.connection.baseUrl;
-  const authToken = options.authToken === undefined ? readGitHubBearerTokenForRemote(projectRoot) : options.authToken;
-  const mode = options.mode ?? "backfill-only";
-  if (explicitRepoRequested && !explicitRepoSlug) {
-    return remoteProjectLinkFailure({
-      status: "missing_project",
-      alias,
-      baseUrl,
-      message: `Invalid --repo value ${JSON.stringify(options.repoSlug)}. Expected owner/repo.`
-    });
-  }
-  if (!repoSlug) {
-    return remoteProjectLinkFailure({
-      status: "missing_project",
-      alias,
-      baseUrl,
-      message: `Remote server ${alias} is selected, but this checkout has no GitHub repo slug recorded.`
-    });
-  }
-  const skippedCandidates = [];
-  const storedRoot = selected.serverProjectRoot?.trim() || null;
-  const storedRootMatchesResolvedRepo = repoProjectSlug === repoSlug;
-  if (storedRoot && storedRootMatchesResolvedRepo) {
-    if (localCheckoutPathCandidate(projectRoot, storedRoot)) {
-      clearRepoServerProjectRoot(projectRoot);
-      skippedCandidates.push(storedRoot);
-    } else {
-      const storedResult = await validateAndPersistRemoteRoot({
-        projectRoot,
-        alias,
-        baseUrl,
-        authToken,
-        repoSlug,
-        candidate: storedRoot,
-        source: "stored",
-        status: "ready"
-      });
-      if (storedResult.ok || storedResult.status === "auth_required" || storedResult.status === "error")
-        return storedResult;
-      clearRepoServerProjectRoot(projectRoot);
-      skippedCandidates.push(storedRoot);
-    }
-  } else if (storedRoot) {
-    skippedCandidates.push(storedRoot);
-  }
-  const authCandidate = inferRemoteServerProjectRootCandidateFromAuthState(projectRoot, repoSlug);
-  if (authCandidate) {
-    const authResult = await validateAndPersistRemoteRoot({ projectRoot, alias, baseUrl, authToken, repoSlug, candidate: authCandidate, source: "auth-state" });
-    if (authResult.ok || authResult.status === "auth_required")
-      return authResult;
-  }
-  let registryResponse;
-  try {
-    registryResponse = await requestRemoteProjectLinkJson(baseUrl, `/api/projects/${encodeURIComponent(repoSlug)}`, authToken);
-  } catch (error) {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias,
-      baseUrl,
-      repoSlug,
-      message: `Could not read remote project registry for ${repoSlug} on ${alias}: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-  if (registryResponse.status === 401 || registryResponse.status === 403) {
-    return remoteProjectLinkFailure({
-      status: "auth_required",
-      alias,
-      baseUrl,
-      repoSlug,
-      statusCode: registryResponse.status,
-      message: `Remote server ${alias} requires authentication before reading the ${repoSlug} project registry.`
-    });
-  }
-  if (registryResponse.ok) {
-    const candidates = checkoutPathsFromProjectPayload(registryResponse.payload);
-    for (const candidate of candidates) {
-      const result = await validateAndPersistRemoteRoot({ projectRoot, alias, baseUrl, authToken, repoSlug, candidate, source: "registry" });
-      if (result.ok || result.status === "auth_required")
-        return result;
-      skippedCandidates.push(candidate);
-    }
-    if (mode === "backfill-only") {
-      return remoteProjectLinkFailure({
-        status: candidates.length > 0 ? "invalid_root" : "no_server_checkout",
-        alias,
-        baseUrl,
-        repoSlug,
-        message: candidates.length > 0 ? `Remote registry has checkout candidates for ${repoSlug}, but none validated for ${alias}.` : `Remote registry has ${repoSlug}, but no server checkout path is linked yet.`,
-        skippedCandidates
-      });
-    }
-  } else if (registryResponse.status === 404) {
-    if (mode === "backfill-only") {
-      return remoteProjectLinkFailure({
-        status: "project_not_registered",
-        alias,
-        baseUrl,
-        repoSlug,
-        statusCode: registryResponse.status,
-        message: `Remote server ${alias} has no registered project record for ${repoSlug}.`
-      });
-    }
-  } else {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias,
-      baseUrl,
-      repoSlug,
-      statusCode: registryResponse.status,
-      message: `Could not backfill ${repoSlug} from remote registry (${registryResponse.status}): ${payloadError(registryResponse.payload, registryResponse.text || "registry lookup failed")}`,
-      skippedCandidates
-    });
-  }
-  let prepareResponse;
-  try {
-    prepareResponse = await requestRemoteProjectLinkJson(baseUrl, `/api/projects/${encodeURIComponent(repoSlug)}/prepare-checkout`, authToken, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ checkout: { kind: "managed-clone" }, repoUrl: `https://github.com/${repoSlug}.git` })
-    });
-  } catch (error) {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias,
-      baseUrl,
-      repoSlug,
-      message: `Could not prepare remote checkout for ${repoSlug} on ${alias}: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-  if (prepareResponse.status === 401 || prepareResponse.status === 403) {
-    return remoteProjectLinkFailure({
-      status: "auth_required",
-      alias,
-      baseUrl,
-      repoSlug,
-      statusCode: prepareResponse.status,
-      message: `Remote server ${alias} requires authentication before preparing ${repoSlug}.`
-    });
-  }
-  if (!prepareResponse.ok) {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias,
-      baseUrl,
-      repoSlug,
-      statusCode: prepareResponse.status,
-      message: `Remote checkout prepare failed for ${repoSlug} (${prepareResponse.status}): ${payloadError(prepareResponse.payload, prepareResponse.text || "prepare-checkout failed")}`,
-      skippedCandidates
-    });
-  }
-  const preparedPath = checkoutPathFromPreparePayload(prepareResponse.payload);
-  if (!preparedPath) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias,
-      baseUrl,
-      repoSlug,
-      message: `Remote checkout prepare for ${repoSlug} did not return a checkout.path.`,
-      skippedCandidates
-    });
-  }
-  return validateAndPersistRemoteRoot({ projectRoot, alias, baseUrl, authToken, repoSlug, candidate: preparedPath, source: "prepare", prepared: true });
-}
-async function ensureServerForCli(projectRoot) {
-  try {
-    const selected = resolveSelectedConnection(projectRoot);
-    if (selected?.connection.kind === "remote") {
-      reportServerPhase(`Connecting to ${selected.alias}\u2026`);
-      const authToken = readGitHubBearerTokenForRemote(projectRoot);
-      const link = await ensureRemoteProjectRootLink(projectRoot, { mode: "backfill-only", authToken });
-      return {
-        baseUrl: selected.connection.baseUrl,
-        authToken,
-        connectionKind: "remote",
-        serverProjectRoot: link.ok ? link.serverProjectRoot ?? null : null
-      };
-    }
-    reportServerPhase("Starting local Rig server\u2026");
-    const connection = await ensureLocalRigServerConnection(projectRoot);
-    return {
-      baseUrl: connection.baseUrl,
-      authToken: connection.authToken ?? readLocalConnectionFallbackToken(projectRoot),
-      connectionKind: "local",
-      serverProjectRoot: resolve2(projectRoot)
-    };
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new CliError(error.message, 1);
-    }
-    throw error;
-  }
-}
-function mergeCookie(existing, name, value) {
-  const encoded = `${name}=${encodeURIComponent(value)}`;
-  if (!existing?.trim())
-    return encoded;
-  const parts = existing.split(";").map((part) => part.trim()).filter((part) => part && !part.startsWith(`${name}=`));
-  return [...parts, encoded].join("; ");
-}
-function queryAuthFallbackEnabled(env = process.env) {
-  return env.RIG_ENABLE_QUERY_AUTH_FALLBACK === "1" || env.RIG_QUERY_AUTH_FALLBACK === "1";
-}
-function mergeHeaders(headers, authToken) {
-  const merged = new Headers(headers);
-  if (authToken) {
-    const bearer = `Bearer ${authToken}`;
-    merged.set("authorization", bearer);
-    merged.set("x-auth", bearer);
-    merged.set("cookie", mergeCookie(merged.get("cookie"), "rig_auth", authToken));
-  }
-  return merged;
-}
-var serverReachabilityCache = new Map;
-var RESUMABLE_RUN_STATUSES = new Set([
-  "created",
-  "preparing",
-  "running",
-  "validating",
-  "reviewing",
-  "stopped",
-  "failed",
-  "needs-attention",
-  "needs_attention"
-]);
-
-// packages/cli/src/commands/_server-events.ts
-function buildRigWebSocketUrl(baseUrl, authToken) {
-  const url = new URL(baseUrl);
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  if (authToken)
-    url.searchParams.set("token", authToken);
-  return url.toString();
-}
-async function connectRigServerEvents(projectRoot, handlers) {
-  const { baseUrl, authToken } = await ensureServerForCli(projectRoot);
-  const transport = new WsTransport(buildRigWebSocketUrl(baseUrl, authToken));
-  const unsubscribers = [];
-  if (handlers.onSnapshotInvalidated)
-    unsubscribers.push(transport.subscribe(RIG_WS_CHANNELS.snapshotInvalidated, handlers.onSnapshotInvalidated));
-  if (handlers.onRunLogAppended)
-    unsubscribers.push(transport.subscribe(RIG_WS_CHANNELS.runLogAppended, handlers.onRunLogAppended));
-  if (handlers.onEngineEvent)
-    unsubscribers.push(transport.subscribe(RIG_WS_CHANNELS.event, handlers.onEngineEvent));
-  let status = "connecting";
-  unsubscribers.push(transport.subscribeState((state) => {
-    status = state.status;
-    handlers.onStatus?.(state.status);
-  }));
-  return {
-    connected: () => status === "connected",
-    close: () => {
-      for (const unsubscribe of unsubscribers) {
-        try {
-          unsubscribe();
-        } catch {}
-      }
-      transport.dispose();
-    }
-  };
-}
-
-// packages/cli/src/app-opentui/theme.ts
-import {
-  bold as otuiBold,
-  dim as otuiDim,
-  fg as otuiFg,
-  t,
-  TextAttributes
-} from "@opentui/core";
-var RIG_UI = {
-  bg: "#070809",
-  bg2: "#0b0c0e",
-  panel: "#101115",
-  panel2: "#14161b",
-  hover: "#181b24",
-  glass: "#1e2230",
-  border: "#2a2e3a",
-  ink: "#f4f5f8",
-  ink2: "#c7c9d3",
-  ink3: "#9aa0ae",
-  ink4: "#787b86",
-  lime: "#ccff4d",
-  limeDim: "#a9d63f",
-  cyan: "#56d8ff",
-  cyanDim: "#3f9fbd",
-  red: "#ff5d5d",
-  yellow: "#ffd24d",
-  magenta: "#ff79b0"
-};
-var styles = {
-  ink: otuiFg(RIG_UI.ink),
-  ink2: otuiFg(RIG_UI.ink2),
-  ink3: otuiFg(RIG_UI.ink3),
-  ink4: otuiFg(RIG_UI.ink4),
-  lime: otuiFg(RIG_UI.lime),
-  limeDim: otuiFg(RIG_UI.limeDim),
-  cyan: otuiFg(RIG_UI.cyan),
-  red: otuiFg(RIG_UI.red),
-  yellow: otuiFg(RIG_UI.yellow),
-  magenta: otuiFg(RIG_UI.magenta)
-};
-
-// packages/cli/src/app-opentui/drone.ts
-import { RGBA, StyledText, TextAttributes as TextAttributes2 } from "@opentui/core";
-var MINI_DRONE = [
-  "(!!!)   (!!!)",
-  "  \\%==%/  ",
-  "   %%?%%   ",
-  "  /%==%\\  ",
-  "(!!!)   (!!!)"
-];
-var LEAD_MARK = [
-  " .-=-. ",
-  "=%%?%%=",
-  " '-=-' "
-];
-var BLADE_FRAMES = ["---", "\\\\\\", "|||", "///"];
-var EYE_FRAMES = ["o", "@", "\u2022", "."];
-var COLOR = {
-  body: RGBA.fromHex(RIG_UI.lime),
-  mini: RGBA.fromHex(RIG_UI.limeDim),
-  rotor: RGBA.fromHex(RIG_UI.cyan),
-  path: RGBA.fromHex(RIG_UI.cyan),
-  eye: RGBA.fromHex(RIG_UI.ink),
-  dim: RGBA.fromHex(RIG_UI.ink4),
-  ink: RGBA.fromHex(RIG_UI.ink2)
-};
-function bladeForTick(tick, phase = 0) {
-  return BLADE_FRAMES[(Math.floor(tick / 3) + phase) % BLADE_FRAMES.length];
-}
-function eyeForTick(tick, phase = 0) {
-  const pulse = Math.sin(tick * 0.09 + phase);
-  return pulse > 0.55 ? EYE_FRAMES[1] : pulse > 0.1 ? EYE_FRAMES[0] : pulse > -0.45 ? EYE_FRAMES[2] : EYE_FRAMES[3];
-}
-function chunk(text, fg, bold = false, dim = false) {
-  let attributes = TextAttributes2.NONE;
-  if (bold)
-    attributes |= TextAttributes2.BOLD;
-  if (dim)
-    attributes |= TextAttributes2.DIM;
-  return { __isChunk: true, text, fg, ...attributes !== TextAttributes2.NONE ? { attributes } : {} };
-}
-function styledLine(text, colorFor) {
-  const chunks = [];
-  let run = "";
-  let runColor = null;
-  const flush = () => {
-    if (!run || !runColor)
-      return;
-    chunks.push(chunk(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 : [chunk("", 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((line) => line.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((line, index) => ({
-    ...line,
-    fg: index % 2 === 0 ? RIG_UI.red : line.fg
-  }));
-}
-
-// packages/cli/src/app-opentui/render/scene.ts
-function line(text, options = {}) {
-  return { text, ...options };
-}
-function blank() {
-  return { text: "" };
-}
-function deckRow(input) {
-  const prefix = input.active ? "\u25B8" : " ";
-  const label = input.label.toUpperCase().padEnd(10);
-  return line(`${prefix} ${label} ${input.detail}`, {
-    fg: input.active ? RIG_UI.lime : RIG_UI.ink2,
-    bold: input.active,
-    selectableIndex: input.index,
-    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 {
-    ...input,
-    text: alignText(fitted, layout.centerWidth, input.align ?? "left")
-  };
-}
-function fitSceneLines(lines, layout) {
-  return lines.slice(0, layout.centerHeight).map((entry) => fitSceneLine(entry, layout));
-}
-function makeSceneFrame(input) {
-  return input;
-}
-
-// 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_DRONE2 = [
-  "(!!!)   (!!!)",
-  "  \\%==%/  ",
-  "   %%?%%   ",
-  "  /%==%\\  ",
-  "(!!!)   (!!!)"
-];
-var ROTORS = ["---", "\\\\\\", "|||", "///"];
-var FLEET_GRID_WIDTH = 52;
-var FLEET_GRID_HEIGHT = 27;
-var FLEET = [
-  { art: MINI_DRONE2, x: 0, y: 2, amp: 1, speed: 0.05, phase: 0, dx: 1, driftSpeed: 0.02 },
-  { art: MINI_DRONE2, x: 39, y: 2, amp: 1, speed: 0.044, phase: 2.1, dx: 1, driftSpeed: 0.017 },
-  { art: MINI_DRONE2, x: 1, y: 20, amp: 1, speed: 0.048, phase: 4.2, dx: 1, driftSpeed: 0.023 },
-  { art: MINI_DRONE2, 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 };
-}
-
-// packages/cli/src/app-opentui/render/constants.ts
-var LCG_MULTIPLIER = 1664525;
-var LCG_INCREMENT = 1013904223;
-var LCG_DIVISOR = 4294967295;
-var PACKET_CYAN_PROBABILITY = 0.22;
-var LANE_INTERP_STEPS = 32;
-var LANE_LEN_BASE = 0.32;
-var LANE_LEN_SPREAD = 0.42;
-var LANE_CURVE_RANGE = 0.7;
-var PACKET_SPEED_BASE = 0.003;
-var PACKET_SPEED_SPREAD = 0.009;
-var DISPATCH_LANES_COMPACT = 7;
-var DISPATCH_LANES_WIDE = 12;
-var DISPATCH_PACKETS_COMPACT = 70;
-var DISPATCH_PACKETS_WIDE = 150;
-var CARRIER_NODES_COMPACT = 5;
-var CARRIER_NODES_WIDE = 7;
-var LOOP_GATES_COMPACT = 4;
-var LOOP_GATES_WIDE = 5;
-var DISPATCH_DRONES_COMPACT = 4;
-var DISPATCH_DRONES_WIDE = 8;
-var CORE_DISPATCH_X = 0.3;
-var CORE_DISPATCH_Y = 0.45;
-var CORE_CARRIER_X = 0.5;
-var CORE_CARRIER_Y = 0.54;
-var CORE_LOOP_X = 0.09;
-var CORE_LOOP_Y = 0.56;
-var RAIL_YS_LOOP = [0.18, 0.5, 0.82];
-var RAIL_YS_CARRIER = [0.24, 0.54, 0.82];
-var RAIL_YS_DISPATCH = [0.18, 0.58, 0.82];
-var GLOW_FALLOFF_EXP_ASCII = 2.2;
-
-// packages/cli/src/app-opentui/render/graphics.ts
-var BRAILLE_SAMPLES_X = 2;
-var BRAILLE_SAMPLES_Y = 4;
-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];
-var INK_RGB = [108, 110, 121];
-var BRAILLE_BITS = [
-  [1, 8],
-  [2, 16],
-  [4, 32],
-  [64, 128]
-];
-function sceneKind(scene) {
-  if (scene === "tasks")
-    return "loop";
-  if (scene === "help")
-    return "carrier";
-  return "dispatch";
-}
-function seeded(seed) {
-  let value = seed >>> 0;
-  return () => {
-    value = value * LCG_MULTIPLIER + LCG_INCREMENT >>> 0;
-    return value / LCG_DIVISOR;
-  };
-}
-function channelBuffer(canvas, channel) {
-  switch (channel) {
-    case 0:
-      return canvas.ac;
-    case 1:
-      return canvas.c2;
-    case 2:
-      return canvas.mg;
-    case 3:
-      return canvas.ink;
-  }
-}
-function addSample(canvas, channel, x, y, value) {
-  const ix = Math.trunc(x);
-  const iy = Math.trunc(y);
-  if (ix < 0 || iy < 0 || ix >= canvas.width || iy >= canvas.height)
-    return;
-  const buffer = channelBuffer(canvas, channel);
-  const index = iy * canvas.width + ix;
-  buffer[index] = Math.min(1, buffer[index] + value);
-}
-function drawDot(canvas, channel, cx, cy, radius, value) {
-  const minX = Math.floor(cx - radius);
-  const maxX = Math.ceil(cx + radius);
-  const minY = Math.floor(cy - radius);
-  const maxY = Math.ceil(cy + radius);
-  for (let y = minY;y <= maxY; y += 1) {
-    for (let x = minX;x <= maxX; x += 1) {
-      const dx = x - cx;
-      const dy = y - cy;
-      const distance = Math.sqrt(dx * dx + dy * dy);
-      if (distance > radius)
-        continue;
-      const falloff = 1 - distance / Math.max(0.001, radius);
-      addSample(canvas, channel, x, y, value * (0.28 + falloff * 0.72));
-    }
-  }
-}
-function drawGlow(canvas, channel, cx, cy, radius, value) {
-  const minX = Math.floor(cx - radius);
-  const maxX = Math.ceil(cx + radius);
-  const minY = Math.floor(cy - radius);
-  const maxY = Math.ceil(cy + radius);
-  for (let y = minY;y <= maxY; y += 1) {
-    for (let x = minX;x <= maxX; x += 1) {
-      const dx = x - cx;
-      const dy = y - cy;
-      const distance = Math.sqrt(dx * dx + dy * dy);
-      if (distance > radius)
-        continue;
-      const falloff = Math.pow(1 - distance / Math.max(0.001, radius), GLOW_FALLOFF_EXP_ASCII);
-      addSample(canvas, channel, x, y, value * falloff);
-    }
-  }
-}
-function drawLine(canvas, channel, x0, y0, x1, y1, value, width = 0.8) {
-  const dx = x1 - x0;
-  const dy = y1 - y0;
-  const steps = Math.max(1, Math.ceil(Math.hypot(dx, dy) * 1.7));
-  for (let step = 0;step <= steps; step += 1) {
-    const t2 = step / steps;
-    const x = x0 + dx * t2;
-    const y = y0 + dy * t2;
-    drawDot(canvas, channel, x, y, width, value);
-  }
-}
-function drawCircleStroke(canvas, channel, cx, cy, radius, value) {
-  const steps = Math.max(18, Math.ceil(radius * 8));
-  for (let step = 0;step < steps; step += 1) {
-    const a = step / steps * Math.PI * 2;
-    drawDot(canvas, channel, cx + Math.cos(a) * radius, cy + Math.sin(a) * radius, 0.72, value);
-  }
-}
-function paletteColor(ac, c2, mg, ink) {
-  const total = Math.max(0.001, ac + c2 + mg + ink);
-  const r = (AC_RGB[0] * ac + C2_RGB[0] * c2 + MG_RGB[0] * mg + INK_RGB[0] * ink) / total;
-  const g = (AC_RGB[1] * ac + C2_RGB[1] * c2 + MG_RGB[1] * mg + INK_RGB[1] * ink) / total;
-  const b = (AC_RGB[2] * ac + C2_RGB[2] * c2 + MG_RGB[2] * mg + INK_RGB[2] * ink) / total;
-  const intensity = Math.min(1, total / 4);
-  const lift = 0.34 + intensity * 0.66;
-  return RGBA2.fromInts(Math.round(r * lift), Math.round(g * lift), Math.round(b * lift), 255);
-}
-function clearCanvas(canvas) {
-  canvas.ac.fill(0);
-  canvas.c2.fill(0);
-  canvas.mg.fill(0);
-  canvas.ink.fill(0);
-}
-function makeCanvas(layout) {
-  const width = Math.max(1, layout.width * BRAILLE_SAMPLES_X);
-  const height = Math.max(1, layout.height * BRAILLE_SAMPLES_Y);
-  const size = width * height;
-  return {
-    width,
-    height,
-    ac: new Float32Array(size),
-    c2: new Float32Array(size),
-    mg: new Float32Array(size),
-    ink: new Float32Array(size)
-  };
-}
-
-class MarketingGlyphCanvas {
-  rand = seeded(6221137);
-  canvas;
-  layout;
-  activeKind = null;
-  lanes = [];
-  motes = [];
-  packets = [];
-  constructor(layout) {
-    this.layout = layout;
-    this.canvas = makeCanvas(layout);
-    this.reset("dispatch");
-  }
-  resize(layout) {
-    if (layout.width === this.layout.width && layout.height === this.layout.height)
-      return;
-    this.layout = layout;
-    this.canvas = makeCanvas(layout);
-    this.reset(this.activeKind ?? "dispatch");
-  }
-  render(layer, scene, tick) {
-    const kind = sceneKind(scene);
-    if (kind !== this.activeKind)
-      this.reset(kind);
-    clearCanvas(this.canvas);
-    this.drawMarketingRails(kind, tick);
-    if (kind === "loop")
-      this.drawLoop(tick);
-    else if (kind === "carrier")
-      this.drawCarrier(tick);
-    else
-      this.drawDispatch(tick);
-    this.blit(layer);
-  }
-  reset(kind) {
-    this.activeKind = kind;
-    this.lanes = [];
-    this.motes = [];
-    this.packets = [];
-    if (kind === "dispatch")
-      this.setupDispatch();
-    else if (kind === "loop")
-      this.setupLoop();
-    else
-      this.setupCarrier();
-  }
-  setupDispatch() {
-    const count = this.layout.compact ? DISPATCH_LANES_COMPACT : DISPATCH_LANES_WIDE;
-    for (let i = 0;i < count; i += 1) {
-      const ang = (-0.9 + 1.8 * (i / Math.max(1, count - 1))) * (Math.PI * 0.5);
-      this.lanes.push({ ang, len: this.canvas.width * (LANE_LEN_BASE + this.rand() * LANE_LEN_SPREAD), curve: (this.rand() - 0.5) * LANE_CURVE_RANGE, phase: this.rand() * Math.PI * 2 });
-    }
-    const packets = this.layout.compact ? DISPATCH_PACKETS_COMPACT : DISPATCH_PACKETS_WIDE;
-    for (let i = 0;i < packets; i += 1)
-      this.packets.push(this.packet(true));
-  }
-  setupLoop() {
-    const lanes = this.layout.compact ? 4 : 7;
-    for (let i = 0;i < lanes; i += 1)
-      this.packets.push(this.packet(true));
-  }
-  setupCarrier() {
-    const nodes = this.layout.compact ? CARRIER_NODES_COMPACT : CARRIER_NODES_WIDE;
-    for (let i = 0;i < nodes * 6; i += 1)
-      this.packets.push(this.packet(true));
-  }
-  packet(random = false) {
-    return {
-      lane: Math.floor(this.rand() * Math.max(1, this.lanes.length || 7)),
-      p: random ? this.rand() : 0,
-      spd: PACKET_SPEED_BASE + this.rand() * PACKET_SPEED_SPREAD,
-      channel: this.rand() < PACKET_CYAN_PROBABILITY ? 1 : 0,
-      wobble: (this.rand() - 0.5) * 7,
-      size: 0.8 + this.rand() * 1.3
-    };
-  }
-  core(kind) {
-    if (kind === "dispatch")
-      return { x: this.canvas.width * CORE_DISPATCH_X, y: this.canvas.height * CORE_DISPATCH_Y };
-    if (kind === "carrier")
-      return { x: this.canvas.width * CORE_CARRIER_X, y: this.canvas.height * CORE_CARRIER_Y };
-    return { x: this.canvas.width * CORE_LOOP_X, y: this.canvas.height * CORE_LOOP_Y };
-  }
-  lanePoint(lane, p, kind = "dispatch") {
-    const core = this.core(kind);
-    const dist = lane.len * p;
-    const bend = Math.sin(p * Math.PI) * lane.curve * 28;
-    const ux = Math.cos(lane.ang);
-    const uy = Math.sin(lane.ang);
-    return { x: core.x + ux * dist + -uy * bend, y: core.y + uy * dist + ux * bend };
-  }
-  drawMotes(tick) {
-    for (const mote of this.motes) {
-      mote.x += 0.1 * mote.z;
-      if (mote.x > this.canvas.width + 2)
-        mote.x = -2;
-      const alpha = (0.035 + 0.08 * mote.z) * (0.55 + 0.45 * Math.sin(tick * 0.03 + mote.tw));
-      drawDot(this.canvas, mote.channel, mote.x, mote.y, 0.45 * mote.z, alpha);
-    }
-  }
-  drawMarketingRails(kind, tick) {
-    const ys = kind === "loop" ? RAIL_YS_LOOP : kind === "carrier" ? RAIL_YS_CARRIER : RAIL_YS_DISPATCH;
-    ys.forEach((ratio, index) => {
-      const y = this.canvas.height * ratio + Math.sin(tick * 0.018 + index) * 1.8;
-      drawLine(this.canvas, index === 1 ? 0 : 1, this.canvas.width * 0.06, y, this.canvas.width * 0.94, y + Math.sin(index) * 2, index === 1 ? 0.11 : 0.07, 0.55);
-      for (let p = (tick * 0.004 + index * 0.21) % 1;p < 1; p += 0.18 + index * 0.02) {
-        const x = this.canvas.width * (0.06 + 0.88 * p);
-        drawDot(this.canvas, index === 2 ? 1 : 0, x, y, 1 + index * 0.25, 0.24);
-        drawGlow(this.canvas, index === 2 ? 1 : 0, x, y, 3.8, 0.035);
-      }
-    });
-  }
-  drawDispatch(tick) {
-    const core = this.core("dispatch");
-    drawGlow(this.canvas, 0, core.x, core.y, 30, 0.12);
-    drawDot(this.canvas, 0, core.x, core.y, 2.2, 0.85);
-    for (const lane of this.lanes) {
-      let prev = this.lanePoint(lane, 0);
-      for (let i = 1;i <= LANE_INTERP_STEPS; i += 1) {
-        const next = this.lanePoint(lane, i / LANE_INTERP_STEPS);
-        drawLine(this.canvas, lane.phase > Math.PI ? 1 : 0, prev.x, prev.y, next.x, next.y, 0.045, 0.38);
-        prev = next;
-      }
-    }
-    for (const packet of this.packets) {
-      packet.p += packet.spd;
-      if (packet.p > 1)
-        Object.assign(packet, this.packet(false));
-      const lane = this.lanes[packet.lane % Math.max(1, this.lanes.length)];
-      if (!lane)
-        continue;
-      const pt = this.lanePoint(lane, packet.p);
-      const fade = packet.p < 0.1 ? packet.p / 0.1 : packet.p > 0.88 ? (1 - packet.p) / 0.12 : 1;
-      const y = pt.y + packet.wobble * Math.sin(packet.p * Math.PI * 2);
-      drawLine(this.canvas, packet.channel, pt.x - 4, y - 1, pt.x, y, 0.08 * fade, 0.38);
-      drawDot(this.canvas, packet.channel, pt.x, y, packet.size, 0.5 * fade);
-      drawGlow(this.canvas, packet.channel, pt.x, y, packet.size * 4, 0.045 * fade);
-    }
-    for (let i = 0;i < (this.layout.compact ? DISPATCH_DRONES_COMPACT : DISPATCH_DRONES_WIDE); i += 1) {
-      const lane = this.lanes[i % Math.max(1, this.lanes.length)];
-      if (!lane)
-        continue;
-      const p = (tick * 0.002 + i * 0.13) % 1;
-      const pt = this.lanePoint(lane, p);
-      this.drawDrone(pt.x, pt.y + Math.sin(tick * 0.04 + i) * 2, 2.6 + i % 2 * 0.6, tick + i * 11, i % 3 === 0 ? 1 : 0);
-    }
-  }
-  drawLoop(tick) {
-    const y = this.canvas.height * 0.56;
-    const x0 = this.canvas.width * 0.09;
-    const x1 = this.canvas.width * 0.91;
-    drawLine(this.canvas, 0, x0, y, x1, y, 0.12, 0.55);
-    const gates = this.layout.compact ? LOOP_GATES_COMPACT : LOOP_GATES_WIDE;
-    const active = Math.floor(tick / 16) % gates;
-    for (let i = 0;i < gates; i += 1) {
-      const x = x0 + (x1 - x0) * (i / Math.max(1, gates - 1));
-      drawLine(this.canvas, i === active ? 0 : 3, x, y - 22, x, y + 22, i === active ? 0.25 : 0.08, i === active ? 0.7 : 0.42);
-      drawDot(this.canvas, i <= active ? 0 : 3, x, y, i === active ? 2.2 : 1.2, i === active ? 0.72 : 0.25);
-      drawCircleStroke(this.canvas, i <= active ? 0 : 3, x, y, i === active ? 4.2 : 2.4, i === active ? 0.18 : 0.08);
-    }
-    for (const packet of this.packets) {
-      packet.p += packet.spd * 0.7;
-      if (packet.p > 1)
-        packet.p = 0;
-      const x = x0 + (x1 - x0) * packet.p;
-      const segment = Math.min(gates - 1, Math.floor(packet.p * gates));
-      const channel = segment < active ? 0 : segment === active ? 1 : 3;
-      const py = y + packet.wobble * Math.sin(packet.p * Math.PI * 2);
-      drawLine(this.canvas, channel, x - 6, py, x, py, 0.1, 0.42);
-      drawDot(this.canvas, channel, x, py, packet.size, channel === 3 ? 0.22 : 0.58);
-      drawGlow(this.canvas, channel, x, py, 3.8, channel === 3 ? 0.02 : 0.04);
-    }
-    this.drawDrone(x0 + (x1 - x0) * (tick * 0.003 % 1), y - 18, 2.7, tick, 0);
-    this.drawDrone(x0 + (x1 - x0) * ((tick * 0.002 + 0.5) % 1), y + 16, 2.2, tick + 40, 2);
-  }
-  drawCarrier(tick) {
-    const core = this.core("carrier");
-    drawGlow(this.canvas, 0, core.x, core.y, 26, 0.12);
-    drawDot(this.canvas, 0, core.x, core.y, 2.4, 0.92);
-    drawCircleStroke(this.canvas, 0, core.x, core.y, 8 + Math.sin(tick * 0.06) * 2, 0.14);
-    const nodes = this.layout.compact ? CARRIER_NODES_COMPACT : CARRIER_NODES_WIDE;
-    const rx = this.canvas.width * 0.36;
-    const ry = this.canvas.height * 0.22;
-    for (let i = 0;i < nodes; i += 1) {
-      const a = i / nodes * Math.PI * 2 - Math.PI / 2 + tick * 0.006;
-      const x = core.x + Math.cos(a) * rx;
-      const y = core.y + Math.sin(a) * ry;
-      drawLine(this.canvas, i % 2 ? 1 : 0, core.x, core.y, x, y, 0.055, 0.36);
-      drawCircleStroke(this.canvas, i % 2 ? 1 : 0, x, y, 4.2, 0.15);
-      drawDot(this.canvas, i % 2 ? 1 : 0, x, y, 1.7, 0.62);
-      this.drawDrone(x, y - 8, 2.1, tick + i * 9, i % 2 ? 1 : 0);
-    }
-    for (const packet of this.packets) {
-      packet.p += packet.spd;
-      if (packet.p > 1)
-        packet.p = 0;
-      const lane = packet.lane % nodes;
-      const a = lane / nodes * Math.PI * 2 - Math.PI / 2 + tick * 0.006;
-      const nx = core.x + Math.cos(a) * rx;
-      const ny = core.y + Math.sin(a) * ry;
-      const x = core.x + (nx - core.x) * packet.p;
-      const y = core.y + (ny - core.y) * packet.p;
-      drawDot(this.canvas, packet.channel, x, y, packet.size, 0.48);
-      drawGlow(this.canvas, packet.channel, x, y, 3.2, 0.035);
-    }
-  }
-  drawDrone(x, y, scale, tick, channel) {
-    const wobble = Math.sin(tick * 0.08) * 0.7;
-    drawDot(this.canvas, channel, x, y + wobble, scale, 0.58);
-    drawDot(this.canvas, 3, x, y + wobble, Math.max(0.6, scale * 0.28), 0.42);
-    const rotor = scale * 1.75;
-    const arms = [
-      [-rotor, -rotor * 0.75],
-      [rotor, -rotor * 0.75],
-      [-rotor, rotor * 0.75],
-      [rotor, rotor * 0.75]
-    ];
-    for (const [dx, dy] of arms) {
-      drawLine(this.canvas, channel, x, y + wobble, x + dx, y + dy + wobble, 0.11, 0.38);
-      drawCircleStroke(this.canvas, channel, x + dx, y + dy + wobble, scale * (0.65 + Math.abs(Math.sin(tick * 0.18)) * 0.25), 0.16);
-      drawDot(this.canvas, channel, x + dx, y + dy + wobble, 0.7, 0.25);
-    }
-    drawLine(this.canvas, channel === 1 ? 0 : 1, x - rotor * 2.4, y + wobble + 1.2, x - rotor * 1.2, y + wobble, 0.05, 0.35);
-  }
-  blit(layer) {
-    const fb = layer.frameBuffer;
-    fb.clear(BACKDROP);
-    const { width, height, ac, c2, mg, ink } = this.canvas;
-    for (let cy = 0;cy < this.layout.height; cy += 1) {
-      for (let cx = 0;cx < this.layout.width; cx += 1) {
-        let bits = 0;
-        let acSum = 0;
-        let c2Sum = 0;
-        let mgSum = 0;
-        let inkSum = 0;
-        for (let sy = 0;sy < BRAILLE_SAMPLES_Y; sy += 1) {
-          for (let sx = 0;sx < BRAILLE_SAMPLES_X; sx += 1) {
-            const px = cx * BRAILLE_SAMPLES_X + sx;
-            const py = cy * BRAILLE_SAMPLES_Y + sy;
-            if (px >= width || py >= height)
-              continue;
-            const index = py * width + px;
-            const a = ac[index];
-            const c = c2[index];
-            const m = mg[index];
-            const k = ink[index];
-            const total2 = a + c + m + k;
-            acSum += a;
-            c2Sum += c;
-            mgSum += m;
-            inkSum += k;
-            if (total2 > 0.11)
-              bits |= BRAILLE_BITS[sy][sx];
-          }
-        }
-        const total = acSum + c2Sum + mgSum + inkSum;
-        if (bits === 0 || total <= 0.02)
-          continue;
-        const char = String.fromCharCode(10240 + bits);
-        fb.setCellWithAlphaBlending(cx, cy, char, paletteColor(acSum, c2Sum, mgSum, inkSum), TRANSPARENT);
-      }
-    }
-  }
-}
-function createGraphicsLayer(renderer, layout) {
-  const layer = new FrameBufferRenderable(renderer, {
-    id: "rig-marketing-glyph-canvas",
-    width: layout.width,
-    height: layout.height,
-    position: "absolute",
-    left: 0,
-    top: 0,
-    respectAlpha: true
-  });
-  layer.__rigMarketingCanvas = new MarketingGlyphCanvas(layout);
-  return layer;
-}
-function resizeGraphicsLayer(layer, layout) {
-  if (layer.width !== layout.width)
-    layer.width = layout.width;
-  if (layer.height !== layout.height)
-    layer.height = layout.height;
-  layer.__rigMarketingCanvas?.resize(layout);
-}
-function clearGraphicsLayer(layer) {
-  layer.frameBuffer.clear(BACKDROP);
-  layer.__rigAmbientKey = undefined;
-}
-function writeCell(layer, x, y, char, fg, bg) {
-  layer.frameBuffer.setCellWithAlphaBlending(x, y, char, fg, bg);
-}
-function drawFullCell(layer, x, y, bg) {
-  writeCell(layer, x, y, " ", TRANSPARENT, bg);
-}
-function drawPanelFill(layer, left, top, right, bottom, dividerY) {
-  const bgForY = (y) => y < dividerY ? PANEL_HEADER_BG : PANEL_BG;
-  for (let y = top;y <= bottom; y += 1) {
-    const bg = bgForY(y);
-    for (let x = left;x <= right; x += 1)
-      drawFullCell(layer, x, y, bg);
-  }
-}
-function drawAdTerminalPanel(layer, layout, panel) {
-  const rect = panelCellRect(layout, panel);
-  if (!rect)
-    return;
-  const { left, top, width, right, bottom, headerHeight, dividerY } = rect;
-  drawPanelFill(layer, left, top, right, bottom, dividerY);
-  if (dividerY > top && dividerY < bottom) {
-    for (let x = left + 2;x < right - 1; x += 1) {
-      writeCell(layer, x, dividerY, "\u2500", PANEL_LINE_DIM, PANEL_BG);
-    }
-  }
-  if (panel.headerText) {
-    const x = left + Math.max(2, Math.min(5, panel.paddingX ?? 4));
-    const y = top + Math.max(1, Math.floor(headerHeight / 2));
-    layer.frameBuffer.drawText(panel.headerText.slice(0, Math.max(0, width - 8)), x, y, PANEL_TEXT_DIM, TRANSPARENT);
-  }
-}
-function drawPanelChrome(layer, layout, panels) {
-  for (const panel of panels) {
-    if (panel.chrome === "ad-terminal")
-      drawAdTerminalPanel(layer, layout, panel);
-  }
-}
-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 withAlpha(hex, alpha) {
-  const a = Math.max(0, Math.min(255, Math.round(alpha * 255)));
-  const [r, g, b] = RGBA2.fromHex(hex).toInts();
-  return RGBA2.fromInts(r, g, b, a);
-}
-function asciiFleetColor(char, row, alpha) {
-  if (char === "@" || char === "$" || char === "o")
-    return withAlpha(RIG_UI.lime, alpha);
-  if (char === "%" || char === "!" || char === "/" || char === "\\" || char === "|")
-    return withAlpha(RIG_UI.cyan, alpha);
-  if (char === "." || char === "'" || char === "_" || row < 3 || row > FLEET_GRID_HEIGHT - 4) {
-    return RGBA2.fromInts(108, 110, 121, Math.min(170, Math.max(0, Math.min(255, Math.round(alpha * 255)))));
-  }
-  return withAlpha(RIG_UI.limeDim, alpha);
-}
-var AMBIENT_LOAD_BUCKETS = 5;
-function ambientLoadBucket(load) {
-  if (!Number.isFinite(load))
-    return 0;
-  return Math.max(0, Math.min(AMBIENT_LOAD_BUCKETS, Math.round(load * AMBIENT_LOAD_BUCKETS)));
-}
-function drawAmbientField(layer, layout, _tick, scene = "fleet", load = 0, activeRuns = 0) {
-  const bucket = ambientLoadBucket(load);
-  const rows = fleetRows(staticFleetTick(scene), { animate: true });
-  let droneTotal = 0;
-  for (const line2 of rows)
-    for (const char of line2)
-      if (char === "@" || char === "$" || char === "%")
-        droneTotal += 1;
-  const litTarget = Math.max(0, Math.min(droneTotal, Math.floor(activeRuns)));
-  const key = `${layout.width}x${layout.height}|${scene}|l${bucket}|d${litTarget}`;
-  if (layer.__rigAmbientKey === key)
-    return;
-  const fb = layer.frameBuffer;
-  fb.clear(BACKDROP);
-  const left = Math.floor((layout.width - FLEET_GRID_WIDTH) / 2);
-  const top = Math.floor((layout.height - FLEET_GRID_HEIGHT) / 2);
-  const baseAlpha = 0.62 + bucket / AMBIENT_LOAD_BUCKETS * 0.18;
-  let droneIndex = 0;
-  for (let row = 0;row < rows.length; row += 1) {
-    const y = top + row;
-    if (y < 0 || y >= layout.height)
-      continue;
-    const line2 = rows[row];
-    for (let col = 0;col < line2.length; col += 1) {
-      const x = left + col;
-      if (x < 0 || x >= layout.width)
-        continue;
-      const char = line2[col];
-      if (char === " ")
-        continue;
-      const isDrone = char === "@" || char === "$" || char === "%";
-      const lit = isDrone && droneIndex < litTarget;
-      if (isDrone)
-        droneIndex += 1;
-      const alpha = lit ? 1 : baseAlpha;
-      fb.setCellWithAlphaBlending(x, y, char, asciiFleetColor(char, row, alpha), TRANSPARENT);
-    }
-  }
-  layer.__rigAmbientKey = key;
-}
-
-// packages/cli/src/app-opentui/fleet-stats.ts
-var ACTIVE_STATUSES = new Set([
-  "running",
-  "preparing",
-  "created",
-  "validating",
-  "reviewing",
-  "closing-out",
-  "stopping",
-  "loading"
-]);
-var SPARK_CHARS = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
-function normalizeStatus(status) {
-  return status.replace(/_/g, "-").toLowerCase();
-}
-function runsFromState(state) {
-  const fleet = state.data.fleet;
-  if (!fleet || typeof fleet !== "object" || Array.isArray(fleet))
-    return [];
-  const runs = fleet.runs;
-  return Array.isArray(runs) ? runs : [];
-}
-function computeFleetStats(runs) {
-  const byStatus = new Map;
-  let active = 0;
-  let succeeded = 0;
-  let failed = 0;
-  for (const run of runs) {
-    const status = normalizeStatus(run.status ?? "");
-    byStatus.set(status, (byStatus.get(status) ?? 0) + 1);
-    if (ACTIVE_STATUSES.has(status))
-      active += 1;
-    else if (status === "success" || status === "completed" || status === "merged")
-      succeeded += 1;
-    else if (status === "failed" || status === "error")
-      failed += 1;
-  }
-  const total = runs.length;
-  const load = total === 0 ? 0 : active / total;
-  const sparkline = buildSparklineSeries(active, succeeded, failed);
-  return { total, active, succeeded, failed, byStatus, load, sparkline };
-}
-function buildSparklineSeries(active, succeeded, failed) {
-  const peak = Math.max(1, active, succeeded, failed);
-  const base = [succeeded, Math.round(succeeded * 0.6 + failed * 0.4), failed, Math.round((active + failed) / 2), active];
-  return base.map((value) => Math.max(0, Math.min(peak, value)) / peak);
-}
-function fleetStatsFromState(state) {
-  return computeFleetStats(runsFromState(state));
-}
-function sparklineString(values, width) {
-  if (values.length === 0)
-    return "";
-  const series = width && width > 0 && values.length > width ? values.slice(values.length - width) : values;
-  return series.map((value) => {
-    const clamped = Math.max(0, Math.min(1, value));
-    const index = Math.min(SPARK_CHARS.length - 1, Math.round(clamped * (SPARK_CHARS.length - 1)));
-    return SPARK_CHARS[index];
-  }).join("");
-}
-
-// packages/cli/src/app-opentui/render/text.ts
-import { RGBA as RGBA3, TextAttributes as TextAttributes3, TextRenderable } from "@opentui/core";
-
-// packages/cli/src/app-opentui/render/hover.ts
-var hoveredId;
-var listeners = new Set;
-function getHoveredSelectableId() {
-  return hoveredId;
-}
-function isHovered(id) {
-  return id !== undefined && id === hoveredId;
-}
-function setHoveredSelectableId(id) {
-  if (hoveredId === id)
-    return;
-  hoveredId = id;
-  for (const listener of listeners)
-    listener();
-}
-function clearHoveredSelectableId(id) {
-  if (id !== undefined && hoveredId === id)
-    setHoveredSelectableId(undefined);
-}
-function subscribeHover(listener) {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-}
-
-// packages/cli/src/app-opentui/render/text.ts
-var TRANSPARENT2 = RGBA3.fromInts(0, 0, 0, 0);
-var HOVER_BG = RGBA3.fromHex(RIG_UI.hover);
-function lineIsClickable(line2) {
-  return line2?.selectable !== undefined || line2?.selectableIndex !== undefined;
-}
-function lineSelectableId(line2) {
-  return line2?.selectable?.id ?? line2?.selectableId;
-}
-function lineBackground(line2) {
-  if (line2?.bg)
-    return RGBA3.fromHex(line2.bg);
-  const id = lineSelectableId(line2);
-  if (id !== undefined && isHovered(id))
-    return HOVER_BG;
-  return TRANSPARENT2;
-}
-function selectableMouseHandler(currentLineRef, onLineMouseDown) {
-  return (event) => {
-    const currentLine = currentLineRef();
-    if (!lineIsClickable(currentLine))
-      return;
-    onLineMouseDown?.(currentLine, event);
-  };
-}
-function hoverHandlers(currentLineRef) {
-  return {
-    onMouseOver: () => {
-      const id = lineSelectableId(currentLineRef());
-      if (id !== undefined)
-        setHoveredSelectableId(id);
-    },
-    onMouseOut: () => clearHoveredSelectableId(lineSelectableId(currentLineRef()))
-  };
-}
-function createFlowTextLine(renderer, id, onLineMouseDown) {
-  let currentLine;
-  const renderable = new TextRenderable(renderer, {
-    id,
-    content: "",
-    width: "100%",
-    height: 1,
-    flexShrink: 0,
-    fg: RIG_UI.ink2,
-    selectable: true,
-    onMouseDown: selectableMouseHandler(() => currentLine, onLineMouseDown),
-    ...hoverHandlers(() => currentLine)
-  });
-  renderable.setRigSceneLine = (line2) => {
-    currentLine = line2;
-  };
-  return renderable;
-}
-function applyFlowTextLine(renderable, line2, width) {
-  renderable.setRigSceneLine?.(line2);
-  renderable.visible = Boolean(line2);
-  renderable.height = line2 ? 1 : 0;
-  renderable.width = Math.max(1, width);
-  renderable.content = line2?.styledText ?? line2?.text ?? "";
-  renderable.fg = line2?.fg ?? RIG_UI.ink2;
-  renderable.bg = lineBackground(line2);
-  renderable.attributes = line2?.bold ? TextAttributes3.BOLD : line2?.dim ? TextAttributes3.DIM : 0;
-}
-
-// packages/cli/src/app-opentui/render/panels.ts
-import { RGBA as RGBA4, ScrollBoxRenderable } from "@opentui/core";
-var TRANSPARENT3 = RGBA4.fromInts(0, 0, 0, 0);
-var MAX_PANEL_LINES = 420;
-var PANEL_OPAQUE_ALPHA = 255;
-var PANEL_BORDER = hexToRgba(RIG_UI.border, 255);
-function hexToRgba(hex, alpha) {
-  const clean = hex.replace(/^#/, "");
-  const full = clean.length === 3 ? clean.split("").map((part) => `${part}${part}`).join("") : clean;
-  const value = Number.parseInt(full, 16);
-  if (!Number.isFinite(value))
-    return 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_OPAQUE_ALPHA);
-}
-function panelBorder(panel) {
-  if (panel.borderColor)
-    return hexToRgba(panel.borderColor, panel.borderAlpha ?? 255);
-  return PANEL_BORDER;
-}
-function createScrollPanelLayer(renderer, id, onLineMouseDown) {
-  const panel = new ScrollBoxRenderable(renderer, {
-    id,
-    position: "absolute",
-    left: 0,
-    top: -2,
-    width: 1,
-    height: 1,
-    backgroundColor: TRANSPARENT3,
-    border: false,
-    shouldFill: true,
-    opacity: 1,
-    zIndex: 6,
-    scrollY: true,
-    scrollX: false,
-    stickyScroll: false,
-    viewportCulling: true,
-    paddingX: 2,
-    paddingY: 1,
-    verticalScrollbarOptions: {
-      showArrows: false,
-      visible: false,
-      width: 1,
-      trackOptions: {
-        backgroundColor: TRANSPARENT3,
-        foregroundColor: hexToRgba(RIG_UI.ink4, 84)
-      }
-    },
-    horizontalScrollbarOptions: {
-      height: 0,
-      visible: false,
-      trackOptions: {
-        backgroundColor: TRANSPARENT3,
-        foregroundColor: TRANSPARENT3
-      }
-    }
-  });
-  panel.__rigTextLines = [];
-  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 line2 = createFlowTextLine(panel.__rigRenderer, `${panel.id}-line-${index}`, panel.__rigOnLineMouseDown);
-    panel.__rigTextLines.push(line2);
-    panel.add(line2);
-  }
-}
-function hidePanel(panel) {
-  panel.visible = false;
-  panel.top = -2;
-  panel.left = 0;
-  panel.width = 1;
-  panel.height = 1;
-  panel.backgroundColor = TRANSPARENT3;
-  panel.border = false;
-  panel.__rigPanelId = undefined;
-  panel.__rigTextLines.forEach((line2) => applyFlowTextLine(line2, undefined, 1));
-}
-function applyScrollPanels(panels, layout, scenePanels) {
-  panels.forEach((renderable, index) => {
-    const panel = scenePanels[index];
-    if (!panel || panel.height <= 0) {
-      hidePanel(renderable);
-      return;
-    }
-    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;
-    renderable.width = width;
-    renderable.height = height;
-    renderable.zIndex = panel.zIndex ?? 6;
-    renderable.opacity = panel.opacity ?? 1;
-    const adTerminal = panel.chrome === "ad-terminal";
-    renderable.backgroundColor = adTerminal ? TRANSPARENT3 : panelBackground(panel);
-    renderable.border = adTerminal ? false : true;
-    renderable.borderColor = adTerminal ? TRANSPARENT3 : panelBorder(panel);
-    renderable.paddingX = paddingX;
-    renderable.paddingY = paddingY;
-    renderable.stickyScroll = panel.stickyScroll ?? false;
-    renderable.stickyStart = panel.stickyStart;
-    renderable.verticalScrollBar.visible = false;
-    renderable.horizontalScrollBar.visible = false;
-    if (renderable.__rigPanelId !== panel.id) {
-      renderable.__rigPanelId = panel.id;
-      renderable.scrollTo(0);
-    }
-    const lineCount = Math.min(panel.lines.length, MAX_PANEL_LINES);
-    ensurePanelLineCount(renderable, lineCount);
-    renderable.__rigTextLines.forEach((line2, lineIndex) => {
-      applyFlowTextLine(line2, lineIndex < lineCount ? panel.lines[lineIndex] : undefined, contentWidth);
-    });
-  });
-}
-
-// packages/cli/src/app-opentui/render/type-bar.ts
-import { BoxRenderable, InputRenderable, InputRenderableEvents, RGBA as RGBA5, StyledText as StyledText2, 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 createTypeBar(renderer) {
-  const background = new BoxRenderable(renderer, {
-    id: "typebar-card",
-    position: "absolute",
-    left: 0,
-    top: 0,
-    width: 1,
-    height: 1,
-    backgroundColor: TYPEBAR_BG,
-    border: true,
-    borderColor: TYPEBAR_BORDER,
-    zIndex: 4
-  });
-  const prefix = new TextRenderable2(renderer, {
-    id: "typebar-prefix",
-    content: " \u203A",
-    position: "absolute",
-    left: 1,
-    top: 0,
-    fg: RIG_UI.lime,
-    zIndex: 7,
-    selectable: true
-  });
-  const input = new InputRenderable(renderer, {
-    id: "typebar-input",
-    position: "absolute",
-    left: 4,
-    top: 0,
-    width: 40,
-    placeholder: "runs \xB7 tasks \xB7 run next \xB7 help",
-    textColor: RIG_UI.ink,
-    cursorColor: RIG_UI.lime,
-    cursorStyle: { style: "block", blinking: false },
-    showCursor: true,
-    zIndex: 7,
-    selectable: true
-  });
-  const footer = new TextRenderable2(renderer, {
-    id: "footer",
-    content: "",
-    position: "absolute",
-    left: 0,
-    top: 1,
-    width: "100%",
-    fg: RIG_UI.ink3,
-    zIndex: 7,
-    selectable: true
-  });
-  return { background, input, prefix, footer };
-}
-function modePrefix(mode) {
-  switch (mode) {
-    case "search":
-      return { glyph: " /", color: RIG_UI.cyan };
-    case "command":
-      return { glyph: " /", color: RIG_UI.lime };
-    case "prompt":
-      return { glyph: " ?", color: RIG_UI.yellow };
-    default:
-      return { glyph: " \u203A", color: RIG_UI.ink3 };
-  }
-}
-function positionTypeBar(renderables, input, footer, width, typeBarTop, footerTop) {
-  const mode = input.mode ?? "nav";
-  const editing = mode !== "nav";
-  const { glyph, color } = modePrefix(mode);
-  renderables.background.visible = true;
-  const cardTop = Math.max(0, typeBarTop - 1);
-  renderables.background.left = 0;
-  renderables.background.top = cardTop;
-  renderables.background.width = width;
-  renderables.background.height = Math.max(3, footerTop - cardTop + 1);
-  renderables.prefix.content = glyph;
-  renderables.prefix.fg = color;
-  renderables.prefix.left = 2;
-  renderables.prefix.top = typeBarTop;
-  renderables.input.top = typeBarTop;
-  renderables.input.left = 5;
-  renderables.input.width = Math.max(10, width - 8);
-  renderables.input.value = editing ? input.value : "";
-  renderables.input.placeholder = editing ? mode === "prompt" ? input.prompt?.label ?? "type a value" : mode === "command" ? "rig \u2026" : "filter\u2026" : input.placeholder;
-  renderables.input.showCursor = editing;
-  if (renderables.input.focused)
-    renderables.input.blur();
-  renderables.footer.top = footerTop;
-  renderables.footer.width = "100%";
-  renderables.footer.content = formatFooter(footer, width);
-}
-function hideTypeBar(renderables, height) {
-  renderables.background.visible = false;
-  renderables.background.top = height + 1;
-  renderables.prefix.content = "";
-  renderables.prefix.top = height + 1;
-  renderables.input.value = "";
-  renderables.input.placeholder = "";
-  renderables.input.top = height + 1;
-  renderables.input.left = 0;
-  renderables.input.width = 1;
-  renderables.input.blur();
-  renderables.footer.content = "";
-  renderables.footer.top = height + 1;
-}
-function safeFooterMessage(message) {
-  const trimmed = message?.trim();
-  if (!trimmed)
-    return null;
-  if (/https?:|\b[a-z0-9-]+\.[a-z]{2,}\b|\brig\b/i.test(trimmed))
-    return null;
-  return trimmed;
-}
-function liveCell(live) {
-  const connected = live.trimStart().startsWith("\u25CF");
-  return { text: live, style: connected ? styles.cyan : styles.ink3 };
-}
-function footerCells(footer) {
-  const safeMessage = safeFooterMessage(footer.message);
-  const cells = [
-    footer.section ? { text: `\u25B8 ${footer.section}`, style: (s) => otuiBold(styles.ink2(s)) } : null,
-    footer.live ? liveCell(footer.live) : null,
-    footer.project ? { text: "workspace", style: styles.ink3 } : null,
-    footer.server ? { text: "server selected", style: styles.ink3 } : null,
-    footer.auth ? { text: "auth ready", style: styles.ink3 } : null,
-    footer.run ? { text: `run ${footer.run}`, style: styles.ink3 } : null,
-    safeMessage ? { text: safeMessage, style: styles.ink2 } : null,
-    footer.updated ? { text: footer.updated, style: styles.ink3 } : null
-  ];
-  return cells.filter((cell) => cell !== null);
-}
-var FOOTER_SEPARATOR = "  \xB7  ";
-function formatFooter(footer, width) {
-  const budget = Math.max(8, width - 2);
-  const chunks = [styles.ink3(" ")];
-  let used = 1;
-  footerCells(footer).forEach((cell, index) => {
-    const sep = index === 0 ? "" : FOOTER_SEPARATOR;
-    const remaining = budget - used - visibleWidth(sep);
-    if (remaining <= 0)
-      return;
-    if (sep) {
-      chunks.push(styles.ink4(sep));
-      used += visibleWidth(sep);
-    }
-    const fits = visibleWidth(cell.text) <= remaining;
-    const text = fits ? cell.text : remaining <= 1 ? "\u2026" : `${[...cell.text].slice(0, Math.max(0, remaining - 1)).join("")}\u2026`;
-    chunks.push(cell.style(text));
-    used += visibleWidth(text);
-  });
-  return new StyledText2(chunks);
-}
-
-// packages/cli/src/app-opentui/render/native-host.ts
-import {
-  BoxRenderable as BoxRenderable2,
-  CodeRenderable,
-  DiffRenderable,
-  RGBA as RGBA6,
-  ScrollBoxRenderable as ScrollBoxRenderable2,
-  SyntaxStyle,
-  TextRenderable as TextRenderable3,
-  TextTableRenderable
-} from "@opentui/core";
-var syntaxStyle = null;
-function rigSyntaxStyle() {
-  if (syntaxStyle)
-    return syntaxStyle;
-  syntaxStyle = SyntaxStyle.fromStyles({
-    keyword: { fg: RGBA6.fromHex(RIG_UI.magenta), bold: true },
-    string: { fg: RGBA6.fromHex(RIG_UI.lime) },
-    number: { fg: RGBA6.fromHex(RIG_UI.cyan) },
-    comment: { fg: RGBA6.fromHex(RIG_UI.ink4), italic: true },
-    function: { fg: RGBA6.fromHex(RIG_UI.cyan) },
-    type: { fg: RGBA6.fromHex(RIG_UI.limeDim) },
-    constant: { fg: RGBA6.fromHex(RIG_UI.yellow) },
-    default: { fg: RGBA6.fromHex(RIG_UI.ink2) }
-  });
-  return syntaxStyle;
-}
-function tableContent(rows) {
-  return rows.map((row, rowIndex) => row.map((cell) => [{ __isChunk: true, text: cell, fg: RGBA6.fromHex(rowIndex === 0 ? RIG_UI.ink3 : RIG_UI.ink2) }]));
-}
-function createNativeHost(renderer) {
-  try {
-    const scrollBox = new ScrollBoxRenderable2(renderer, {
-      id: "rig-native-scrollbox",
-      position: "absolute",
-      left: 0,
-      top: 0,
-      width: 1,
-      height: 1,
-      scrollY: true,
-      zIndex: 9,
-      visible: false
-    });
-    renderer.root.add(scrollBox);
-    return { scrollBox, code: null, diff: null, table: null, active: null, lastKey: "" };
-  } catch {
-    return null;
-  }
-}
-function hideAllChildren(host) {
-  if (host.code)
-    host.code.visible = false;
-  if (host.diff)
-    host.diff.visible = false;
-  if (host.table)
-    host.table.visible = false;
-}
-function hideNativeHost(host) {
-  if (!host)
-    return;
-  host.scrollBox.visible = false;
-  hideAllChildren(host);
-  host.active = null;
-}
-function applyNativeHost(host, mount, layout) {
-  if (!host)
-    return false;
-  try {
-    const left = mount.left ?? layout.centerLeft;
-    const top = mount.top ?? layout.centerTop;
-    const width = Math.max(8, mount.width ?? layout.centerWidth);
-    const height = Math.max(3, mount.height ?? layout.centerHeight);
-    host.scrollBox.left = left;
-    host.scrollBox.top = top;
-    host.scrollBox.width = width;
-    host.scrollBox.height = height;
-    host.scrollBox.visible = true;
-    hideAllChildren(host);
-    const rowCount = mount.rows?.length ?? 0;
-    const key = `${mount.kind}:${width}x${height}:${mount.content.length}:${mount.filetype ?? ""}:${rowCount}`;
-    if (mount.kind === "table") {
-      if (!host.table) {
-        host.table = new TextTableRenderable(host.scrollBox.ctx, { id: "rig-native-table", content: [], width: "100%", showBorders: true, columnWidthMode: "full", borderColor: RIG_UI.ink4 });
-        host.scrollBox.add(host.table);
-      }
-      if (host.lastKey !== key)
-        host.table.content = tableContent(mount.rows ?? []);
-      host.table.visible = true;
-    } else if (mount.kind === "diff") {
-      if (!host.diff) {
-        host.diff = new DiffRenderable(host.scrollBox.ctx, { id: "rig-native-diff", diff: "", width: "100%" });
-        host.scrollBox.add(host.diff);
-      }
-      if (host.lastKey !== key)
-        host.diff.diff = mount.content;
-      host.diff.visible = true;
-    } else {
-      const filetype = mount.kind === "markdown" ? "markdown" : mount.filetype ?? "text";
-      if (!host.code) {
-        host.code = new CodeRenderable(host.scrollBox.ctx, { id: "rig-native-code", content: "", filetype, syntaxStyle: rigSyntaxStyle(), width: "100%" });
-        host.scrollBox.add(host.code);
-      }
-      if (host.lastKey !== key) {
-        host.code.filetype = filetype;
-        host.code.content = mount.content;
-      }
-      host.code.visible = true;
-    }
-    host.active = mount.kind;
-    host.lastKey = key;
-    if (mount.stickyBottom)
-      host.scrollBox.scrollTo?.({ x: 0, y: Number.MAX_SAFE_INTEGER });
-    return true;
-  } catch {
-    hideNativeHost(host);
-    return false;
-  }
-}
-function destroyNativeHost(host) {
-  if (!host)
-    return;
-  try {
-    host.scrollBox.destroy?.();
-  } catch {}
-}
-
-// packages/cli/src/app-opentui/remote-link.ts
-var REPAIRABLE_REMOTE_LINK_STATUSES = new Set([
-  "auth_required",
-  "project_not_registered",
-  "no_server_checkout",
-  "invalid_root",
-  "needs_prepare",
-  "error"
-]);
-function remoteProjectLinkError(message) {
-  return /no server-host project root link|remote project(?:-root)? link|x-rig-project-root|serverProjectRoot/i.test(message ?? "");
-}
-function serverRecordForRemoteLink(state) {
-  const server = state.data.server;
-  return server && typeof server === "object" && !Array.isArray(server) ? server : null;
-}
-function remoteProjectLinkState(state) {
-  const serverRecord = serverRecordForRemoteLink(state);
-  if (!serverRecord || serverRecord.kind !== "remote")
-    return null;
-  const link = serverRecord.remoteProjectLink;
-  if (link && typeof link === "object" && !Array.isArray(link))
-    return link;
-  const direct = state.data.remoteProjectLink;
-  if (direct && typeof direct === "object" && !Array.isArray(direct))
-    return direct;
-  return null;
-}
-function shouldOfferRemoteLinkRepair(state, message) {
-  const link = remoteProjectLinkState(state);
-  if (link) {
-    if (link.ok === true)
-      return false;
-    const status = link.status ?? "";
-    return REPAIRABLE_REMOTE_LINK_STATUSES.has(status);
-  }
-  const serverRecord = serverRecordForRemoteLink(state);
-  if (serverRecord && serverRecord.kind !== "remote")
-    return false;
-  return remoteProjectLinkError(message ?? state.error?.message);
-}
-
-// packages/cli/src/app-opentui/selectable.ts
-function selectableDeckRow(deck, item) {
-  return { ...deckRow({ ...deck, activateOnClick: true }), selectable: item };
-}
-
-// packages/cli/src/app-opentui/scenes/error.ts
-var ERROR_ACTIONS = [
-  { detail: "return to dashboard", item: { id: "main", label: "main", intent: { scene: "main", argv: [], action: { kind: "refresh", label: "Back to dashboard" } }, message: "back to dashboard" } },
-  { detail: "run diagnostics", item: { id: "doctor", label: "doctor", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Run doctor" } }, message: "run diagnostics" } },
-  { detail: "open server controls", item: { id: "server", label: "server", intent: { scene: "server", argv: ["server", "status"], action: { kind: "refresh", label: "Open server controls" } }, message: "open server controls" } }
-];
-var ERROR_REPAIR_LINK_ACTION = { detail: "backfill or prepare selected remote project-root link", item: { id: "repair-link", label: "repair link", intent: { scene: "server", argv: ["server", "repair-link"], action: { kind: "remote-link-repair", label: "Repair remote link", payload: { returnScene: "server" } } }, message: "repair remote project link" } };
-function errorActions(state) {
-  return shouldOfferRemoteLinkRepair(state, state.error?.message) ? [...ERROR_ACTIONS, ERROR_REPAIR_LINK_ACTION] : ERROR_ACTIONS;
-}
-function renderErrorScene(state) {
-  const message = state.error?.message ?? "Unknown app error";
-  const hint = state.error?.hint ?? "Use the actions below to recover.";
-  const actions = errorActions(state);
-  const selected = Math.max(0, Math.min(actions.length - 1, 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 }),
-        ...actions.map(({ detail, item }, index) => selectableDeckRow({ label: item.label, detail, index, active: selected === index }, item))
-      ],
-      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
-function surfaceActionItem(action) {
-  if (action.needsArgs && action.promptArgv) {
-    return {
-      id: action.id,
-      label: action.label,
-      prompt: {
-        label: action.template ?? action.label,
-        scene: "command",
-        argv: [...action.promptArgv],
-        intentKind: "command-run",
-        payloadBase: {},
-        payloadKey: "args",
-        appendValueToArgv: true
-      },
-      message: `${action.template ?? action.label} \xB7 enter args to run`
-    };
-  }
-  return {
-    id: action.id,
-    label: action.label,
-    intent: intentForSurfaceAction(action),
-    message: action.template ? `${action.template} \xB7 ${action.detail}` : action.detail
-  };
-}
-var SHORTCUTS = [
-  ["tab / \u2192", "next workspace"],
-  ["\u2190", "previous workspace"],
-  ["esc", "back one screen \xB7 clears search filter first"],
-  ["\u2191 \u2193 / j k", "move selection"],
-  ["enter / space / click", "activate selected action"],
-  ["/", "search the current list (runs \xB7 tasks)"],
-  [":", "command palette \u2014 type any rig command"],
-  ["mouse wheel", "scroll panel under cursor"],
-  ["ctrl-]", "detach from embedded Pi/command terminal"],
-  ["q", "back \xB7 exits from the home cockpit"],
-  ["ctrl-c", "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 actions = tuiSurfaceActions();
-  const selected = Math.max(0, Math.min(actions.length - 1, state.selection.index));
-  const actionLines = [];
-  let previousFamily = "";
-  actions.forEach((action, index) => {
-    if (action.family !== previousFamily) {
-      if (actionLines.length > 0)
-        actionLines.push(line("", { fg: RIG_UI.ink4 }));
-      actionLines.push(line(action.family.toUpperCase(), { fg: RIG_UI.ink3, bold: true }));
-      previousFamily = action.family;
-    }
-    const label = action.id.startsWith("family:") ? action.label : `  ${action.label}`;
-    const detail = action.template ? `${action.detail} \xB7 ${action.template}` : action.detail;
-    actionLines.push(selectableDeckRow({ label, detail, index, active: selected === index }, surfaceActionItem(action)));
-  });
-  const panelLines = [
-    ...unsupported ? [
-      line(`${unsupported.command} needs the action catalog.`, { fg: RIG_UI.yellow, bold: true }),
-      line(unsupported.reason ?? "Pick an action below; command workspaces run inside this TUI unless RIG_PLAIN=1/--json/CI is explicit.", { fg: RIG_UI.ink3 }),
-      line("", { fg: RIG_UI.ink3 })
-    ] : [],
-    line("SURFACES / ACTIONS", { fg: RIG_UI.ink3, bold: true }),
-    ...actionLines,
-    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
-    }],
-    footer: { message: "enter/click opens a workspace" },
-    live: true
-  });
-}
-
-// packages/cli/src/app-opentui/scenes/main.ts
-var CONFIGURED_MENU = [
-  ["init", "guided setup, reconfigure, repair project state", { id: "init", label: "init", intent: { scene: "init", argv: ["init"], action: { kind: "refresh", label: "Open init" } }, message: "open native init flow" }],
-  ["server", "local/remote target, auth, linkage", { id: "server", label: "server", intent: { scene: "server", argv: ["server", "status"], action: { kind: "refresh", label: "Checking server" } }, message: "check selected server" }],
-  ["github", "auth, selected repo, stored token", { id: "github", label: "github", intent: { scene: "server", argv: ["github", "auth", "status"], action: { kind: "refresh", label: "Checking GitHub auth" } }, message: "check GitHub auth" }],
-  ["tasks", "browse, filter, dispatch, attach active work", { id: "tasks", label: "tasks", intent: { scene: "tasks", argv: ["tasks"], action: { kind: "refresh", label: "Opening tasks" } }, message: "selected tasks" }],
-  ["runs", "attach, stop, resume, inspect live sessions", { id: "runs", label: "runs", intent: { scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } }, message: "selected runs" }],
-  ["inbox", "approve, reject, answer, attach", { id: "inbox", label: "inbox", intent: { scene: "inbox", argv: ["inbox"], action: { kind: "refresh", label: "Loading inbox" } }, message: "selected inbox" }],
-  ["doctor", "diagnose and repair broken surfaces", { id: "doctor", label: "doctor", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Running doctor" } }, message: "diagnose project" }],
-  ["browser", "browser workstation, hp-next, CDP, profile smokes", { id: "browser", label: "browser", intent: { scene: "family", argv: ["browser"], action: { kind: "refresh", label: "Open browser workstation", payload: { family: "browser" } } }, message: "browser workstation control panel" }],
-  ["stats", "fleet metrics: completion, failures, run time", { id: "stats", label: "stats", intent: { scene: "family", argv: ["stats"], action: { kind: "refresh", label: "Open stats", payload: { family: "stats" } } }, message: "fleet metrics dashboard" }],
-  ["agent", "runtime agent workspace roster and controls", { id: "agent", label: "agent", intent: { scene: "family", argv: ["agent"], action: { kind: "refresh", label: "Open agents", payload: { family: "agent" } } }, message: "agent workspace controls" }],
-  ["remote", "remote orchestration status and controls", { id: "remote", label: "remote", intent: { scene: "family", argv: ["remote"], action: { kind: "refresh", label: "Open remote", payload: { family: "remote" } } }, message: "remote orchestration controls" }],
-  ["pi", "Pi extension packages, search/add/remove/list", { id: "pi", label: "pi", intent: { scene: "pi", argv: ["pi", "list"], action: { kind: "refresh", label: "Open Pi extensions" } }, message: "Pi extension package actions" }],
-  ["inspect", "logs, artifacts, failures, graph, audit, diff", { id: "inspect", label: "inspect", intent: { scene: "inspect", argv: ["inspect"], action: { kind: "refresh", label: "Open inspect actions" } }, message: "logs/artifacts/failures/diff" }],
-  ["plugin", "plugin list, validation, contributed commands", { id: "plugin", label: "plugin", intent: { scene: "plugin", argv: ["plugin", "list"], action: { kind: "refresh", label: "Open plugin actions" } }, message: "plugin contributions" }],
-  ["repo", "repo sync, git helper, harness helper", { id: "repo", label: "repo", intent: { scene: "repo", argv: ["repo", "status"], action: { kind: "refresh", label: "Open repo/git/harness actions" } }, message: "repo/git/harness helpers" }],
-  ["workspace", "workspace topology, remotes, service helpers", { id: "workspace", label: "workspace", intent: { scene: "workspace", argv: ["workspace", "summary"], action: { kind: "refresh", label: "Open workspace summary" } }, message: "workspace topology" }],
-  ["help", "all actions, shortcuts, mouse controls", { id: "help", label: "help", intent: { scene: "help", argv: ["help"], action: { kind: "none", label: "Opening help" } }, message: "selected help" }]
-];
-var ONBOARD_PRIMARY = {
-  id: "onboard-init",
-  label: "Start guided init",
-  intent: { scene: "init", argv: ["init"], action: { kind: "refresh", label: "Init" } },
-  message: "open the native init checklist"
-};
-var ONBOARD_SECONDARY = [
-  ["server", "select a local or remote target", { id: "server", label: "server", intent: { scene: "server", argv: ["server", "status"], action: { kind: "refresh", label: "Checking server" } }, message: "check selected server" }],
-  ["doctor", "diagnose what is missing", { id: "doctor", label: "doctor", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Running doctor" } }, message: "diagnose missing setup" }],
-  ["help", "shortcuts and controls", { id: "help", label: "help", intent: { scene: "help", argv: ["help"], action: { kind: "none", label: "Opening help" } }, message: "selected help" }]
-];
-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 inboxPending(state) {
-  const inbox = record(state.data.inbox);
-  const approvals = Array.isArray(inbox?.approvals) ? inbox.approvals.length : 0;
-  const inputs = Array.isArray(inbox?.inputs) ? inbox.inputs.length : 0;
-  return approvals + inputs;
-}
-function readyTaskCount(state) {
-  const tasks = record(state.data.tasks);
-  const records = Array.isArray(tasks?.records) ? tasks.records : [];
-  return records.filter((entry) => {
-    const status = record(entry)?.status;
-    return typeof status === "string" && /(ready|open|todo|pending)/i.test(status);
-  }).length;
-}
-function needsAttention(state) {
-  const stats = fleetStatsFromState(state);
-  let attention = stats.failed;
-  for (const [status, count] of stats.byStatus) {
-    if (/(needs-attention|stalled|blocked|error)/i.test(status))
-      attention += count;
-  }
-  return attention;
-}
-function tile(count, label, hint, color, item, active) {
-  const lit = count > 0;
-  const row = selectableDeckRow({ label: `${String(count).padStart(2)} ${label}`, detail: hint, active }, item);
-  return { ...row, fg: lit ? color : RIG_UI.ink3, bold: lit || active };
-}
-function panelWidth2(layout) {
-  return layout?.centerWidth ?? 118;
-}
-function panelHeight2(layout) {
-  return Math.max(22, layout?.centerHeight ?? 36);
-}
-function configuredMenuRows(selectedIndex) {
-  return CONFIGURED_MENU.map(([label, detail, item], index) => ({
-    ...deckRow({ label, detail, index, active: index === selectedIndex, activateOnClick: true }),
-    selectable: item
-  }));
-}
-function onboardingRows(selectedIndex) {
-  const primary = selectableDeckRow({ label: "init", detail: "Start guided init \u2014 recommended", active: selectedIndex === 0 }, ONBOARD_PRIMARY);
-  const secondary = ONBOARD_SECONDARY.map(([label, detail, item], index) => ({
-    ...deckRow({ label, detail, index: index + 1, active: selectedIndex === index + 1, activateOnClick: true }),
-    selectable: item
-  }));
-  return [primary, ...secondary];
-}
-var TILE_RUNS = { id: "tile-runs", label: "runs", intent: { scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } }, message: "active runs \u2014 attach/stop/inspect" };
-var TILE_ATTENTION = { id: "tile-attention", label: "attention", intent: { scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } }, message: "runs that need attention" };
-var TILE_INBOX = { id: "tile-inbox", label: "inbox", intent: { scene: "inbox", argv: ["inbox"], action: { kind: "refresh", label: "Loading inbox" } }, message: "pending approvals + input requests" };
-var TILE_TASKS = { id: "tile-tasks", label: "tasks", intent: { scene: "tasks", argv: ["tasks"], action: { kind: "refresh", label: "Opening tasks" } }, message: "ready tasks \u2014 dispatch work" };
-function dashboardLines(state, selected) {
-  const stats = fleetStatsFromState(state);
-  const attention = needsAttention(state);
-  const pending = inboxPending(state);
-  const ready = readyTaskCount(state);
-  const spark = sparklineString(stats.sparkline, 24);
-  const lines = [
-    line("FLEET", { fg: RIG_UI.ink, bold: true }),
-    tile(stats.active, "ACTIVE RUNS", "attach \xB7 steer \xB7 stop \xB7 inspect", RIG_UI.cyan, TILE_RUNS, selected === 0),
-    tile(attention, "NEEDS ATTENTION", "failed / stalled runs to triage", RIG_UI.red, TILE_ATTENTION, selected === 1),
-    tile(pending, "PENDING APPROVALS", "blockers waiting on you", RIG_UI.yellow, TILE_INBOX, selected === 2),
-    tile(ready, "READY TASKS", "dispatch a new run", RIG_UI.lime, TILE_TASKS, selected === 3)
-  ];
-  if (spark.trim())
-    lines.push(line(`  throughput ${spark}  ${stats.succeeded} done \xB7 ${stats.failed} failed \xB7 ${stats.total} total`, { fg: RIG_UI.ink3 }));
-  return { lines, tileCount: 4 };
-}
-function statusLine(state) {
-  const label = state.actionLabel ?? (state.runtimeReady ? "ready" : "starting up");
-  if (state.status === "error") {
-    return line(`\u2717 ${state.error?.message ?? label}`, { fg: RIG_UI.red, bold: true });
-  }
-  if (state.status === "action") {
-    return line(`\u25D0 ${label}`, { fg: RIG_UI.cyan, bold: true });
-  }
-  if (state.status === "success") {
-    return line(`\u2713 ${label}`, { fg: RIG_UI.limeDim, bold: true });
-  }
-  return line(`\u25CF ${label}`, { fg: RIG_UI.ink2, bold: true });
-}
-function renderMainScene(state, layout) {
-  const configured = state.data.projectConfigured === true;
-  const server = serverSummary(state);
-  const selected = Math.max(0, state.selection.index);
-  const dash = configured ? dashboardLines(state, selected) : { lines: [], tileCount: 0 };
-  const actionSelected = configured ? selected - dash.tileCount : selected;
-  const lines = configured ? [
-    line("COCKPIT", { fg: RIG_UI.ink, bold: true }),
-    line("arrows + enter or click a tile/row \xB7 esc goes back \xB7 ctrl-c exits", { fg: RIG_UI.ink3 }),
-    blank(),
-    ...dash.lines,
-    blank(),
-    line("MANAGE", { fg: RIG_UI.ink, bold: true }),
-    ...configuredMenuRows(actionSelected),
-    blank(),
-    line("CONTEXT", { fg: RIG_UI.ink3, bold: true }),
-    kv("config", "configured", RIG_UI.limeDim),
-    kv("server", `${server.label} \xB7 ${server.health}`, server.health === "reachable" ? RIG_UI.limeDim : RIG_UI.yellow),
-    kv("github", server.auth, server.auth.startsWith("signed in") ? RIG_UI.limeDim : RIG_UI.yellow),
-    blank(),
-    statusLine(state)
-  ] : [
-    line("WELCOME", { fg: RIG_UI.ink, bold: true }),
-    line("This project isn't initialized yet. One native init flow gets you running.", { fg: RIG_UI.ink2 }),
-    blank(),
-    line("GET STARTED", { fg: RIG_UI.ink, bold: true }),
-    ...onboardingRows(actionSelected),
-    blank(),
-    line("CONTEXT", { fg: RIG_UI.ink3, bold: true }),
-    kv("config", "needs setup", RIG_UI.yellow),
-    kv("server", `${server.label} \xB7 ${server.health}`, server.health === "reachable" ? RIG_UI.limeDim : RIG_UI.yellow),
-    kv("github", server.auth, server.auth.startsWith("signed in") ? RIG_UI.limeDim : RIG_UI.yellow),
-    blank(),
-    statusLine(state)
-  ];
-  return makeSceneFrame({
-    scene: "main",
-    title: "Cockpit",
-    lines: [],
-    panels: [{
-      id: "cockpit",
-      top: 0,
-      width: panelWidth2(layout),
-      height: panelHeight2(layout),
-      lines,
-      backgroundColor: RIG_UI.panel,
-      backgroundAlpha: 184,
-      opacity: 0.98,
-      border: false,
-      chrome: "ad-terminal",
-      headerText: "cockpit",
-      paddingX: layout?.compact ? 3 : 5,
-      paddingY: 2
-    }],
-    live: true
-  });
-}
-
-// packages/cli/src/app-opentui/runtime.ts
-var PRELOADER_BACKDROP = RGBA7.fromHex(RIG_UI.bg);
-function inboxPendingCount(state) {
-  const inbox = state.data.inbox;
-  if (!inbox || typeof inbox !== "object" || Array.isArray(inbox))
-    return 0;
-  const record2 = inbox;
-  const approvals = Array.isArray(record2.approvals) ? record2.approvals.length : 0;
-  const inputs = Array.isArray(record2.inputs) ? record2.inputs.length : 0;
-  return approvals + inputs;
-}
-var PRIMARY_NAV = [
-  { id: "cockpit", label: "Cockpit", scene: "main", argv: ["main"], enterLabel: "Cockpit", member: ["main"] },
-  { id: "runs", label: "Runs", scene: "fleet", argv: ["runs"], enterLabel: "Runs", member: ["fleet", "run-detail", "inspect", "handoff"] },
-  { id: "tasks", label: "Tasks", scene: "tasks", argv: ["tasks"], enterLabel: "Tasks", member: ["tasks"] },
-  { id: "inbox", label: "Inbox", scene: "inbox", argv: ["inbox"], enterLabel: "Inbox", member: ["inbox"], badge: inboxPendingCount },
-  { id: "stats", label: "Stats", scene: "family", argv: ["stats"], enterLabel: "Stats", member: ["family"] },
-  { id: "init", label: "Init", scene: "init", argv: ["init"], enterLabel: "Init", member: ["init", "doctor", "server", "pi", "plugin", "repo", "workspace"] },
-  { id: "help", label: "Help", scene: "help", argv: ["help"], enterLabel: "Help", member: ["help"] }
-];
-function activeNavSection(scene) {
-  return PRIMARY_NAV.find((section) => section.member.includes(scene)) ?? PRIMARY_NAV[0];
-}
-function entryIntentForScene(scene) {
-  switch (scene) {
-    case "main":
-      return { scene, argv: ["main"], action: { kind: "refresh", label: "Cockpit" } };
-    case "fleet":
-      return { scene, argv: ["runs"], action: { kind: "refresh", label: "Runs" } };
-    case "tasks":
-      return { scene, argv: ["tasks"], action: { kind: "refresh", label: "Tasks" } };
-    case "inbox":
-      return { scene, argv: ["inbox"], action: { kind: "refresh", label: "Inbox" } };
-    case "server":
-      return { scene, argv: ["server", "status"], action: { kind: "refresh", label: "Server" } };
-    case "doctor":
-      return { scene, argv: ["doctor"], action: { kind: "doctor-run", label: "Doctor" } };
-    case "init":
-      return { scene, argv: ["init"], action: { kind: "refresh", label: "Init" } };
-    case "run-detail":
-      return { scene, argv: ["run", "status"], action: { kind: "refresh", label: "Run" } };
-    case "pi":
-      return { scene, argv: ["pi", "list"], action: { kind: "refresh", label: "Pi" } };
-    case "plugin":
-      return { scene, argv: ["plugin", "list"], action: { kind: "refresh", label: "Plugins" } };
-    case "repo":
-      return { scene, argv: ["repo", "status"], action: { kind: "refresh", label: "Repo" } };
-    case "workspace":
-      return { scene, argv: ["workspace", "summary"], action: { kind: "refresh", label: "Workspace" } };
-    case "inspect":
-      return { scene, argv: ["inspect"], action: { kind: "refresh", label: "Inspect" } };
-    case "family":
-      return { scene, argv: ["stats"], action: { kind: "refresh", label: "Stats", payload: { family: "stats" } } };
-    case "help":
-      return { scene, argv: ["help"], action: { kind: "none", label: "Help" } };
-    case "command":
-    case "handoff":
-    case "error":
-      return { scene: "main", argv: ["main"], action: { kind: "refresh", label: "Cockpit" } };
-  }
-}
-function sceneSectionLabel(scene) {
-  const labels = {
-    main: "cockpit",
-    fleet: "runs",
-    tasks: "tasks",
-    inbox: "inbox",
-    inspect: "inspect",
-    "run-detail": "run",
-    handoff: "pi console",
-    server: "server",
-    doctor: "doctor",
-    init: "init",
-    pi: "pi",
-    plugin: "plugins",
-    repo: "repo",
-    workspace: "workspace",
-    family: "family",
-    command: "command",
-    help: "help",
-    error: "error"
-  };
-  return labels[scene] ?? scene;
-}
-function liveLinkLabel(status) {
-  if (status === "connected")
-    return "\u25CF live";
-  if (status === "connecting")
-    return "\u25CB connecting";
-  return "\u25CB polling";
-}
-function buildNavStrip(state) {
-  const active = activeNavSection(state.scene);
-  const chunks = [];
-  PRIMARY_NAV.forEach((section, index) => {
-    if (index > 0)
-      chunks.push(styles.ink4("   "));
-    const isActive = section.id === active.id;
-    chunks.push(isActive ? otuiBold(styles.lime(section.label)) : styles.ink3(section.label));
-    const badgeCount = section.badge ? section.badge(state) : 0;
-    if (badgeCount > 0) {
-      chunks.push(styles.ink4(" "));
-      chunks.push(otuiBold(styles.yellow(String(badgeCount))));
-    }
-  });
-  return new StyledText3(chunks);
-}
-function renderedItemsOrStateItems(_state, renderedItems) {
-  return renderedItems ? [...renderedItems] : [];
-}
-function selectedRenderedItemId(state) {
-  if (state.scene === "fleet") {
-    const selected = state.data.selectedRunId;
-    return typeof selected === "string" && selected.trim() ? selected.trim() : undefined;
-  }
-  if (state.scene === "tasks") {
-    const selected = state.data.selectedTaskId;
-    return typeof selected === "string" && selected.trim() ? selected.trim() : undefined;
-  }
-  return;
-}
-function effectiveRenderedIndex(state, items) {
-  if (items.length === 0)
-    return -1;
-  const selectedId = selectedRenderedItemId(state);
-  if (selectedId) {
-    const renderedIndex = items.findIndex((item) => item.id === selectedId);
-    if (renderedIndex >= 0)
-      return renderedIndex;
-    if (state.scene === "fleet" || state.scene === "tasks")
-      return 0;
-  }
-  return Math.max(0, Math.min(items.length - 1, state.selection.index));
-}
-function selectIndex(store, index, renderedItems) {
-  const state = store.getState();
-  const items = renderedItemsOrStateItems(state, renderedItems);
-  if (items.length === 0)
-    return false;
-  const next = Math.max(0, Math.min(items.length - 1, index));
-  const item = items[next];
-  store.patch({
-    selection: { index: next, count: items.length },
-    ...item.data ? { data: item.data } : {},
-    typeBar: { message: item.message ?? item.label }
-  });
-  return true;
-}
-function moveSelection(store, delta, renderedItems) {
-  const state = store.getState();
-  const items = renderedItemsOrStateItems(state, renderedItems);
-  const current = effectiveRenderedIndex(state, items);
-  return current >= 0 && selectIndex(store, current + delta, items);
-}
-function selectById(store, id, renderedItems) {
-  const items = renderedItemsOrStateItems(store.getState(), renderedItems);
-  const index = items.findIndex((item) => item.id === id);
-  return index >= 0 && selectIndex(store, index, items);
-}
-var DESTRUCTIVE_ACTION_KINDS = new Set(["run-stop", "inbox-reject"]);
-function intentNeedsConfirm(intent2) {
-  return DESTRUCTIVE_ACTION_KINDS.has(intent2.action.kind) || intent2.action.payload?.confirm === true;
-}
-async function activateSelection(runtime, renderedItems) {
-  const state = runtime.getState();
-  const items = renderedItemsOrStateItems(state, renderedItems);
-  const index = effectiveRenderedIndex(state, items);
-  if (index < 0)
-    return false;
-  const item = items[index];
-  if (item.data)
-    runtime.patchState({ data: item.data });
-  if (item.prompt) {
-    runtime.emit({ type: "typebar.patch", typeBar: { mode: "prompt", value: "", prompt: item.prompt } });
-    return true;
-  }
-  if (item.intent) {
-    if (intentNeedsConfirm(item.intent)) {
-      runtime.emit({ type: "confirm.request", confirm: { label: item.intent.action.label ?? "Confirm action", intent: item.intent } });
-      return true;
-    }
-    await runtime.runIntent(item.intent);
-    return true;
-  }
-  runtime.patchState({ typeBar: { message: item.message ?? item.label } });
-  return true;
-}
-
-// packages/cli/src/app-opentui/react/App.tsx
-import { useMemo, useRef as useRef4, useSyncExternalStore as useSyncExternalStore2 } from "react";
-import { useKeyboard, useRenderer as useRenderer4, useTerminalDimensions as useTerminalDimensions2 } from "@opentui/react";
-
-// packages/cli/src/app-opentui/react/Backdrop.tsx
-import { useEffect, useRef } from "react";
-import { useRenderer } from "@opentui/react";
-var ANIMATION_SLOWDOWN = 1;
-function isTerminalScene(scene) {
-  return scene === "handoff" || scene === "command";
-}
-function Backdrop(props) {
-  const renderer = useRenderer();
-  const graphicsRef = useRef(null);
-  useEffect(() => {
-    const layout = computeStageLayout(renderer.width, renderer.height);
-    const graphics = createGraphicsLayer(renderer, layout);
-    renderer.root.add(graphics);
-    graphicsRef.current = graphics;
-    return () => {
-      const g = graphicsRef.current;
-      if (g) {
-        try {
-          renderer.root.remove(g.id);
-        } catch {}
-      }
-      graphicsRef.current = null;
-    };
-  }, [renderer]);
-  useEffect(() => {
-    const graphics = graphicsRef.current;
-    if (!graphics)
-      return;
-    const layout = computeStageLayout(renderer.width, renderer.height);
-    if (layout.tooSmall) {
-      clearGraphicsLayer(graphics);
-      return;
-    }
-    const stats = fleetStatsFromState(props.state);
-    const animationTick = Math.floor(props.state.tick / ANIMATION_SLOWDOWN);
-    const panels = (props.frame.panels ?? []).map((panel) => ({ ...panel }));
-    const terminalActive = props.frame.terminalActive ?? isTerminalScene(props.state.scene);
-    const fullScreen = Boolean(props.frame.fullScreen);
-    resizeGraphicsLayer(graphics, layout);
-    if (terminalActive || fullScreen) {
-      clearGraphicsLayer(graphics);
-    } else {
-      drawAmbientField(graphics, layout, animationTick, props.state.scene, stats.load, stats.active);
-      drawPanelChrome(graphics, layout, panels);
-    }
-  });
-  return null;
-}
-
-// packages/cli/src/app-opentui/react/SceneFrameView.tsx
-import { useEffect as useEffect2, useRef as useRef2 } from "react";
-import { useRenderer as useRenderer2 } from "@opentui/react";
-import { TextAttributes as TextAttributes4 } from "@opentui/core";
-
-// packages/cli/src/app-opentui/react/scroll.ts
-var registries = new Set;
-function registerScrollables(provider) {
-  registries.add(provider);
-  return () => {
-    registries.delete(provider);
-  };
-}
-function scrollActiveBody(delta) {
-  for (const provider of registries) {
-    for (const body of provider()) {
-      if (body.visible)
-        body.scrollBy(delta);
-    }
-  }
-}
-
-// packages/cli/src/app-opentui/react/SceneFrameView.tsx
-import { jsxDEV, Fragment } from "@opentui/react/jsx-dev-runtime";
-function lineAttributes(line2) {
-  return line2?.bold ? TextAttributes4.BOLD : line2?.dim ? TextAttributes4.DIM : 0;
-}
-function lineContent(line2) {
-  return line2.styledText ?? line2.text ?? "";
-}
-function LineView(props) {
-  const { line: line2, onLineClick } = props;
-  const id = lineSelectableId(line2);
-  return /* @__PURE__ */ jsxDEV("text", {
-    style: { position: "absolute", left: props.left, top: props.top, width: props.width, zIndex: 5 },
-    fg: line2.fg ?? RIG_UI.ink2,
-    bg: lineBackground(line2),
-    attributes: lineAttributes(line2),
-    content: lineContent(line2),
-    onMouseDown: onLineClick ? () => onLineClick(line2) : undefined,
-    onMouseOver: id !== undefined ? () => setHoveredSelectableId(id) : undefined,
-    onMouseOut: id !== undefined ? () => clearHoveredSelectableId(id) : undefined
-  }, undefined, false, undefined, this);
-}
-function PanelHost(props) {
-  const renderer = useRenderer2();
-  const poolRef = useRef2([]);
-  const clickRef = useRef2(props.onLineClick);
-  clickRef.current = props.onLineClick;
-  useEffect2(() => {
-    const unregister = registerScrollables(() => poolRef.current);
-    return () => {
-      unregister();
-      for (const panel of poolRef.current) {
-        try {
-          renderer.root.remove(panel.id);
-        } catch {}
-      }
-      poolRef.current = [];
-    };
-  }, [renderer]);
-  useEffect2(() => {
-    const pool = poolRef.current;
-    while (pool.length < props.panels.length) {
-      const panel = createScrollPanelLayer(renderer, `react-scroll-panel-${pool.length}`, (line2) => clickRef.current?.(line2));
-      renderer.root.add(panel);
-      pool.push(panel);
-    }
-    applyScrollPanels(pool, props.layout, props.panels);
-  });
-  return null;
-}
-function NativeHostView(props) {
-  const renderer = useRenderer2();
-  const hostRef = useRef2(null);
-  useEffect2(() => {
-    const host = createNativeHost(renderer);
-    hostRef.current = host;
-    const unregister = registerScrollables(() => host ? [host.scrollBox] : []);
-    return () => {
-      unregister();
-      destroyNativeHost(hostRef.current);
-      hostRef.current = null;
-    };
-  }, [renderer]);
-  useEffect2(() => {
-    const host = hostRef.current;
-    if (!host)
-      return;
-    if (props.native) {
-      if (!applyNativeHost(host, props.native, props.layout))
-        hideNativeHost(host);
-    } else {
-      hideNativeHost(host);
-    }
-  });
-  return null;
-}
-function SceneFrameView(props) {
-  const { frame, layout } = props;
-  const contentLayout = frame.fullScreen ? { ...layout, centerWidth: layout.width, centerLeft: 0, centerTop: 0 } : layout;
-  const lines = fitSceneLines(frame.lines ?? [], contentLayout);
-  const nativeActive = frame.native && !frame.terminalActive;
-  return /* @__PURE__ */ jsxDEV(Fragment, {
-    children: [
-      lines.map((line2, index) => /* @__PURE__ */ jsxDEV(LineView, {
-        line: line2,
-        top: contentLayout.centerTop + index,
-        left: contentLayout.centerLeft,
-        width: contentLayout.centerWidth,
-        onLineClick: props.onLineClick
-      }, `line-${index}`, false, undefined, this)),
-      /* @__PURE__ */ jsxDEV(PanelHost, {
-        panels: frame.panels ?? [],
-        layout: contentLayout,
-        onLineClick: props.onLineClick
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(NativeHostView, {
-        native: nativeActive ? frame.native : undefined,
-        layout: contentLayout
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-
-// packages/cli/src/app-opentui/react/ChromeHost.tsx
-import { useEffect as useEffect3, useRef as useRef3 } from "react";
-import { useRenderer as useRenderer3, useTerminalDimensions } from "@opentui/react";
-import { TextRenderable as TextRenderable5 } from "@opentui/core";
-function isTerminalScene2(scene) {
-  return scene === "handoff" || scene === "command";
-}
-function ChromeHost(props) {
-  const renderer = useRenderer3();
-  const dims = useTerminalDimensions();
-  const navRef = useRef3(null);
-  const barRef = useRef3(null);
-  useEffect3(() => {
-    const nav = new TextRenderable5(renderer, { id: "react-primary-nav", content: "", position: "absolute", left: 0, top: -2, width: 1, zIndex: 9, selectable: false });
-    renderer.root.add(nav);
-    navRef.current = nav;
-    const bar = createTypeBar(renderer);
-    renderer.root.add(bar.background);
-    renderer.root.add(bar.prefix);
-    renderer.root.add(bar.input);
-    renderer.root.add(bar.footer);
-    barRef.current = bar;
-    return () => {
-      try {
-        renderer.root.remove(nav.id);
-      } catch {}
-      for (const r of [bar.background, bar.prefix, bar.input, bar.footer]) {
-        try {
-          renderer.root.remove(r.id);
-        } catch {}
-      }
-      navRef.current = null;
-      barRef.current = null;
-    };
-  }, [renderer]);
-  useEffect3(() => {
-    const { state, frame } = props;
-    const layout = computeStageLayout(dims.width, dims.height);
-    const nav = navRef.current;
-    const bar = barRef.current;
-    const terminalActive = isTerminalScene2(state.scene);
-    const showNav = !frame.fullScreen && !terminalActive && state.typeBar.mode !== "command";
-    if (nav) {
-      nav.visible = showNav;
-      if (showNav) {
-        nav.content = buildNavStrip(state);
-        nav.left = layout.centerLeft;
-        nav.top = Math.max(0, layout.centerTop - 2);
-        nav.width = layout.centerWidth;
-        nav.fg = RIG_UI.ink3;
-        nav.zIndex = 9;
-      }
-    }
-    if (bar) {
-      if (frame.hideTypeBar) {
-        hideTypeBar(bar, layout.height);
-      } else {
-        positionTypeBar(bar, { ...state.typeBar, placeholder: frame.typeBarPlaceholder ?? state.typeBar.placeholder }, { section: sceneSectionLabel(state.scene), ...state.footer, ...frame.footer ?? {} }, layout.width, layout.typeBarTop, layout.footerTop);
-      }
-    }
-  });
-  return null;
-}
-
-// packages/cli/src/app-opentui/react/context.tsx
-import { createContext, useContext, useSyncExternalStore } from "react";
-import { jsxDEV as jsxDEV2 } from "@opentui/react/jsx-dev-runtime";
-var RigAppContext = createContext(null);
-function RigAppProvider(props) {
-  return /* @__PURE__ */ jsxDEV2(RigAppContext.Provider, {
-    value: props.value,
-    children: props.children
-  }, undefined, false, undefined, this);
-}
-function useCtx() {
-  const value = useContext(RigAppContext);
-  if (!value)
-    throw new Error("Rig react components must render inside <RigAppProvider>.");
-  return value;
-}
-function useAppState() {
-  const { store } = useCtx();
-  return useSyncExternalStore(store.subscribe, store.getState, store.getState);
-}
-function useRuntime() {
-  return useCtx().runtime;
-}
-function useStore() {
-  return useCtx().store;
-}
-function useRunAppAction() {
-  return useCtx().runAppAction;
-}
-
-// packages/cli/src/app-opentui/react/nav.ts
-function inboxPendingCount2(state) {
-  const inbox = state.data.inbox;
-  if (!inbox || typeof inbox !== "object" || Array.isArray(inbox))
-    return 0;
-  const record2 = inbox;
-  const approvals = Array.isArray(record2.approvals) ? record2.approvals.length : 0;
-  const inputs = Array.isArray(record2.inputs) ? record2.inputs.length : 0;
-  return approvals + inputs;
-}
-var PRIMARY_NAV2 = [
-  { id: "cockpit", label: "Cockpit", scene: "main", argv: ["main"], enterLabel: "Cockpit", member: ["main"] },
-  { id: "runs", label: "Runs", scene: "fleet", argv: ["runs"], enterLabel: "Runs", member: ["fleet", "run-detail", "inspect", "handoff"] },
-  { id: "tasks", label: "Tasks", scene: "tasks", argv: ["tasks"], enterLabel: "Tasks", member: ["tasks"] },
-  { id: "inbox", label: "Inbox", scene: "inbox", argv: ["inbox"], enterLabel: "Inbox", member: ["inbox"], badge: inboxPendingCount2 },
-  { id: "stats", label: "Stats", scene: "family", argv: ["stats"], enterLabel: "Stats", member: ["family"] },
-  { id: "init", label: "Init", scene: "init", argv: ["init"], enterLabel: "Init", member: ["init", "doctor", "server", "pi", "plugin", "repo", "workspace"] },
-  { id: "help", label: "Help", scene: "help", argv: ["help"], enterLabel: "Help", member: ["help"] }
-];
-function navSectionIntent(section) {
-  if (section.scene === "help") {
-    return { scene: "help", argv: ["help"], action: { kind: "none", label: "Help" } };
-  }
-  if (section.scene === "family") {
-    return { scene: "family", argv: section.argv, action: { kind: "refresh", label: section.enterLabel, payload: { family: section.argv[0] } } };
-  }
-  return { scene: section.scene, argv: section.argv, action: { kind: "refresh", label: section.enterLabel } };
-}
-function activeNavSection2(scene) {
-  return PRIMARY_NAV2.find((section) => section.member.includes(scene)) ?? PRIMARY_NAV2[0];
-}
-function primaryNavIntent(scene) {
-  const section = PRIMARY_NAV2.find((entry) => entry.scene === scene || entry.member.includes(scene)) ?? PRIMARY_NAV2[0];
-  return navSectionIntent(section);
-}
-function nextPrimaryScene(current, delta) {
-  const active = activeNavSection2(current);
-  const index = PRIMARY_NAV2.findIndex((entry) => entry.id === active.id);
-  const base = index < 0 ? 0 : index;
-  return PRIMARY_NAV2[(base + delta + PRIMARY_NAV2.length) % PRIMARY_NAV2.length].scene;
-}
-
-// packages/cli/src/app-opentui/react/App.tsx
-import { jsxDEV as jsxDEV3 } from "@opentui/react/jsx-dev-runtime";
-var BUILTIN = {
-  main: renderMainScene,
-  help: renderHelpScene,
-  error: renderErrorScene
-};
-function defaultFrame(state) {
-  return {
-    scene: state.scene,
-    lines: [
-      { text: `  ${state.scene}`, fg: "#f4f5f8", bold: true },
-      { text: "  Return to cockpit", fg: "#9aa0ae", selectable: { id: "home", label: "cockpit", intent: primaryNavIntent("main") } }
-    ]
-  };
-}
-function App(props) {
-  const state = useAppState();
-  const runtime = useRuntime();
-  const runAppAction = useRunAppAction();
-  const store = useStore();
-  const renderer = useRenderer4();
-  useSyncExternalStore2(subscribeHover, getHoveredSelectableId, getHoveredSelectableId);
-  const dims = useTerminalDimensions2();
-  const layout = computeStageLayout(dims.width, dims.height);
-  const registry = useMemo(() => ({ ...BUILTIN, ...props.sceneRenderers ?? {} }), [props.sceneRenderers]);
-  const render = registry[state.scene];
-  const frame = render ? render(state, layout) : defaultFrame(state);
-  const contentLayout = frame.fullScreen ? { ...layout, centerWidth: layout.width, centerLeft: 0, centerTop: 0 } : layout;
-  const selectables = deriveSelectables(fitSceneLines(frame.lines ?? [], contentLayout), frame.panels);
-  const itemsRef = useRef4(selectables);
-  itemsRef.current = selectables;
-  useKeyboard((key) => handleAppKeyPress({
-    renderer: () => renderer,
-    runtime,
-    getState: () => store.getState(),
-    getTypeBar: () => null,
-    getRenderedSelectableItems: () => itemsRef.current,
-    emitTypeBarPatch: (patch) => runtime.emit({ type: "typebar.patch", typeBar: patch }),
-    runAppAction,
-    primaryNavIntent,
-    nextPrimaryScene,
-    moveSelection: (delta, items) => moveSelection(store, delta, items),
-    activateSelection: (items) => activateSelection(runtime, items),
-    scrollActiveBody: (delta) => scrollActiveBody(delta)
-  }, key));
-  const onLineClick = (line2) => {
-    const items = itemsRef.current;
-    const id = line2.selectable?.id ?? line2.selectableId;
-    if (id !== undefined) {
-      if (!selectById(store, id, items))
-        return;
-    } else if (line2.selectableIndex !== undefined) {
-      selectIndex(store, line2.selectableIndex, items);
-    } else {
-      return;
-    }
-    runAppAction("Activate selection", () => activateSelection(runtime, items));
-  };
-  return /* @__PURE__ */ jsxDEV3("box", {
-    style: { position: "absolute", left: 0, top: 0, width: "100%", height: "100%" },
-    children: [
-      /* @__PURE__ */ jsxDEV3(Backdrop, {
-        state,
-        frame
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV3(SceneFrameView, {
-        frame,
-        layout,
-        onLineClick
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV3(ChromeHost, {
-        state,
-        frame
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-function deriveSelectables(fittedLines, panels) {
-  const seen = new Set;
-  const out = [];
-  const collect = (lines) => {
-    for (const line2 of lines ?? []) {
-      const item = line2.selectable;
-      if (item && !seen.has(item.id)) {
-        seen.add(item.id);
-        out.push(item);
-      }
-    }
-  };
-  collect(fittedLines);
-  for (const panel of panels ?? [])
-    collect(panel.lines);
-  return out;
-}
-
-// packages/cli/src/app-opentui/react/launch.tsx
-import { jsxDEV as jsxDEV4 } from "@opentui/react/jsx-dev-runtime";
-var POLLABLE_SCENES = new Set(["main", "fleet", "tasks", "inbox", "run-detail", "inspect", "server", "doctor", "workspace"]);
-async function launchRigReactApp(options) {
-  const initialState = createInitialAppState(options);
-  const store = createAppStore(initialState);
-  const events = createAppEventBus();
-  let renderer = null;
-  let root = null;
-  let runnerPromise = null;
-  let suppressHistoryPush = false;
-  let resolveExit = () => {};
-  const appExit = new Promise((resolve3) => {
-    resolveExit = resolve3;
-  });
-  let relaunching = false;
-  const mountRenderer = async () => {
-    renderer = await createCliRenderer2({
-      screenMode: "alternate-screen",
-      exitOnCtrlC: false,
-      targetFps: 30,
-      maxFps: 30,
-      useMouse: true,
-      autoFocus: false,
-      useKittyKeyboard: { disambiguate: true }
-    });
-    renderer.on("destroy", () => {
-      if (!relaunching)
-        resolveExit();
-    });
-    root = createRoot(renderer);
-    root.render(/* @__PURE__ */ jsxDEV4(RigAppProvider, {
-      value: { store, runtime, runAppAction },
-      children: /* @__PURE__ */ jsxDEV4(App, {
-        sceneRenderers: options.sceneRenderers
-      }, undefined, false, undefined, this)
-    }, undefined, false, undefined, this));
-    relaunching = false;
-  };
-  const teardownRenderer = () => {
-    relaunching = true;
-    try {
-      root?.unmount();
-    } catch {}
-    root = null;
-    try {
-      renderer?.destroy();
-    } catch {}
-    renderer = null;
-  };
-  const runAppAction = (label, action) => {
-    action().catch((error) => {
-      const n = normalizeError(error);
-      events.emit({ type: "action.failed", label, message: n.message, hint: n.hint, cause: n.cause });
-    });
-  };
-  const runtime = {
-    getState: () => store.getState(),
-    patchState: (patch) => store.patch(patch),
-    emit: (event) => events.emit(event),
-    setScene: (scene, intent2) => events.emit({ type: "scene.change", scene, ...intent2 ? { intent: intent2 } : {} }),
-    runIntent: async (nextIntent) => {
-      const previousScene = store.getState().scene;
-      if (!suppressHistoryPush && nextIntent.scene !== previousScene) {
-        store.patch({ history: [...store.getState().history, previousScene].slice(-25) });
-      }
-      events.emit({ type: "scene.change", scene: nextIntent.scene, intent: nextIntent });
-      if (nextIntent.action.kind !== "none" && nextIntent.action.kind !== "navigate") {
-        events.emit({ type: "action.started", label: nextIntent.action.label ?? nextIntent.action.kind, optimistic: { lastIntent: nextIntent } });
-      }
-      for (const adapter of options.adapters ?? []) {
-        await adapter.handleIntent?.(runtime, nextIntent);
-      }
-    },
-    goBack: async () => {
-      const current = store.getState();
-      const previous = current.history[current.history.length - 1];
-      store.patch({ history: current.history.slice(0, -1) });
-      suppressHistoryPush = true;
-      try {
-        await runtime.runIntent(entryIntentForScene(previous ?? "main"));
-      } finally {
-        suppressHistoryPush = false;
-      }
-    },
-    getRunnerContext: async () => {
-      if (!options.initializeRuntime)
-        throw new Error("Runtime initializer was not provided to the OpenTUI app.");
-      runnerPromise ??= options.initializeRuntime();
-      return runnerPromise;
-    },
-    suspend: () => teardownRenderer(),
-    resume: async () => {
-      await mountRenderer();
-    },
-    destroy: () => renderer?.destroy()
-  };
-  events.subscribe((event) => store.patch(reduceAppEvent(store.getState(), event)));
-  const tick = setInterval(() => store.patch({ tick: store.getState().tick + 1 }), 96);
-  if (typeof tick.unref === "function") {
-    tick.unref();
-  }
-  await mountRenderer();
-  let liveEvents = null;
-  const canAutoRefresh = (state) => {
-    if (state.status === "action" || state.status === "loading")
-      return false;
-    if (state.confirm)
-      return false;
-    const mode = state.typeBar.mode ?? "nav";
-    if (mode === "command" || mode === "prompt")
-      return false;
-    return POLLABLE_SCENES.has(state.scene);
-  };
-  const refreshCurrentDataScene = () => {
-    const state = store.getState();
-    if (!canAutoRefresh(state))
-      return;
-    const refreshIntent = entryIntentForScene(state.scene);
-    runAppAction("live-refresh", async () => {
-      for (const adapter of options.adapters ?? [])
-        await adapter.handleIntent?.(runtime, refreshIntent);
-    });
-  };
-  const FALLBACK_REFRESH_MS = Number(process.env.RIG_OPENTUI_FALLBACK_REFRESH_MS) || 15000;
-  const poll = setInterval(() => {
-    const erroredDataScene = store.getState().status === "error";
-    if (liveEvents?.connected() && !erroredDataScene)
-      return;
-    refreshCurrentDataScene();
-  }, FALLBACK_REFRESH_MS);
-  if (typeof poll.unref === "function")
-    poll.unref();
-  queueMicrotask(() => {
-    (async () => {
-      try {
-        if (options.initializeRuntime) {
-          const runner = await runtime.getRunnerContext();
-          events.emit({ type: "runtime.ready", runner });
-        }
-        for (const adapter of options.adapters ?? [])
-          await adapter.start?.(runtime);
-        connectRigServerEvents(options.projectRoot, {
-          onSnapshotInvalidated: () => refreshCurrentDataScene(),
-          onRunLogAppended: () => {
-            const scene = store.getState().scene;
-            if (scene === "run-detail" || scene === "fleet")
-              refreshCurrentDataScene();
-          },
-          onStatus: (status) => store.patch({ footer: { live: liveLinkLabel(status) } })
-        }).then((subscription) => {
-          liveEvents = subscription;
-        }).catch(() => {
-          store.patch({ footer: { live: liveLinkLabel("disconnected") } });
-        });
-        await runtime.runIntent(store.getState().intent);
-      } catch (error) {
-        const n = normalizeError(error);
-        events.emit({ type: "runtime.failed", message: n.message, hint: n.hint, cause: n.cause });
-      }
-    })();
-  });
-  await appExit;
-  clearInterval(tick);
-  clearInterval(poll);
-  liveEvents?.close();
-  teardownRenderer();
-}
-export {
-  launchRigReactApp
-};