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

package/dist/src/commands/server.js

@@ -42,174 +42,16 @@ Usage: ${usage}`);
 }
 
 // packages/cli/src/commands/server.ts
-import { resolveRigServerCommand } from "@rig/runtime/local-server";
-
-// packages/cli/src/commands/_authority-runs.ts
 import {
-  readAuthorityRun,
-  readJsonlFile,
-  writeAuthorityRunRecord
-} from "@rig/runtime/control-plane/authority-files";
-
-// packages/cli/src/commands/_paths.ts
-import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
-
-// packages/cli/src/commands/_authority-runs.ts
-function normalizeRuntimeAdapter(value) {
-  const normalized = value?.trim().toLowerCase();
-  if (!normalized) {
-    return "pi";
-  }
-  if (normalized === "codex" || normalized === "codex-cli" || normalized === "codex-app-server" || normalized === "gpt-codex") {
-    return "codex";
-  }
-  if (normalized === "pi" || normalized === "rig-pi" || normalized === "@rig/pi") {
-    return "pi";
-  }
-  return "claude-code";
-}
-
-// packages/cli/src/app/drone-ui.ts
-import { ProcessTerminal, TUI, Text, Input, SelectList, matchesKey } from "@earendil-works/pi-tui";
-
-// packages/cli/src/app/theme.ts
-var RIG_PALETTE = {
-  ink: "#f2f3f6",
-  ink2: "#aeb0ba",
-  ink3: "#6c6e79",
-  ink4: "#44464f",
-  accent: "#ccff4d",
-  accentDim: "#a9d63f",
-  cyan: "#56d8ff",
-  red: "#ff5d5d",
-  yellow: "#ffd24d"
-};
-function hexToRgb(hex) {
-  const value = hex.replace("#", "");
-  return [
-    Number.parseInt(value.slice(0, 2), 16),
-    Number.parseInt(value.slice(2, 4), 16),
-    Number.parseInt(value.slice(4, 6), 16)
-  ];
-}
-function fg(hex) {
-  const [r, g, b] = hexToRgb(hex);
-  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[39m`;
-}
-var ink = fg(RIG_PALETTE.ink);
-var ink2 = fg(RIG_PALETTE.ink2);
-var ink3 = fg(RIG_PALETTE.ink3);
-var ink4 = fg(RIG_PALETTE.ink4);
-var accent = fg(RIG_PALETTE.accent);
-var accentDim = fg(RIG_PALETTE.accentDim);
-var cyan = fg(RIG_PALETTE.cyan);
-var red = fg(RIG_PALETTE.red);
-var yellow = fg(RIG_PALETTE.yellow);
-function bold(text) {
-  return `\x1B[1m${text}\x1B[22m`;
-}
-var DRONE_ART = [
-  "  .-=-.                   .-=-.   ",
-  " ( !!! )                 ( !!! )  ",
-  "  '-=-'._               _.'-=-'   ",
-  "        '._           _.'         ",
-  "           '=$$$$$$$=.'           ",
-  "          =$$$$$$$$$$$=           ",
-  "         $$$@@@@@@@@@@$$$         ",
-  "        $$$@@        @@$$$        ",
-  "        $$@    ?     @$$$         ",
-  "        $$$@   '-'   @$$$         ",
-  "        $$$@@        @@$$$        ",
-  "         $$$@@@@@@@@@@$$$         ",
-  "          =$$$$$$$$$$$=           ",
-  "           '=$$$$$$$=.'           ",
-  "        _.'           '._         ",
-  "  .-=-.'                 '.-=-.   ",
-  " ( !!! )                 ( !!! )  ",
-  "  '-=-'                   '-=-'   "
-];
-var EYE_FRAMES = ["@", "o", "."];
-var DRONE_WIDTH = DRONE_ART[0].length;
-var DRONE_HEIGHT = DRONE_ART.length;
-var MICRO_BLADES = ["---", "\\\\\\", "|||", "///"];
-function microDroneFrame(tick) {
-  const blade = MICRO_BLADES[tick % MICRO_BLADES.length];
-  const eye = EYE_FRAMES[Math.floor(tick / 2) % EYE_FRAMES.length];
-  return `(${blade})${eye}(${blade})`;
-}
-var MICRO_DRONE_FRAMES = Array.from({ length: 12 }, (_, index) => microDroneFrame(index));
-
-// packages/cli/src/app/drone-ui.ts
-var isTty = () => Boolean(process.stdout.isTTY);
-function droneCancel(text) {
-  console.log(` ${red("\u2716")} ${ink3(text)}`);
-}
-var SELECT_THEME = {
-  selectedPrefix: (text) => accent(text),
-  selectedText: (text) => bold(ink(text)),
-  description: (text) => ink3(text),
-  scrollInfo: (text) => ink4(text),
-  noMatch: (text) => ink3(text)
-};
-async function runMiniTui(build) {
-  const terminal = new ProcessTerminal;
-  const tui = new TUI(terminal);
-  let settled = false;
-  return await new Promise((resolve) => {
-    const finish = (result) => {
-      if (settled)
-        return;
-      settled = true;
-      tui.stop();
-      resolve(result);
-    };
-    build(tui, finish);
-    tui.start();
-  });
-}
-async function droneSelect(input) {
-  if (!isTty() || input.options.length === 0) {
-    return input.initialValue ?? input.options[0]?.value ?? null;
-  }
-  return runMiniTui((tui, finish) => {
-    tui.addChild(new Text(` ${accent("\u258D")}${bold(ink(input.message))}`));
-    const items = input.options.map((option) => ({
-      value: option.value,
-      label: option.label,
-      ...option.hint ? { description: option.hint } : {}
-    }));
-    const list = new SelectList(items, Math.min(items.length, 12), SELECT_THEME);
-    const initialIndex = input.initialValue ? items.findIndex((item) => item.value === input.initialValue) : -1;
-    if (initialIndex > 0)
-      list.setSelectedIndex(initialIndex);
-    list.onSelect = (item) => finish(item.value);
-    list.onCancel = () => finish(null);
-    tui.addChild(list);
-    tui.addChild(new Text(ink4(" \u2191\u2193 navigate \xB7 enter select \xB7 esc cancel")));
-    tui.setFocus(list);
-    tui.addInputListener((data) => {
-      if (matchesKey(data, "ctrl+c") || matchesKey(data, "escape")) {
-        finish(null);
-        return { consume: true };
-      }
-      return;
-    });
-  });
-}
+  listManagedRemoteEndpoints,
+  removeManagedRemoteEndpoint,
+  resolveSelectedRemote as resolveSelectedRemote2,
+  upsertManagedRemoteEndpoint
+} from "@rig/runtime/control-plane/remote";
 
 // 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");
 }
