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

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

@@ -2,7 +2,7 @@
 // packages/cli/src/app-opentui/runtime.ts
 import { existsSync as existsSync3 } from "fs";
 import { resolve as resolve3 } from "path";
-import { BoxRenderable as BoxRenderable3, RGBA as RGBA8, StyledText as StyledText4, TextRenderable as TextRenderable4, createCliRenderer } from "@opentui/core";
+import { BoxRenderable as BoxRenderable3, RGBA as RGBA7, StyledText as StyledText3, TextRenderable as TextRenderable4, createCliRenderer } from "@opentui/core";
 
 // packages/cli/src/app-opentui/events.ts
 function createAppEventBus() {
@@ -351,12 +351,13 @@ var PRIMARY_GROUPS = [
   {
     name: "server",
     summary: "Choose, inspect, and start the Rig server that owns tasks and runs.",
-    usage: ["rig server <status|list|add|use|start> [options]"],
+    usage: ["rig server <status|list|add|use|repair-link|start> [options]"],
     commands: [
-      { command: "status", description: "Show the selected server for this repo.", primary: true },
+      { 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." }
     ],
@@ -364,6 +365,7 @@ var PRIMARY_GROUPS = [
       "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"
     ],
@@ -1056,16 +1058,31 @@ function taskViewIntent(argv, command = "", rest = [], raw) {
   const { payload, label } = taskViewPayload(command, rest);
   return intent("tasks", argv, "refresh", payload, label, raw);
 }
-function routeServer(argv, command, raw, checkingLabel) {
-  if (!command || command === "status") {
+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) {
@@ -1114,11 +1131,16 @@ function intentFromArgv(argv) {
     return commandRunIntent(argv);
   }
   if (normalizedGroup === "server")
-    return routeServer(argv, normalizedCommand, undefined, "Checking server");
+    return routeServer(argv, normalizedCommand, rest, undefined, "Checking server");
   if (normalizedGroup === "github")
     return routeGithub(argv, normalizedCommand, rest);
-  if (normalizedGroup === "init")
-    return commandRunIntent(argv);
+  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")
@@ -1181,12 +1203,17 @@ function intentFromTypeBar(value) {
       return commandRunIntent(parts, value);
     return intent("tasks", parts, "refresh", undefined, "Select a task, then press Enter; or use run next", value);
   }
-  if (first === "init")
-    return commandRunIntent(parts, 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, value, "Loading server");
+    return routeServer(parts, second, rest, value, "Loading server");
   if (first === "github")
     return routeGithub(parts, second, rest, value);
   if (first === "inbox")
@@ -1204,397 +1231,6 @@ function intentFromTypeBar(value) {
   return intentFromArgv(parts);
 }
 
-// packages/cli/src/app-opentui/pi-pty-host.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { basename as basename2 } from "path";
-import { RGBA, StyledText, TextAttributes } from "@opentui/core";
-import { Terminal as XtermTerminal2 } from "@xterm/headless";
-var MIN_COLS2 = 40;
-var MIN_ROWS2 = 12;
-var MAX_ROWS2 = 300;
-var MAX_SNAPSHOT_LINES2 = 360;
-var STYLED_SNAPSHOT_MARGIN = 6;
-var SNAPSHOT_DELAY_MS2 = 120;
-var fallbackChildScriptPath = fileURLToPath2(new URL("./pi-host-child.ts", import.meta.url));
-var activeHost2 = null;
-function clampCols2(cols) {
-  return Math.max(MIN_COLS2, Math.trunc(cols || 100));
-}
-function clampRows2(rows) {
-  return Math.max(MIN_ROWS2, Math.min(MAX_ROWS2, Math.trunc(rows || 35)));
-}
-var XTERM_COLOR_MODE_INDEXED_16 = 16777216;
-var XTERM_COLOR_MODE_INDEXED_256 = 33554432;
-var XTERM_COLOR_MODE_RGB = 50331648;
-function rgbaFromXtermColor(mode, value) {
-  if (mode === 1 || mode === 2 || mode === XTERM_COLOR_MODE_INDEXED_16 || mode === XTERM_COLOR_MODE_INDEXED_256) {
-    return RGBA.fromIndex(value);
-  }
-  if (mode === 3 || mode === XTERM_COLOR_MODE_RGB) {
-    return RGBA.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255);
-  }
-  return;
-}
-function textAttributesFromCell(cell) {
-  let attributes = TextAttributes.NONE;
-  if (cell.isBold())
-    attributes |= TextAttributes.BOLD;
-  if (cell.isDim())
-    attributes |= TextAttributes.DIM;
-  if (cell.isItalic())
-    attributes |= TextAttributes.ITALIC;
-  if (cell.isUnderline())
-    attributes |= TextAttributes.UNDERLINE;
-  if (cell.isBlink())
-    attributes |= TextAttributes.BLINK;
-  if (cell.isInverse())
-    attributes |= TextAttributes.INVERSE;
-  if (cell.isInvisible())
-    attributes |= TextAttributes.HIDDEN;
-  if (cell.isStrikethrough())
-    attributes |= TextAttributes.STRIKETHROUGH;
-  return attributes;
-}
-function sameRgba(a, b) {
-  if (!a && !b)
-    return true;
-  return Boolean(a && b && a.equals(b));
-}
-function sameStyle(a, b) {
-  return sameRgba(a.fg, b.fg) && sameRgba(a.bg, b.bg) && (a.attributes ?? 0) === (b.attributes ?? 0);
-}
-function styleFromCell(cell) {
-  return {
-    fg: rgbaFromXtermColor(cell.getFgColorMode(), cell.getFgColor()),
-    bg: rgbaFromXtermColor(cell.getBgColorMode(), cell.getBgColor()),
-    attributes: textAttributesFromCell(cell)
-  };
-}
-function lineToStyledText(line, cols) {
-  if (!line)
-    return new StyledText([{ __isChunk: true, text: "" }]);
-  const chunks = [];
-  let run = "";
-  let runStyle = null;
-  const flush = () => {
-    if (!run)
-      return;
-    chunks.push({
-      __isChunk: true,
-      text: run,
-      ...runStyle?.fg ? { fg: runStyle.fg } : {},
-      ...runStyle?.bg ? { bg: runStyle.bg } : {},
-      ...(runStyle?.attributes ?? 0) !== 0 ? { attributes: runStyle.attributes } : {}
-    });
-    run = "";
-  };
-  for (let index = 0;index < cols; index += 1) {
-    const cell = line.getCell(index);
-    if (!cell) {
-      if (runStyle !== null)
-        flush();
-      runStyle = null;
-      run += " ";
-      continue;
-    }
-    if (cell.getWidth() === 0)
-      continue;
-    const style = styleFromCell(cell);
-    if (!runStyle || !sameStyle(runStyle, style)) {
-      flush();
-      runStyle = style;
-    }
-    run += cell.getChars() || " ";
-  }
-  flush();
-  return new StyledText(chunks.length > 0 ? chunks : [{ __isChunk: true, text: "" }]);
-}
-function childCommandPrefix2() {
-  const execName = basename2(process.execPath).toLowerCase();
-  const currentEntry = process.argv[1];
-  if (execName === "bun" || execName === "bun.exe") {
-    return currentEntry ? [process.execPath, currentEntry, "__opentui-pi-host"] : [process.execPath, fallbackChildScriptPath];
-  }
-  return [process.execPath, "__opentui-pi-host"];
-}
-function withEnv2(base) {
-  const env = {};
-  for (const [key, value] of Object.entries(base ?? process.env)) {
-    if (key === "RIG_PLAIN" || key === "RIG_CLI_PLAIN_HELP" || key === "NO_COLOR")
-      continue;
-    if (typeof value === "string")
-      env[key] = value;
-  }
-  return {
-    ...env,
-    TERM: "xterm-256color",
-    COLORTERM: "truecolor",
-    FORCE_COLOR: env.FORCE_COLOR ?? "1",
-    RIG_OPENTUI_PI_HOST: "1"
-  };
-}
-function getActivePiHost() {
-  return activeHost2 && !activeHost2.disposed ? activeHost2 : null;
-}
-function stopActivePiHost(reason = "detach") {
-  activeHost2?.dispose(reason);
-  activeHost2 = null;
-}
-
-class PiPtyHost {
-  runId;
-  projectRoot;
-  onSnapshot;
-  onExit;
-  onError;
-  terminal;
-  disposables = [];
-  decoder = new TextDecoder("utf-8");
-  proc = null;
-  pty = null;
-  status = "starting";
-  cols;
-  rows;
-  message = "starting bundled Pi";
-  lastResizeError = null;
-  exitCode;
-  signal;
-  notifyTimer = null;
-  lastStreamKey = "";
-  _disposed = false;
-  constructor(options) {
-    this.runId = options.runId;
-    this.projectRoot = options.projectRoot;
-    this.cols = clampCols2(options.cols);
-    this.rows = clampRows2(options.rows);
-    this.onSnapshot = options.onSnapshot;
-    this.onExit = options.onExit;
-    this.onError = options.onError;
-    this.terminal = new XtermTerminal2({
-      allowProposedApi: true,
-      cols: this.cols,
-      rows: this.rows,
-      scrollback: 1000
-    });
-    this.registerTerminalResponders();
-    this.disposables.push(this.terminal.onWriteParsed(() => {
-      if (this._disposed)
-        return;
-      const snapshot = this.createSnapshot();
-      const key = snapshot.lines.join(`
-`);
-      if (key === this.lastStreamKey)
-        return;
-      this.lastStreamKey = key;
-      this.onSnapshot?.(snapshot);
-    }));
-  }
-  get disposed() {
-    return this._disposed;
-  }
-  get snapshot() {
-    return this.createSnapshot();
-  }
-  async start() {
-    if (this._disposed)
-      throw new Error("Pi PTY host is disposed.");
-    if (typeof Bun.Terminal !== "function") {
-      throw new Error("Bun native PTY is unavailable in this runtime. Pi host requires Bun.Terminal.");
-    }
-    const spawnOptions = {
-      cwd: this.projectRoot,
-      env: withEnv2(process.env),
-      terminal: {
-        cols: this.cols,
-        rows: this.rows,
-        name: "xterm-256color",
-        data: (_terminal, data) => this.handlePtyData(data)
-      }
-    };
-    const proc = Bun.spawn([
-      ...childCommandPrefix2(),
-      "--run-id",
-      this.runId,
-      "--project-root",
-      this.projectRoot
-    ], spawnOptions);
-    if (!proc.terminal)
-      throw new Error("Bun did not attach a terminal to the bundled Pi child process.");
-    this.proc = proc;
-    this.pty = proc.terminal;
-    this.status = "running";
-    this.message = "bundled Pi running inside this app";
-    this.emitSnapshotSoon(0);
-    proc.exited.then((exitCode) => {
-      if (this._disposed)
-        return;
-      this.status = exitCode === 0 ? "exited" : "failed";
-      this.exitCode = exitCode;
-      this.signal = null;
-      this.message = exitCode === 0 ? "bundled Pi exited" : `bundled Pi exited with code ${exitCode}`;
-      const snapshot = this.createSnapshot();
-      this.onSnapshot?.(snapshot);
-      this.onExit?.(snapshot);
-      if (activeHost2 === this)
-        activeHost2 = null;
-      this.dispose("exit", { kill: false, notify: false });
-    }).catch((error) => {
-      if (this._disposed)
-        return;
-      this.status = "failed";
-      this.message = error instanceof Error ? error.message : String(error);
-      const snapshot = this.createSnapshot();
-      this.onSnapshot?.(snapshot);
-      this.onError?.(error, snapshot);
-      if (activeHost2 === this)
-        activeHost2 = null;
-      this.dispose("error", { kill: false, notify: false });
-    });
-  }
-  write(data) {
-    if (this._disposed || !this.pty)
-      return;
-    try {
-      this.pty.write(data);
-    } catch (error) {
-      this.status = "failed";
-      this.message = error instanceof Error ? error.message : String(error);
-      const snapshot = this.createSnapshot();
-      this.onSnapshot?.(snapshot);
-      this.onError?.(error, snapshot);
-    }
-  }
-  resize(cols, rows) {
-    const nextCols = clampCols2(cols);
-    const nextRows = clampRows2(rows);
-    if (nextCols === this.cols && nextRows === this.rows)
-      return;
-    this.cols = nextCols;
-    this.rows = nextRows;
-    this.terminal.resize(nextCols, nextRows);
-    try {
-      this.pty?.resize(nextCols, nextRows);
-      this.lastResizeError = null;
-    } catch (error) {
-      this.lastResizeError = error instanceof Error ? error.message : String(error);
-    }
-    this.emitSnapshotSoon(0);
-  }
-  detach() {
-    this.dispose("detach");
-    return this.createSnapshot("detached from bundled Pi");
-  }
-  dispose(reason = "dispose", options = {}) {
-    if (this._disposed)
-      return;
-    this._disposed = true;
-    if (this.notifyTimer)
-      clearTimeout(this.notifyTimer);
-    this.notifyTimer = null;
-    for (const disposable of this.disposables.splice(0)) {
-      try {
-        disposable.dispose();
-      } catch {}
-    }
-    if (options.kill !== false) {
-      try {
-        this.proc?.kill("SIGTERM");
-      } catch {}
-    }
-    try {
-      this.pty?.close();
-    } catch {}
-    try {
-      this.terminal.dispose();
-    } catch {}
-    if (activeHost2 === this)
-      activeHost2 = null;
-    if (options.notify) {
-      this.message = reason;
-      this.onSnapshot?.(this.createSnapshot(reason));
-    }
-  }
-  handlePtyData(data) {
-    if (this._disposed)
-      return;
-    const text = this.decoder.decode(data, { stream: true });
-    this.respondToRawTerminalQueries(text);
-    this.terminal.write(data);
-  }
-  emitSnapshotSoon(delayMs = SNAPSHOT_DELAY_MS2) {
-    if (this._disposed || this.notifyTimer)
-      return;
-    this.notifyTimer = setTimeout(() => {
-      this.notifyTimer = null;
-      if (this._disposed)
-        return;
-      this.onSnapshot?.(this.createSnapshot());
-    }, delayMs);
-  }
-  createSnapshot(message = this.message) {
-    const buffer = this.terminal.buffer.active;
-    const end = buffer.length;
-    const start = Math.max(0, end - MAX_SNAPSHOT_LINES2);
-    const styledStart = Math.max(start, end - this.rows - STYLED_SNAPSHOT_MARGIN);
-    const lines = [];
-    const styledLines = [];
-    for (let row = start;row < end; row += 1) {
-      const line = buffer.getLine(row);
-      lines.push((line?.translateToString(false) ?? "").slice(0, this.cols));
-      if (row >= styledStart)
-        styledLines[lines.length - 1] = lineToStyledText(line, this.cols);
-    }
-    while (lines.length < this.rows) {
-      lines.push("");
-      styledLines[lines.length - 1] = new StyledText([{ __isChunk: true, text: "" }]);
-    }
-    const resolvedMessage = this.lastResizeError ? `resize degraded: ${this.lastResizeError}` : message;
-    return {
-      runId: this.runId,
-      status: this.status,
-      cols: this.cols,
-      rows: this.rows,
-      lines,
-      styledLines,
-      message: resolvedMessage,
-      ...this.lastResizeError ? { resizeError: this.lastResizeError } : {},
-      ...this.exitCode !== undefined ? { exitCode: this.exitCode } : {},
-      ...this.signal !== undefined ? { signal: this.signal } : {}
-    };
-  }
-  registerTerminalResponders() {
-    this.disposables.push(this.terminal.parser.registerCsiHandler({ final: "c" }, (params) => {
-      if (params.length === 0 || params[0] === 0)
-        this.write("\x1B[?62;22c");
-      return false;
-    }));
-    this.disposables.push(this.terminal.parser.registerCsiHandler({ prefix: ">", final: "c" }, (params) => {
-      if (params.length === 0 || params[0] === 0)
-        this.write("\x1B[>0;0;0c");
-      return false;
-    }));
-    this.disposables.push(this.terminal.parser.registerCsiHandler({ final: "n" }, (params) => {
-      if (params[0] === 5) {
-        this.write("\x1B[0n");
-      } else if (params[0] === 6) {
-        const row = this.terminal.buffer.active.cursorY + 1;
-        const col = this.terminal.buffer.active.cursorX + 1;
-        this.write(`\x1B[${row};${col}R`);
-      }
-      return false;
-    }));
-  }
-  respondToRawTerminalQueries(text) {
-    if (!text)
-      return;
-    const decrqm = /\x1b\[\?(\d+)\$p/g;
-    let match;
-    while ((match = decrqm.exec(text)) !== null) {
-      this.write(`\x1B[?${match[1]};2$y`);
-    }
-  }
-}
-
 // packages/cli/src/app-opentui/keymap.ts
 var autocompleteState;
 function clearTypeBar(context, message) {
@@ -1604,22 +1240,15 @@ function clearTypeBar(context, message) {
   context.emitTypeBarPatch({ value: "", mode: "nav", prompt: undefined, message });
 }
 function handleEmbeddedTerminalKey(context, key) {
-  const state = context.getState();
-  const piHost = getActivePiHost();
-  const commandHost = getActiveCommandHost();
-  const host = state.scene === "handoff" ? piHost : state.scene === "command" ? commandHost : null;
+  if (context.getState().scene !== "command")
+    return false;
+  const host = getActiveCommandHost();
   if (!host)
     return false;
   if (key.ctrl && key.name === "]") {
-    if (state.scene === "handoff") {
-      stopActivePiHost("operator detach");
-      clearTypeBar(context, "detached from Pi");
-      context.runAppAction("Opening runs", () => context.runtime.runIntent({ scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } }));
-    } else {
-      stopActiveCommandHost("operator detach");
-      clearTypeBar(context, "closed command");
-      context.runAppAction("Project menu", () => context.runtime.runIntent({ scene: "main", argv: ["main"], action: { kind: "none", label: "Project menu" } }));
-    }
+    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;
@@ -1931,8 +1560,8 @@ import { WsTransport } from "@rig/client";
 import { RIG_WS_CHANNELS } from "@rig/contracts";
 
 // packages/cli/src/commands/_server-client.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+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";
@@ -2024,12 +1653,28 @@ function readRepoConnection(projectRoot) {
     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
+    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)
@@ -2041,13 +1686,41 @@ function resolveSelectedConnection(projectRoot, options = {}) {
   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: repo.serverProjectRoot };
+  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 writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
+function clearRepoServerProjectRoot(projectRoot) {
   const repo = readRepoConnection(projectRoot);
   if (!repo)
     return;
-  writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
+  writeRepoConnection(projectRoot, {
+    selected: repo.selected,
+    ...repo.project ? { project: repo.project } : {},
+    ...repo.linkedAt ? { linkedAt: repo.linkedAt } : {}
+  });
 }
 
 // packages/cli/src/commands/_server-client.ts
@@ -2088,11 +1761,10 @@ function readStoredGitHubAuthToken(projectRoot) {
   const parsed = readRemoteAuthState(projectRoot);
   return parsed ? cleanToken(typeof parsed.token === "string" ? parsed.token : undefined) : null;
 }
-function inferRemoteServerProjectRootFromAuthState(projectRoot) {
-  const repo = readRepoConnection(projectRoot);
-  const slug = repo?.project?.trim();
-  if (!slug || !/^[^/]+\/[^/]+$/.test(slug))
+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;
@@ -2101,25 +1773,413 @@ function inferRemoteServerProjectRootFromAuthState(projectRoot) {
   const checkoutBaseDir = typeof auth?.checkoutBaseDir === "string" && auth.checkoutBaseDir.trim() ? auth.checkoutBaseDir.trim() : null;
   if (!checkoutBaseDir)
     return null;
-  const inferred = `${checkoutBaseDir.replace(/\/+$/, "")}/${slug}`;
-  writeRepoServerProjectRoot(projectRoot, inferred);
-  return inferred;
+  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 serverProjectRoot = selected.serverProjectRoot ?? inferRemoteServerProjectRootFromAuthState(projectRoot) ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
+      const link = await ensureRemoteProjectRootLink(projectRoot, { mode: "backfill-only", authToken });
       return {
         baseUrl: selected.connection.baseUrl,
         authToken,
         connectionKind: "remote",
-        serverProjectRoot
+        serverProjectRoot: link.ok ? link.serverProjectRoot ?? null : null
       };
     }
     reportServerPhase("Starting local Rig server\u2026");
@@ -2137,32 +2197,6 @@ async function ensureServerForCli(projectRoot) {
     throw error;
   }
 }
-async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken) {
-  const repo = readRepoConnection(projectRoot);
-  const slug = repo?.project?.trim();
-  if (!slug)
-    return null;
-  try {
-    const url = new URL(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`);
-    if (authToken && queryAuthFallbackEnabled())
-      url.searchParams.set("rt", authToken);
-    const response = await fetch(url, {
-      headers: mergeHeaders(undefined, authToken)
-    });
-    if (!response.ok)
-      return null;
-    const payload = await response.json();
-    const project = payload.project && typeof payload.project === "object" && !Array.isArray(payload.project) ? payload.project : null;
-    const checkouts = Array.isArray(project?.checkouts) ? project.checkouts : [];
-    const latestCheckout = [...checkouts].reverse().find((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.path === "string"));
-    const path = typeof latestCheckout?.path === "string" && latestCheckout.path.trim() ? latestCheckout.path.trim() : null;
-    if (path)
-      writeRepoServerProjectRoot(projectRoot, path);
-    return path;
-  } catch {
-    return null;
-  }
-}
 function mergeCookie(existing, name, value) {
   const encoded = `${name}=${encodeURIComponent(value)}`;
   if (!existing?.trim())
@@ -2238,7 +2272,7 @@ import {
   dim as otuiDim,
   fg as otuiFg,
   t,
-  TextAttributes as TextAttributes2
+  TextAttributes
 } from "@opentui/core";
 var RIG_UI = {
   bg: "#070809",
@@ -2274,7 +2308,7 @@ var styles = {
 };
 
 // packages/cli/src/app-opentui/drone.ts
-import { RGBA as RGBA2, StyledText as StyledText2, TextAttributes as TextAttributes3 } from "@opentui/core";
+import { RGBA, StyledText, TextAttributes as TextAttributes2 } from "@opentui/core";
 var MINI_DRONE = [
   "(!!!)   (!!!)",
   "  \\%==%/  ",
@@ -2290,13 +2324,13 @@ var LEAD_MARK = [
 var BLADE_FRAMES = ["---", "\\\\\\", "|||", "///"];
 var EYE_FRAMES = ["o", "@", "\u2022", "."];
 var COLOR = {
-  body: RGBA2.fromHex(RIG_UI.lime),
-  mini: RGBA2.fromHex(RIG_UI.limeDim),
-  rotor: RGBA2.fromHex(RIG_UI.cyan),
-  path: RGBA2.fromHex(RIG_UI.cyan),
-  eye: RGBA2.fromHex(RIG_UI.ink),
-  dim: RGBA2.fromHex(RIG_UI.ink4),
-  ink: RGBA2.fromHex(RIG_UI.ink2)
+  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];
@@ -2306,12 +2340,12 @@ function eyeForTick(tick, phase = 0) {
   return pulse > 0.55 ? EYE_FRAMES[1] : pulse > 0.1 ? EYE_FRAMES[0] : pulse > -0.45 ? EYE_FRAMES[2] : EYE_FRAMES[3];
 }
 function chunk(text, fg, bold = false, dim = false) {
-  let attributes = TextAttributes3.NONE;
+  let attributes = TextAttributes2.NONE;
   if (bold)
-    attributes |= TextAttributes3.BOLD;
+    attributes |= TextAttributes2.BOLD;
   if (dim)
-    attributes |= TextAttributes3.DIM;
-  return { __isChunk: true, text, fg, ...attributes !== TextAttributes3.NONE ? { attributes } : {} };
+    attributes |= TextAttributes2.DIM;
+  return { __isChunk: true, text, fg, ...attributes !== TextAttributes2.NONE ? { attributes } : {} };
 }
 function styledLine(text, colorFor) {
   const chunks = [];
@@ -2332,7 +2366,7 @@ function styledLine(text, colorFor) {
     run += char;
   }
   flush();
-  return new StyledText2(chunks.length > 0 ? chunks : [chunk("", COLOR.ink)]);
+  return new StyledText(chunks.length > 0 ? chunks : [chunk("", COLOR.ink)]);
 }
 function droneColor(char) {
   if (char === "?" || char === "o" || char === "@" || char === "\u2022")
@@ -2612,7 +2646,7 @@ function reduceAppEvent(state, event) {
 }
 
 // packages/cli/src/app-opentui/render/graphics.ts
-import { FrameBufferRenderable, RGBA as RGBA3 } from "@opentui/core";
+import { FrameBufferRenderable, RGBA as RGBA2 } from "@opentui/core";
 
 // packages/cli/src/app-opentui/render/ascii-fleet.ts
 var LEAD_DRONE = [
@@ -2756,13 +2790,13 @@ 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 = RGBA3.fromValues(0, 0, 0, 0);
-var BACKDROP = RGBA3.fromHex(RIG_UI.bg);
-var PANEL_BG = RGBA3.fromInts(16, 17, 21, 184);
-var PANEL_HEADER_BG = RGBA3.fromInts(16, 17, 21, 188);
-var PANEL_LINE = RGBA3.fromInts(255, 255, 255, 20);
-var PANEL_LINE_DIM = RGBA3.fromInts(255, 255, 255, 8);
-var PANEL_TEXT_DIM = RGBA3.fromInts(108, 110, 121, 255);
+var TRANSPARENT = RGBA2.fromValues(0, 0, 0, 0);
+var BACKDROP = RGBA2.fromHex(RIG_UI.bg);
+var PANEL_BG = RGBA2.fromInts(16, 17, 21, 184);
+var PANEL_HEADER_BG = RGBA2.fromInts(16, 17, 21, 188);
+var PANEL_LINE = RGBA2.fromInts(255, 255, 255, 20);
+var PANEL_LINE_DIM = RGBA2.fromInts(255, 255, 255, 8);
+var PANEL_TEXT_DIM = RGBA2.fromInts(108, 110, 121, 255);
 var AC_RGB = [204, 255, 77];
 var C2_RGB = [86, 216, 255];
 var MG_RGB = [255, 121, 176];
@@ -2867,7 +2901,7 @@ function paletteColor(ac, c2, mg, ink) {
   const b = (AC_RGB[2] * ac + C2_RGB[2] * c2 + MG_RGB[2] * mg + INK_RGB[2] * ink) / total;
   const intensity = Math.min(1, total / 4);
   const lift = 0.34 + intensity * 0.66;
-  return RGBA3.fromInts(Math.round(r * lift), Math.round(g * lift), Math.round(b * lift), 255);
+  return RGBA2.fromInts(Math.round(r * lift), Math.round(g * lift), Math.round(b * lift), 255);
 }
 function clearCanvas(canvas) {
   canvas.ac.fill(0);
@@ -3222,8 +3256,8 @@ function staticFleetTick(scene) {
 }
 function withAlpha(hex, alpha) {
   const a = Math.max(0, Math.min(255, Math.round(alpha * 255)));
-  const [r, g, b] = RGBA3.fromHex(hex).toInts();
-  return RGBA3.fromInts(r, g, b, a);
+  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")
@@ -3231,7 +3265,7 @@ function asciiFleetColor(char, row, 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 RGBA3.fromInts(108, 110, 121, Math.min(170, Math.max(0, Math.min(255, Math.round(alpha * 255)))));
+    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);
 }
@@ -3344,7 +3378,7 @@ function sparklineString(values, width) {
 }
 
 // packages/cli/src/app-opentui/render/text.ts
-import { RGBA as RGBA4, TextAttributes as TextAttributes4, TextRenderable } from "@opentui/core";
+import { RGBA as RGBA3, TextAttributes as TextAttributes3, TextRenderable } from "@opentui/core";
 
 // packages/cli/src/app-opentui/render/hover.ts
 var hoveredId;
@@ -3371,8 +3405,8 @@ function subscribeHover(listener) {
 }
 
 // packages/cli/src/app-opentui/render/text.ts
-var TRANSPARENT2 = RGBA4.fromInts(0, 0, 0, 0);
-var HOVER_BG = RGBA4.fromHex(RIG_UI.hover);
+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;
 }
@@ -3381,7 +3415,7 @@ function lineSelectableId(line2) {
 }
 function lineBackground(line2) {
   if (line2?.bg)
-    return RGBA4.fromHex(line2.bg);
+    return RGBA3.fromHex(line2.bg);
   const id = lineSelectableId(line2);
   if (id !== undefined && isHovered(id))
     return HOVER_BG;
@@ -3450,7 +3484,7 @@ function applyTextLine(renderable, line2, top, left, width) {
   renderable.content = line2?.styledText ?? line2?.text ?? "";
   renderable.fg = line2?.fg ?? RIG_UI.ink2;
   renderable.bg = lineBackground(line2);
-  renderable.attributes = line2?.bold ? TextAttributes4.BOLD : line2?.dim ? TextAttributes4.DIM : 0;
+  renderable.attributes = line2?.bold ? TextAttributes3.BOLD : line2?.dim ? TextAttributes3.DIM : 0;
 }
 function applyFlowTextLine(renderable, line2, width) {
   renderable.setRigSceneLine?.(line2);
@@ -3460,7 +3494,7 @@ function applyFlowTextLine(renderable, line2, width) {
   renderable.content = line2?.styledText ?? line2?.text ?? "";
   renderable.fg = line2?.fg ?? RIG_UI.ink2;
   renderable.bg = lineBackground(line2);
-  renderable.attributes = line2?.bold ? TextAttributes4.BOLD : line2?.dim ? TextAttributes4.DIM : 0;
+  renderable.attributes = line2?.bold ? TextAttributes3.BOLD : line2?.dim ? TextAttributes3.DIM : 0;
 }
 function clearTextLines(renderables, from = 0) {
   for (let index = from;index < renderables.length; index += 1) {
@@ -3474,9 +3508,20 @@ function clearTextLines(renderables, from = 0) {
   }
 }
 
+// packages/cli/src/app-opentui/render/terminal-handoff.ts
+function resumeRendererClean(renderer) {
+  try {
+    renderer.pendingSuspendedTerminalSetup = true;
+  } catch {}
+  renderer.resume();
+  try {
+    renderer.requestRender?.();
+  } catch {}
+}
+
 // packages/cli/src/app-opentui/render/panels.ts
-import { RGBA as RGBA5, ScrollBoxRenderable } from "@opentui/core";
-var TRANSPARENT3 = RGBA5.fromInts(0, 0, 0, 0);
+import { RGBA as RGBA4, ScrollBoxRenderable } from "@opentui/core";
+var TRANSPARENT3 = RGBA4.fromInts(0, 0, 0, 0);
 var MAX_PANEL_LINES = 420;
 var PANEL_OPAQUE_ALPHA = 255;
 var PANEL_BORDER = hexToRgba(RIG_UI.border, 255);
@@ -3485,8 +3530,8 @@ function hexToRgba(hex, alpha) {
   const full = clean.length === 3 ? clean.split("").map((part) => `${part}${part}`).join("") : clean;
   const value = Number.parseInt(full, 16);
   if (!Number.isFinite(value))
-    return RGBA5.fromInts(14, 15, 17, alpha);
-  return RGBA5.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255, alpha);
+    return RGBA4.fromInts(14, 15, 17, alpha);
+  return RGBA4.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255, alpha);
 }
 function panelBackground(panel) {
   return hexToRgba(panel.backgroundColor ?? RIG_UI.panel, PANEL_OPAQUE_ALPHA);
@@ -3601,9 +3646,9 @@ function applyScrollPanels(panels, layout, scenePanels) {
 }
 
 // packages/cli/src/app-opentui/render/type-bar.ts
-import { BoxRenderable, InputRenderable, InputRenderableEvents, RGBA as RGBA6, StyledText as StyledText3, TextRenderable as TextRenderable2 } from "@opentui/core";
-var TYPEBAR_BG = RGBA6.fromInts(20, 25, 14, 224);
-var TYPEBAR_BORDER = RGBA6.fromInts(204, 255, 77, 92);
+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",
@@ -3751,7 +3796,7 @@ function formatFooter(footer, width) {
     chunks.push(cell.style(text));
     used += visibleWidth(text);
   });
-  return new StyledText3(chunks);
+  return new StyledText2(chunks);
 }
 
 // packages/cli/src/app-opentui/render/native-host.ts
@@ -3759,7 +3804,7 @@ import {
   BoxRenderable as BoxRenderable2,
   CodeRenderable,
   DiffRenderable,
-  RGBA as RGBA7,
+  RGBA as RGBA6,
   ScrollBoxRenderable as ScrollBoxRenderable2,
   SyntaxStyle,
   TextRenderable as TextRenderable3,
@@ -3770,19 +3815,19 @@ function rigSyntaxStyle() {
   if (syntaxStyle)
     return syntaxStyle;
   syntaxStyle = SyntaxStyle.fromStyles({
-    keyword: { fg: RGBA7.fromHex(RIG_UI.magenta), bold: true },
-    string: { fg: RGBA7.fromHex(RIG_UI.lime) },
-    number: { fg: RGBA7.fromHex(RIG_UI.cyan) },
-    comment: { fg: RGBA7.fromHex(RIG_UI.ink4), italic: true },
-    function: { fg: RGBA7.fromHex(RIG_UI.cyan) },
-    type: { fg: RGBA7.fromHex(RIG_UI.limeDim) },
-    constant: { fg: RGBA7.fromHex(RIG_UI.yellow) },
-    default: { fg: RGBA7.fromHex(RIG_UI.ink2) }
+    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: RGBA7.fromHex(rowIndex === 0 ? RIG_UI.ink3 : RIG_UI.ink2) }]));
+  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 {
@@ -3923,6 +3968,48 @@ function renderAsciiPreloaderFrame(scene, layout, tick) {
   };
 }
 
+// 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 };
@@ -3932,13 +4019,17 @@ function selectableDeckRow(deck, item) {
 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" } },
-  { detail: "repair project/server/auth link", item: { id: "repair", label: "repair", intent: { scene: "command", argv: ["init", "--repair"], action: { kind: "command-run", label: "Repair project link" } }, message: "repair project link" } }
+  { 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 selected = Math.max(0, Math.min(3, state.selection.index));
+  const actions = errorActions(state);
+  const selected = Math.max(0, Math.min(actions.length - 1, state.selection.index));
   return makeSceneFrame({
     scene: "error",
     title: "Error",
@@ -3956,7 +4047,7 @@ function renderErrorScene(state) {
         ...hint ? [line(hint, { fg: RIG_UI.yellow })] : [],
         line("", { fg: RIG_UI.ink3 }),
         line("ACTIONS", { fg: RIG_UI.ink3, bold: true }),
-        ...ERROR_ACTIONS.map(({ detail, item }, index) => selectableDeckRow({ label: item.label, detail, index, active: selected === index }, item))
+        ...actions.map(({ detail, item }, index) => selectableDeckRow({ label: item.label, detail, index, active: selected === index }, item))
       ],
       backgroundColor: RIG_UI.panel,
       backgroundAlpha: 184,
@@ -4084,7 +4175,7 @@ function renderHelpScene(state, layout) {
 
 // packages/cli/src/app-opentui/scenes/main.ts
 var CONFIGURED_MENU = [
-  ["init", "setup, reconfigure, repair project state", { id: "init", label: "init", intent: { scene: "command", argv: ["init"], action: { kind: "command-run", label: "Run init" } }, message: "run setup/reconfigure flow" }],
+  ["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" }],
@@ -4103,10 +4194,10 @@ var CONFIGURED_MENU = [
   ["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-setup",
-  label: "Start guided setup",
-  intent: { scene: "init", argv: ["init"], action: { kind: "refresh", label: "Setup" } },
-  message: "open the guided setup checklist"
+  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" }],
@@ -4169,7 +4260,7 @@ function configuredMenuRows(selectedIndex) {
   }));
 }
 function onboardingRows(selectedIndex) {
-  const primary = selectableDeckRow({ label: "setup", detail: "Start guided setup \u2014 recommended", active: selectedIndex === 0 }, ONBOARD_PRIMARY);
+  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
@@ -4233,7 +4324,7 @@ function renderMainScene(state, layout) {
     statusLine(state)
   ] : [
     line("WELCOME", { fg: RIG_UI.ink, bold: true }),
-    line("This project isn't set up yet. One guided flow gets you running.", { fg: RIG_UI.ink2 }),
+    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),
@@ -4268,11 +4359,17 @@ function renderMainScene(state, layout) {
   });
 }
 
+// packages/cli/src/app-opentui/pi-pty-host.ts
+function getActivePiHost() {
+  return null;
+}
+function stopActivePiHost(_reason) {}
+
 // packages/cli/src/app-opentui/runtime.ts
 var MAX_SCENE_LINES = 200;
 var MAX_SCENE_PANELS = 5;
 var ANIMATION_SLOWDOWN = 1;
-var PRELOADER_BACKDROP = RGBA8.fromHex(RIG_UI.bg);
+var PRELOADER_BACKDROP = RGBA7.fromHex(RIG_UI.bg);
 function inboxPendingCount(state) {
   const inbox = state.data.inbox;
   if (!inbox || typeof inbox !== "object" || Array.isArray(inbox))
@@ -4288,7 +4385,7 @@ var PRIMARY_NAV = [
   { id: "tasks", label: "Tasks", scene: "tasks", argv: ["tasks"], enterLabel: "Tasks", member: ["tasks"] },
   { id: "inbox", label: "Inbox", scene: "inbox", argv: ["inbox"], enterLabel: "Inbox", member: ["inbox"], badge: inboxPendingCount },
   { id: "stats", label: "Stats", scene: "family", argv: ["stats"], enterLabel: "Stats", member: ["family"] },
-  { id: "setup", label: "Setup", scene: "init", argv: ["init"], enterLabel: "Setup", member: ["init", "doctor", "server", "pi", "plugin", "repo", "workspace"] },
+  { id: "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) {
@@ -4328,7 +4425,7 @@ function entryIntentForScene(scene) {
     case "doctor":
       return { scene, argv: ["doctor"], action: { kind: "doctor-run", label: "Doctor" } };
     case "init":
-      return { scene, argv: ["init"], action: { kind: "refresh", label: "Setup" } };
+      return { scene, argv: ["init"], action: { kind: "refresh", label: "Init" } };
     case "run-detail":
       return { scene, argv: ["run", "status"], action: { kind: "refresh", label: "Run" } };
     case "pi":
@@ -4444,7 +4541,7 @@ function sceneSectionLabel(scene) {
     handoff: "pi console",
     server: "server",
     doctor: "doctor",
-    init: "setup",
+    init: "init",
     pi: "pi",
     plugin: "plugins",
     repo: "repo",
@@ -4477,7 +4574,7 @@ function buildNavStrip(state) {
       chunks.push(otuiBold(styles.yellow(String(badgeCount))));
     }
   });
-  return new StyledText4(chunks);
+  return new StyledText3(chunks);
 }
 function requestRender(renderer) {
   renderer.requestRender?.();
@@ -4706,7 +4803,8 @@ async function launchRigOpenTuiApp(options) {
     },
     suspend: () => renderer?.suspend(),
     resume: () => {
-      renderer?.resume();
+      if (renderer)
+        resumeRendererClean(renderer);
       renderApp();
     },
     destroy: () => renderer?.destroy()
@@ -4934,7 +5032,7 @@ async function launchRigOpenTuiApp(options) {
           }
           for (const adapter of options.adapters ?? [])
             await adapter.start?.(runtime);
-          liveEvents = await connectRigServerEvents(options.projectRoot, {
+          connectRigServerEvents(options.projectRoot, {
             onSnapshotInvalidated: () => refreshCurrentDataScene(),
             onRunLogAppended: () => {
               const scene = store.getState().scene;
@@ -4942,11 +5040,17 @@ async function launchRigOpenTuiApp(options) {
                 refreshCurrentDataScene();
             },
             onStatus: (status) => store.patch({ footer: { live: liveLinkLabel(status) } })
-          }).catch(() => null);
-          if (!liveEvents)
-            store.patch({ footer: { live: liveLinkLabel("disconnected") } });
-          if (liveEvents)
+          }).then((subscription) => {
+            if (destroyed) {
+              subscription.close();
+              return;
+            }
+            liveEvents = subscription;
             resources.add(() => liveEvents?.close());
+          }).catch(() => {
+            if (!destroyed)
+              store.patch({ footer: { live: liveLinkLabel("disconnected") } });
+          });
           await runtime.runIntent(store.getState().intent);
         } catch (error) {
           const normalized = normalizeError(error);