@@ -227,47 +69,6 @@ function writeJsonFile(path, value) {
   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 writeGlobalConnections(state, options = {}) {
-  writeJsonFile(resolveGlobalConnectionsPath(options.env ?? process.env), state);
-}
-function upsertGlobalConnection(alias, connection, options = {}) {
-  const cleanAlias = alias.trim();
-  if (!cleanAlias)
-    throw new CliError("Connection alias is required.", 1, { hint: "Save a server with `rig server add <alias> <url>`." });
-  const state = readGlobalConnections(options);
-  state.connections[cleanAlias] = connection;
-  writeGlobalConnections(state, options);
-  return state;
-}
 function readRepoConnection(projectRoot) {
   const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
   if (!payload || typeof payload !== "object" || Array.isArray(payload))
@@ -280,550 +81,167 @@ 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 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: repo.serverProjectRoot };
-}
-function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
-  const repo = readRepoConnection(projectRoot);
-  if (!repo)
-    return;
-  writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
+
+// packages/cli/src/commands/_run-bridge.ts
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { CUSTOM_TYPE_FOR, sessionIdFromSessionFile } from "@rig/contracts";
+import { createPluginHost } from "@rig/core";
+import { loadConfig } from "@rig/core/load-config";
+import { resolveOwnerNamespaceKey, resolveRegistryBaseUrl, resolveRegistrySecret, resolveSelectedRemote } from "@rig/runtime/control-plane/remote";
+import { listAgentRuntimes } from "@rig/runtime/control-plane/runtime/isolation";
+import { createRegistryClient } from "@rig/relay-registry";
+import {
+  listActiveCollabSessions as ompListActiveCollabSessions
+} from "@oh-my-pi/pi-coding-agent/collab/api";
+async function readSelectedTarget(projectRoot, env = process.env) {
+  const config = await loadConfig(resolve2(projectRoot));
+  const selected = resolveSelectedRemote(projectRoot, env);
+  return {
+    alias: selected?.alias ?? "local",
+    kind: selected ? "remote" : "local",
+    projectRoot,
+    status: "ready",
+    taskSource: config.taskSource.kind
+  };
 }
 
 // packages/cli/src/commands/_cli-format.ts
 import pc from "picocolors";
-var themeDim = (value) => ink3(value);
-var themeFaint = (value) => ink4(value);
-function truncate(value, width) {
-  if (value.length <= width)
-    return value;
-  if (width <= 1)
-    return "\u2026";
-  return `${value.slice(0, width - 1)}\u2026`;
-}
-function pad(value, width) {
-  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
-}
-function statusColor(status) {
-  const normalized = status.toLowerCase();
-  if (["completed", "merged", "closed", "done", "accepted", "pass", "selected", "approved", "running"].includes(normalized))
-    return accent;
-  if (["failed", "needs_attention", "needs-attention", "blocked", "error", "rejected"].includes(normalized))
-    return red;
-  if (["reviewing", "validating", "in_progress", "in-progress", "remote", "preparing", "closing-out"].includes(normalized))
-    return cyan;
-  if (["ready", "open", "queued", "created", "local", "pending"].includes(normalized))
-    return yellow;
-  return themeDim;
-}
-function formatStatusPill(status) {
-  const label = status || "unknown";
-  return statusColor(label)(`\u25CF ${label}`);
-}
-function formatSection(title, subtitle) {
-  return `${pc.bold(accent("\u25C6"))} ${pc.bold(title)}${subtitle ? themeDim(` \u2014 ${subtitle}`) : ""}`;
-}
-function formatSuccessCard(title, rows = []) {
-  const body = rows.filter(([, value]) => value !== undefined && value !== null && String(value).length > 0).map(([key, value]) => `${themeFaint("\u2502")} ${themeDim(key.padEnd(12))} ${value}`);
-  return [formatSection(title), ...body].join(`
-`);
-}
-function formatNextSteps(steps) {
-  if (steps.length === 0)
-    return [];
-  return [pc.bold("Next"), ...steps.map((step) => `${accent("\u203A")} ${step}`)];
-}
-function formatConnectionList(connections) {
-  const rows = [["local", { kind: "local", mode: "auto" }], ...Object.entries(connections)];
-  const aliasWidth = Math.min(24, Math.max(5, ...rows.map(([alias]) => alias.length)));
-  const lines = rows.map(([alias, connection]) => [
-    pc.bold(pad(truncate(alias, aliasWidth), aliasWidth)),
-    formatStatusPill(connection.kind),
-    connection.kind === "remote" ? connection.baseUrl ?? "" : connection.mode ?? "local"
-  ].join("  "));
-  return [formatSection("Rig servers", `${rows.length} available`), `${pc.bold(pad("ALIAS", aliasWidth))}  ${pc.bold("KIND")}  ${pc.bold("TARGET")}`, ...lines, "", ...formatNextSteps(["Select one: `rig server use <alias|local>`"])].join(`
-`);
-}
-function formatConnectionStatus(selected, connections) {
-  const connection = selected === "local" ? { kind: "local", mode: "auto" } : connections[selected];
-  const target = !connection ? "not configured" : connection.kind === "remote" ? connection.baseUrl : "local";
-  return [
-    formatSection("Rig server", "selected for this repo"),
-    `${themeFaint("\u2502")} ${themeDim("selected ")} ${pc.bold(selected)}`,
-    `${themeFaint("\u2502")} ${themeDim("kind     ")} ${formatStatusPill(connection?.kind ?? "unknown")}`,
-    `${themeFaint("\u2502")} ${themeDim("target   ")} ${target ?? "not configured"}`,
-    "",
-    ...formatNextSteps(["Change: `rig server use <alias|local>`", "List saved servers: `rig server list`"])
-  ].join(`
-`);
+var dim = pc.dim;
+var faintBar = pc.dim("\u2502");
+var accent = pc.cyan;
+function printFormattedOutput(message) {
+  console.log(message);
 }
 
-// packages/cli/src/commands/connect.ts
-function usageName(options) {
-  return `rig ${options.group}`;
-}
-function parseConnection(alias, value, options) {
-  if (alias === "local" && !value)
-    return { kind: "local", mode: "auto" };
-  if (!value)
-    throw new CliError(`Missing remote server URL. Usage: ${usageName(options)} add <alias> <url>`, 1);
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch {
-    throw new CliError(`Invalid Rig server URL: ${value}`, 1, { hint: "Pass a full http(s) URL, e.g. `rig server add prod https://rig.example.com`." });
-  }
-  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
-    throw new CliError("Rig remote server URL must be http(s).", 1, { hint: "Use an http:// or https:// URL, e.g. `rig server add prod https://rig.example.com`." });
-  }
-  return { kind: "remote", baseUrl: parsed.toString().replace(/\/+$/, "") };
-}
-function printJsonOrText(context, payload, text) {
-  if (context.outputMode === "json") {
-    console.log(JSON.stringify(payload, null, 2));
-  } else {
-    console.log(text);
-  }
-}
-async function promptForConnectionAlias(context) {
-  const state = readGlobalConnections();
-  const repo = readRepoConnection(context.projectRoot);
-  const options = [
-    { value: "local", label: "local", hint: "Use/start a local Rig server" },
-    ...Object.entries(state.connections).map(([alias, connection]) => ({
-      value: alias,
-      label: alias,
-      hint: connection.kind === "remote" ? connection.baseUrl : "local"
-    }))
-  ].filter((option, index, all) => all.findIndex((candidate) => candidate.value === option.value) === index);
-  const answer = await droneSelect({
-    message: "Select Rig server for this repo",
-    initialValue: repo?.selected ?? "local",
-    options
-  });
-  if (answer === null) {
-    droneCancel("No server selected.");
-    throw new CliError("No server selected.", 3);
-  }
-  return String(answer);
-}
-async function executeConnectionCommand(context, args, options) {
-  const [command, ...rest] = args;
-  switch (command ?? "status") {
-    case "list": {
-      requireNoExtraArgs(rest, `${usageName(options)} list`);
-      const state = readGlobalConnections();
-      printJsonOrText(context, state, formatConnectionList(state.connections));
-      return { ok: true, group: options.group, command: "list", details: state };
-    }
-    case "add": {
-      const [alias, url, ...extra] = rest;
-      if (!alias)
-        throw new CliError(`Missing alias. Usage: ${usageName(options)} add <alias> <url>`, 1);
-      requireNoExtraArgs(extra, `${usageName(options)} add <alias> <url>`);
-      const connection = parseConnection(alias, url, options);
-      const state = upsertGlobalConnection(alias, connection);
-      printJsonOrText(context, { alias, connection }, formatSuccessCard("Rig server saved", [
-        ["alias", alias],
-        ["target", connection.kind === "remote" ? connection.baseUrl : "local"],
-        ["next", `${usageName(options)} use ${alias}`]
-      ]));
-      return { ok: true, group: options.group, command: "add", details: { alias, connection, count: Object.keys(state.connections).length } };
-    }
-    case "use": {
-      let [alias, ...extra] = rest;
-      requireNoExtraArgs(extra, `${usageName(options)} use <alias|local>`);
-      if (!alias && options.interactiveUse && context.outputMode === "text" && process.stdin.isTTY) {
-        alias = await promptForConnectionAlias(context);
-      }
-      if (!alias)
-        throw new CliError(`Missing alias. Usage: ${usageName(options)} use <alias|local>`, 1);
-      if (alias !== "local") {
-        const state = readGlobalConnections();
-        if (!state.connections[alias])
-          throw new CliError(`Unknown Rig server: ${alias}`, 1, { hint: "Run `rig server list` to see saved aliases, or save one with `rig server add <alias> <url>`." });
-      }
-      const repoState = { selected: alias, linkedAt: new Date().toISOString() };
-      writeRepoConnection(context.projectRoot, repoState);
-      printJsonOrText(context, repoState, formatSuccessCard("Rig server selected", [
-        ["selected", alias],
-        ["scope", "this repo"],
-        ["next", "rig task list"]
-      ]));
-      return { ok: true, group: options.group, command: "use", details: repoState };
-    }
+// packages/cli/src/commands/server.ts
+var DEFAULT_REMOTE_PORT = 22;
+async function executeServer(context, args) {
+  const [command = "status", ...rest] = args;
+  const text = context.outputMode === "text";
+  const projectRoot = context.projectRoot;
+  switch (command) {
     case "status": {
-      requireNoExtraArgs(rest, `${usageName(options)} status`);
-      const repo = readRepoConnection(context.projectRoot);
-      const global = readGlobalConnections();
-      const details = { selected: repo?.selected ?? "local", repo, connections: global.connections };
-      printJsonOrText(context, details, formatConnectionStatus(details.selected, global.connections));
-      return { ok: true, group: options.group, command: "status", details };
-    }
-    default:
-      throw new CliError(`Unknown ${options.group} command: ${String(command)}
-Usage: ${usageName(options)} <list|add|use|status>`, 1);
-  }
-}
-
-// packages/cli/src/commands/_server-client.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
-import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
-var scopedGitHubBearerTokens = new Map;
-var serverPhaseListener = null;
-function reportServerPhase(label) {
-  serverPhaseListener?.(label);
-}
-function cleanToken(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : null;
-}
-function readPrivateRemoteSessionToken(projectRoot) {
-  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
-  if (!existsSync2(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined);
-  } catch {
-    return 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 path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
-  if (!existsSync2(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return cleanToken(typeof parsed.token === "string" ? parsed.token : undefined);
-  } catch {
-    return null;
-  }
-}
-function readLocalConnectionFallbackToken(projectRoot) {
-  return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
-}
-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 ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
+      requireNoExtraArgs(rest, "rig server status");
+      const target = await readSelectedTarget(projectRoot);
+      const remote = resolveSelectedRemote2(projectRoot);
+      if (text) {
+        printFormattedOutput(target.kind === "local" ? "Placement: local (runs execute on this machine)." : `Placement: remote \u2192 ${target.alias}${remote ? ` (${remote.host}:${remote.port})` : ""}`);
+        printFormattedOutput(`Task source: ${target.taskSource}`);
+      }
       return {
-        baseUrl: selected.connection.baseUrl,
-        authToken,
-        connectionKind: "remote",
-        serverProjectRoot
+        ok: true,
+        group: "server",
+        command,
+        details: {
+          placement: target.kind,
+          alias: target.alias,
+          taskSource: target.taskSource,
+          ...remote ? { host: remote.host, port: remote.port } : {}
+        }
       };
     }
-    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;
-  }
-}
-async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken) {
-  const repo = readRepoConnection(projectRoot);
-  const slug = repo?.project?.trim();
-  if (!slug)
-    return null;
-  try {
-    const response = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`, {
-      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 mergeHeaders(headers, authToken) {
-  const merged = new Headers(headers);
-  if (authToken) {
-    merged.set("authorization", `Bearer ${authToken}`);
-  }
-  return merged;
-}
-function diagnosticMessage(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const record = payload;
-  const diagnostics = Array.isArray(record.diagnostics) ? record.diagnostics : [];
-  const messages = diagnostics.flatMap((entry) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry))
-      return [];
-    const diagnostic = entry;
-    const kind = typeof diagnostic.kind === "string" ? diagnostic.kind : "task-source";
-    const message = typeof diagnostic.message === "string" ? diagnostic.message : null;
-    return message ? [`${kind}: ${message}`] : [];
-  });
-  return messages.length > 0 ? messages.join("; ") : null;
-}
-var serverReachabilityCache = new Map;
-async function probeServerReachability(baseUrl, authToken) {
-  try {
-    const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/api/server/status`, {
-      headers: mergeHeaders(undefined, authToken),
-      signal: AbortSignal.timeout(1500)
-    });
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
-function cachedServerReachability(projectRoot, baseUrl, authToken) {
-  const key = resolve2(projectRoot);
-  const cached = serverReachabilityCache.get(key);
-  if (cached)
-    return cached;
-  const probe = probeServerReachability(baseUrl, authToken);
-  serverReachabilityCache.set(key, probe);
-  return probe;
-}
-function describeSelectedServer(projectRoot, server) {
-  try {
-    const selected = resolveSelectedConnection(projectRoot);
-    if (selected) {
+    case "list": {
+      requireNoExtraArgs(rest, "rig server list");
+      const endpoints = listManagedRemoteEndpoints(undefined, projectRoot);
+      const selected = readRepoConnection(projectRoot)?.selected ?? "local";
+      if (text) {
+        printFormattedOutput(`${selected === "local" ? "* " : "  "}local \u2014 runs execute on this machine`);
+        if (endpoints.length === 0) {
+          printFormattedOutput("  (no remote endpoints; add one with `rig server add --alias <a> --host <h>`)");
+        }
+        for (const endpoint of endpoints) {
+          printFormattedOutput(`${selected === endpoint.alias ? "* " : "  "}${endpoint.alias} \u2014 ${endpoint.host}:${endpoint.port}`);
+        }
+      }
       return {
-        alias: selected.alias,
-        target: selected.connection.kind === "remote" ? selected.connection.baseUrl : server.baseUrl
+        ok: true,
+        group: "server",
+        command,
+        details: { selected, endpoints: endpoints.map((e) => ({ alias: e.alias, host: e.host, port: e.port })) }
       };
     }
-  } catch {}
-  return { alias: server.connectionKind === "remote" ? "remote" : "local", target: server.baseUrl };
-}
-async function buildServerFailureContext(projectRoot, server) {
-  const { alias, target } = describeSelectedServer(projectRoot, server);
-  const reachable = await cachedServerReachability(projectRoot, server.baseUrl, server.authToken);
-  const reachability = reachable ? "server is reachable" : "server is unreachable";
-  return {
-    contextLine: `Currently connected to: ${alias} at ${target} (${reachability}).`,
-    hint: "Check the selected server with `rig server status`, or switch with `rig server use <alias|local>`."
-  };
-}
-async function requestServerJson(context, pathname, init = {}) {
-  const server = await ensureServerForCli(context.projectRoot);
-  const headers = mergeHeaders(init.headers, server.authToken);
-  if (server.serverProjectRoot)
-    headers.set("x-rig-project-root", server.serverProjectRoot);
-  reportServerPhase(`${(init.method ?? "GET").toUpperCase()} ${pathname.split("?")[0]}\u2026`);
-  let response;
-  try {
-    response = await fetch(`${server.baseUrl}${pathname}`, {
-      ...init,
-      headers
-    });
-  } catch (error) {
-    const failure = await buildServerFailureContext(context.projectRoot, server);
-    throw new CliError(`Rig server request failed: ${error instanceof Error ? error.message : String(error)}
-${failure.contextLine}`, 1, { hint: failure.hint });
-  }
-  const text = await response.text();
-  const payload = text.trim().length > 0 ? (() => {
-    try {
-      return JSON.parse(text);
-    } catch {
-      return null;
-    }
-  })() : null;
-  if (!response.ok) {
-    const diagnostics = diagnosticMessage(payload);
-    const rawDetail = diagnostics ?? (text || response.statusText);
-    const detail = diagnostics ? rawDetail : rawDetail.split(`
-`).map((line) => line.trim()).find((line) => line.length > 0)?.slice(0, 200) ?? response.statusText;
-    const failure = await buildServerFailureContext(context.projectRoot, server);
-    throw new CliError(`Rig server request failed (${response.status}): ${detail}
-${failure.contextLine}`, 1, { hint: failure.hint });
-  }
-  return payload;
-}
-var RESUMABLE_RUN_STATUSES = new Set([
-  "created",
-  "preparing",
-  "running",
-  "validating",
-  "reviewing",
-  "stopped",
-  "failed",
-  "needs-attention",
-  "needs_attention"
-]);
-async function submitTaskRunViaServer(context, input) {
-  const isTaskRun = Boolean(input.taskId);
-  const endpoint = isTaskRun ? "/api/runs/task" : "/api/runs/adhoc";
-  const payload = await requestServerJson(context, endpoint, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json"
-    },
-    body: JSON.stringify({
-      runId: input.runId,
-      taskId: input.taskId,
-      title: input.title,
-      runtimeAdapter: input.runtimeAdapter,
-      model: input.model,
-      runtimeMode: input.runtimeMode,
-      interactionMode: input.interactionMode,
-      initialPrompt: input.initialPrompt,
-      baselineMode: input.baselineMode,
-      prMode: input.prMode,
-      executionTarget: "local"
-    })
-  });
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    throw new CliError("Rig server returned an invalid run submission payload.", 1, { hint: "Check `rig server status` and retry; `rig run list` shows whether the run was created anyway." });
-  }
-  const runId = payload.runId;
-  if (typeof runId !== "string" || runId.trim().length === 0) {
-    throw new CliError("Rig server returned no runId for the submitted run.", 1, { hint: "Check `rig run list` \u2014 the run may still have been created; otherwise retry the submission." });
-  }
-  return { runId };
-}
-
-// packages/cli/src/commands/server.ts
-async function executeServer(context, args, options) {
-  const [command = "status", ...rest] = args;
-  if (["status", "list", "add", "use"].includes(command)) {
-    return executeConnectionCommand(context, [command, ...rest], { group: "server", interactiveUse: true });
-  }
-  switch (command) {
-    case "start": {
-      let pending = rest;
-      const hostResult = takeOption(pending, "--host");
-      pending = hostResult.rest;
-      const portResult = takeOption(pending, "--port");
-      pending = portResult.rest;
-      const pollResult = takeOption(pending, "--poll-ms");
-      pending = pollResult.rest;
-      const authTokenResult = takeOption(pending, "--auth-token");
-      pending = authTokenResult.rest;
-      requireNoExtraArgs(pending, "rig server start [--host <host>] [--port <n>] [--poll-ms <n>] [--auth-token <token>]");
-      const serverCommand = resolveRigServerCommand(context.projectRoot);
-      const commandParts = [serverCommand.command, ...serverCommand.commandArgs, "start"];
-      if (hostResult.value) {
-        commandParts.push("--host", hostResult.value);
-      }
-      if (portResult.value) {
-        commandParts.push("--port", portResult.value);
-      }
-      if (pollResult.value) {
-        commandParts.push("--poll-ms", pollResult.value);
-      }
-      if (authTokenResult.value) {
-        commandParts.push("--auth-token", authTokenResult.value);
+    case "use": {
+      const [aliasArg, ...extra] = rest;
+      requireNoExtraArgs(extra, "rig server use <local|alias>");
+      const alias = (aliasArg ?? "").trim();
+      if (!alias) {
+        throw new CliError("rig server use requires a target.", 2, { hint: "rig server use local  |  rig server use <alias>" });
       }
-      await context.runCommand(commandParts);
-      return { ok: true, group: "server", command };
-    }
-    case "events":
-      throw new CliError("server events is not supported by the CLI wrapper. Use `rig inspector stream` for bounded event streaming, or start the server with `rig server start`.", 2);
-    case "notify-test": {
-      let pending = rest;
-      const eventResult = takeOption(pending, "--event");
-      pending = eventResult.rest;
-      requireNoExtraArgs(pending, "rig server notify-test [--event <type>]");
-      const serverCommand = resolveRigServerCommand(context.projectRoot);
-      const commandParts = [serverCommand.command, ...serverCommand.commandArgs, "notify-test"];
-      if (eventResult.value) {
-        commandParts.push("--event", eventResult.value);
+      if (alias !== "local") {
+        const known = listManagedRemoteEndpoints(undefined, projectRoot).some((endpoint) => endpoint.alias === alias);
+        if (!known) {
+          throw new CliError(`Unknown remote endpoint: ${alias}`, 2, {
+            hint: "Run `rig server list`, or add it with `rig server add --alias <a> --host <h>`."
+          });
+        }
       }
-      await context.runCommand(commandParts);
-      return { ok: true, group: "server", command, details: { event: eventResult.value || "manual.test" } };
+      if (context.dryRun)
+        return { ok: true, group: "server", command, details: { selected: alias, dryRun: true } };
+      const prev = readRepoConnection(projectRoot);
+      writeRepoConnection(projectRoot, { ...prev ?? { selected: "local" }, selected: alias });
+      if (text)
+        printFormattedOutput(alias === "local" ? "Placement set to local." : `Placement set to remote \u2192 ${alias}.`);
+      return { ok: true, group: "server", command, details: { selected: alias } };
     }
-    case "task-run": {
-      let pending = rest;
-      const taskResult = takeOption(pending, "--task");
-      pending = taskResult.rest;
-      const titleResult = takeOption(pending, "--title");
-      pending = titleResult.rest;
-      const runtimeAdapterResult = takeOption(pending, "--runtime-adapter");
-      pending = runtimeAdapterResult.rest;
-      const modelResult = takeOption(pending, "--model");
-      pending = modelResult.rest;
-      const runtimeModeResult = takeOption(pending, "--runtime-mode");
-      pending = runtimeModeResult.rest;
-      const interactionModeResult = takeOption(pending, "--interaction-mode");
-      pending = interactionModeResult.rest;
-      const initialPromptResult = takeOption(pending, "--initial-prompt");
-      pending = initialPromptResult.rest;
-      const dirtyBaselineResult = takeOption(pending, "--dirty-baseline");
-      pending = dirtyBaselineResult.rest;
-      const prResult = takeOption(pending, "--pr");
-      pending = prResult.rest;
-      requireNoExtraArgs(pending, "rig --run-id <run-id> server task-run [--task <id>] [--title <text>] [--runtime-adapter claude-code|codex|pi] [--model <model>] [--runtime-mode <mode>] [--interaction-mode <mode>] [--initial-prompt <text>] [--dirty-baseline head|dirty-snapshot] [--pr auto|ask|off]");
-      if (!taskResult.value && !initialPromptResult.value && !titleResult.value) {
-        throw new CliError("server task-run requires either --task <id> or --initial-prompt/--title for an ad hoc run.", 2);
+    case "add": {
+      const aliasOpt = takeOption(rest, "--alias");
+      const hostOpt = takeOption(aliasOpt.rest, "--host");
+      const portOpt = takeOption(hostOpt.rest, "--port");
+      const tokenOpt = takeOption(portOpt.rest, "--token");
+      const positional = tokenOpt.rest.filter((arg) => !arg.startsWith("-"));
+      const alias = (aliasOpt.value ?? positional[0] ?? "").trim();
+      const host = (hostOpt.value ?? positional[1] ?? "").trim();
+      const portRaw = portOpt.value ?? positional[2];
+      if (!alias || !host) {
+        throw new CliError("rig server add requires --alias <a> and --host <h>.", 2, {
+          hint: "rig server add --alias prod --host prod.example.com --port 22"
+        });
       }
-      const input = {
-        runId: context.runId,
-        taskId: taskResult.value ?? undefined,
-        title: titleResult.value ?? undefined,
-        runtimeAdapter: normalizeRuntimeAdapter(runtimeAdapterResult.value),
-        model: modelResult.value ?? undefined,
-        runtimeMode: runtimeModeResult.value || "full-access",
-        interactionMode: interactionModeResult.value || "default",
-        initialPrompt: initialPromptResult.value ?? undefined,
-        baselineMode: dirtyBaselineResult.value === "dirty-snapshot" ? "dirty-snapshot" : "head",
-        prMode: prResult.value === "auto" || prResult.value === "ask" || prResult.value === "off" ? prResult.value : undefined
-      };
-      if (process.env.RIG_SERVER_INTERNAL_EXEC === "1") {
-        await options.executeRigOwnedTaskRun(context, input);
-      } else {
-        await submitTaskRunViaServer(context, input);
+      const port = portRaw ? Number(portRaw) : DEFAULT_REMOTE_PORT;
+      if (!Number.isFinite(port))
+        throw new CliError(`Invalid --port: ${portRaw}`, 2);
+      if (context.dryRun)
+        return { ok: true, group: "server", command, details: { alias, host, port, dryRun: true } };
+      const saved = upsertManagedRemoteEndpoint({ alias, host, port, ...tokenOpt.value ? { token: tokenOpt.value } : {} }, undefined, projectRoot);
+      if (text) {
+        printFormattedOutput(`Saved remote endpoint ${saved.alias} \u2192 ${saved.host}:${saved.port}. Select it with \`rig server use ${saved.alias}\`.`);
       }
-      return {
-        ok: true,
-        group: "server",
-        command,
-        details: { runId: context.runId, taskId: taskResult.value ?? null, title: titleResult.value ?? null }
-      };
+      return { ok: true, group: "server", command, details: { alias: saved.alias, host: saved.host, port: saved.port } };
+    }
+    case "remove": {
+      const [aliasArg, ...extra] = rest;
+      requireNoExtraArgs(extra, "rig server remove <alias>");
+      const alias = (aliasArg ?? "").trim();
+      if (!alias)
+        throw new CliError("rig server remove requires an alias.", 2);
+      if (context.dryRun)
+        return { ok: true, group: "server", command, details: { alias, dryRun: true } };
+      const removed = removeManagedRemoteEndpoint(alias, undefined, projectRoot);
+      if (text)
+        printFormattedOutput(removed ? `Removed remote endpoint ${alias}.` : `No remote endpoint named ${alias}.`);
+      return { ok: removed, group: "server", command, details: { alias, removed } };
     }
+    case "start":
+      throw new CliError("rig server start is retired: there is no standalone Rig server process after the OMP migration.", 2, {
+        hint: "Runs execute locally (tmux) or on a selected remote \u2014 pick one with `rig server use local|<alias>`."
+      });
+    case "repair-link":
+      throw new CliError("rig server repair-link is retired with the standalone server.", 2, {
+        hint: "Select placement with `rig server use local|<alias>`."
+      });
     default:
-      throw new CliError(`Unknown server command: ${command}`, 1, { hint: "Run `rig server --help` \u2014 primary commands are status|list|add|use|start." });
+      throw new CliError(`Unknown server command: ${command}`, 1, {
+        hint: "Run `rig server --help` \u2014 commands are status|list|use|add|remove."
+      });
   }
 }
 export {