@h-rig/cli 0.0.6-alpha.80 → 0.0.6-alpha.81

package/dist/src/app-opentui/adapters/inbox.js

@@ -0,0 +1,1454 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+var CliError;
+var init_runner = __esm(() => {
+  CliError = class CliError extends RuntimeCliError {
+    hint;
+    constructor(message, exitCode = 1, options = {}) {
+      super(message, exitCode);
+      if (options.hint?.trim()) {
+        this.hint = options.hint.trim();
+      }
+    }
+  };
+});
+
+// packages/cli/src/app/theme.ts
+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`;
+}
+function bold(text) {
+  return `\x1B[1m${text}\x1B[22m`;
+}
+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})`;
+}
+function renderMicroDroneFrame(tick) {
+  const blade = MICRO_BLADES[tick % MICRO_BLADES.length];
+  const eye = EYE_FRAMES[Math.floor(tick / 2) % EYE_FRAMES.length];
+  return `${ink4("(")}${cyan(blade)}${ink4(")")}${bold(accent(eye))}${ink4("(")}${cyan(blade)}${ink4(")")}`;
+}
+var RIG_PALETTE, ink, ink2, ink3, ink4, accent, accentDim, cyan, red, yellow, DRONE_ART, EYE_FRAMES, DRONE_WIDTH, DRONE_HEIGHT, MICRO_BLADES, MICRO_DRONE_FRAMES;
+var init_theme = __esm(() => {
+  RIG_PALETTE = {
+    ink: "#f2f3f6",
+    ink2: "#aeb0ba",
+    ink3: "#6c6e79",
+    ink4: "#44464f",
+    accent: "#ccff4d",
+    accentDim: "#a9d63f",
+    cyan: "#56d8ff",
+    red: "#ff5d5d",
+    yellow: "#ffd24d"
+  };
+  ink = fg(RIG_PALETTE.ink);
+  ink2 = fg(RIG_PALETTE.ink2);
+  ink3 = fg(RIG_PALETTE.ink3);
+  ink4 = fg(RIG_PALETTE.ink4);
+  accent = fg(RIG_PALETTE.accent);
+  accentDim = fg(RIG_PALETTE.accentDim);
+  cyan = fg(RIG_PALETTE.cyan);
+  red = fg(RIG_PALETTE.red);
+  yellow = fg(RIG_PALETTE.yellow);
+  DRONE_ART = [
+    "  .-=-.                   .-=-.   ",
+    " ( !!! )                 ( !!! )  ",
+    "  '-=-'._               _.'-=-'   ",
+    "        '._           _.'         ",
+    "           '=$$$$$$$=.'           ",
+    "          =$$$$$$$$$$$=           ",
+    "         $$$@@@@@@@@@@$$$         ",
+    "        $$$@@        @@$$$        ",
+    "        $$@    ?     @$$$         ",
+    "        $$$@   '-'   @$$$         ",
+    "        $$$@@        @@$$$        ",
+    "         $$$@@@@@@@@@@$$$         ",
+    "          =$$$$$$$$$$$=           ",
+    "           '=$$$$$$$=.'           ",
+    "        _.'           '._         ",
+    "  .-=-.'                 '.-=-.   ",
+    " ( !!! )                 ( !!! )  ",
+    "  '-=-'                   '-=-'   "
+  ];
+  EYE_FRAMES = ["@", "o", "."];
+  DRONE_WIDTH = DRONE_ART[0].length;
+  DRONE_HEIGHT = DRONE_ART.length;
+  MICRO_BLADES = ["---", "\\\\\\", "|||", "///"];
+  MICRO_DRONE_FRAMES = Array.from({ length: 12 }, (_, index) => microDroneFrame(index));
+});
+
+// packages/cli/src/commands/_spinner.ts
+function createTtySpinner(input) {
+  const output = input.output ?? process.stdout;
+  const isTty = output.isTTY === true;
+  const frames = input.frames && input.frames.length > 0 ? input.frames : SPINNER_FRAMES;
+  let label = input.label;
+  let frame = 0;
+  let paused = false;
+  let stopped = false;
+  let lastPrintedLabel = "";
+  const render = () => {
+    if (stopped || paused)
+      return;
+    if (!isTty) {
+      if (label !== lastPrintedLabel) {
+        output.write(`${label}
+`);
+        lastPrintedLabel = label;
+      }
+      return;
+    }
+    frame = (frame + 1) % frames.length;
+    const glyph = frames[frame] ?? frames[0] ?? "";
+    output.write(`\r\x1B[2K${input.styleFrame ? input.styleFrame(glyph) : glyph} ${label}`);
+  };
+  const clearLine = () => {
+    if (isTty)
+      output.write("\r\x1B[2K");
+  };
+  render();
+  const timer = isTty ? setInterval(render, input.intervalMs ?? 16) : null;
+  return {
+    setLabel(next) {
+      label = next;
+      render();
+    },
+    pause() {
+      paused = true;
+      clearLine();
+    },
+    resume() {
+      if (stopped)
+        return;
+      paused = false;
+      render();
+    },
+    stop(finalLine) {
+      if (stopped)
+        return;
+      stopped = true;
+      if (timer)
+        clearInterval(timer);
+      clearLine();
+      if (finalLine)
+        output.write(`${finalLine}
+`);
+    }
+  };
+}
+var SPINNER_FRAMES;
+var init__spinner = __esm(() => {
+  SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+});
+
+// packages/cli/src/app/drone-ui.ts
+import { ProcessTerminal, TUI, Text, Input, SelectList, matchesKey } from "@earendil-works/pi-tui";
+function droneNote(message, title) {
+  if (title)
+    console.log(` ${accentDim("\u25C7")} ${bold(ink2(title))}`);
+  for (const line of message.split(`
+`)) {
+    console.log(` ${ink4("\u2502")} ${line}`);
+  }
+}
+var init_drone_ui = __esm(() => {
+  init_theme();
+  init__spinner();
+});
+
+// packages/cli/src/commands/_cli-format.ts
+import pc from "picocolors";
+function stringField2(record, key, fallback = "") {
+  const value = record[key];
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+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 firstString(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = stringField2(record, key);
+    if (value)
+      return value;
+  }
+  return fallback;
+}
+function requestIdOf(entry) {
+  return firstString(entry, ["requestId", "id", "approvalId", "inputId"], "(unknown-request)");
+}
+function shouldUseClackOutput() {
+  return Boolean(process.stdout.isTTY) && process.env.RIG_CLI_PLAIN_HELP !== "1";
+}
+function printFormattedOutput(message, options = {}) {
+  if (!shouldUseClackOutput()) {
+    console.log(message);
+    return;
+  }
+  droneNote(message, options.title);
+}
+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 formatNextSteps(steps) {
+  if (steps.length === 0)
+    return [];
+  return [pc.bold("Next"), ...steps.map((step) => `${accent("\u203A")} ${step}`)];
+}
+function formatInboxList(kind, entries) {
+  const title = kind === "approvals" ? "Approval inbox" : "Input inbox";
+  if (entries.length === 0) {
+    return [
+      formatSection(title, "empty"),
+      themeDim(kind === "approvals" ? "No pending approvals." : "No pending user-input requests."),
+      "",
+      ...formatNextSteps(["Check runs: `rig run status`", "Start work: `rig task run --next`"])
+    ].join(`
+`);
+  }
+  const lines = [formatSection(title, `${entries.length} pending`)];
+  for (const entry of entries) {
+    const record = entry.record && typeof entry.record === "object" && !Array.isArray(entry.record) ? entry.record : entry;
+    const runId = firstString(entry, ["runId"], firstString(record, ["runId"]));
+    const taskId = firstString(entry, ["taskId"], firstString(record, ["taskId", "task"]));
+    const requestId = requestIdOf(record);
+    const status = firstString(record, ["status", "state"], "pending");
+    const prompt = firstString(record, ["prompt", "message", "reason", "title", "summary"], kind === "approvals" ? "Approval requested" : "Input requested");
+    lines.push(`${themeFaint("\u2502")} ${pc.bold(requestId)} ${formatStatusPill(status)} ${prompt}`);
+    lines.push(`${themeFaint("\u2502")} ${themeDim("run      ")} ${runId || "(unknown-run)"}${taskId ? themeDim(`  task ${taskId}`) : ""}`);
+  }
+  lines.push("", ...formatNextSteps(kind === "approvals" ? ["Resolve: `rig inbox approve --run <run-id> --request <request-id> --decision approve|reject`", "Rejoin: `rig run attach <run-id> --follow`"] : ["Respond: `rig inbox respond --run <run-id> --request <request-id> --answer key=value`", "Rejoin: `rig run attach <run-id> --follow`"]));
+  return lines.join(`
+`);
+}
+var themeDim = (value) => ink3(value), themeFaint = (value) => ink4(value);
+var init__cli_format = __esm(() => {
+  init_drone_ui();
+  init_theme();
+});
+
+// packages/cli/src/commands/_connection-state.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+function resolveGlobalConnectionsPath(env = process.env) {
+  const explicit = env.RIG_CONNECTIONS_FILE?.trim();
+  if (explicit)
+    return resolve(explicit);
+  const stateDir = env.RIG_GLOBAL_STATE_DIR?.trim();
+  if (stateDir)
+    return resolve(stateDir, "connections.json");
+  return resolve(homedir(), ".rig", "connections.json");
+}
+function resolveRepoConnectionPath(projectRoot) {
+  return resolve(projectRoot, ".rig", "state", "connection.json");
+}
+function readJsonFile(path) {
+  if (!existsSync(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new CliError(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1, { hint: "Fix or delete that file, then re-select a server with `rig server use <alias|local>`." });
+  }
+}
+function writeJsonFile(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function normalizeConnection(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = value;
+  if (record.kind === "local")
+    return { kind: "local", mode: "auto" };
+  if (record.kind === "remote" && typeof record.baseUrl === "string" && record.baseUrl.trim()) {
+    const baseUrl = record.baseUrl.trim().replace(/\/+$/, "");
+    return { kind: "remote", baseUrl };
+  }
+  return null;
+}
+function readGlobalConnections(options = {}) {
+  const path = resolveGlobalConnectionsPath(options.env ?? process.env);
+  const payload = readJsonFile(path);
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return { connections: {} };
+  }
+  const rawConnections = payload.connections;
+  const connections = {};
+  if (rawConnections && typeof rawConnections === "object" && !Array.isArray(rawConnections)) {
+    for (const [alias, raw] of Object.entries(rawConnections)) {
+      const connection = normalizeConnection(raw);
+      if (connection)
+        connections[alias] = connection;
+    }
+  }
+  return { connections };
+}
+function readRepoConnection(projectRoot) {
+  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
+  if (!selected)
+    return null;
+  return {
+    selected,
+    project: typeof record.project === "string" ? record.project : undefined,
+    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
+    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined
+  };
+}
+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 });
+}
+var init__connection_state = __esm(() => {
+  init_runner();
+});
+
+// packages/cli/src/commands/_server-client.ts
+var exports__server_client = {};
+__export(exports__server_client, {
+  updateWorkspaceTaskViaServer: () => updateWorkspaceTaskViaServer,
+  switchServerProjectRootViaServer: () => switchServerProjectRootViaServer,
+  submitTaskRunViaServer: () => submitTaskRunViaServer,
+  stopRunViaServer: () => stopRunViaServer,
+  steerRunViaServer: () => steerRunViaServer,
+  setServerPhaseListener: () => setServerPhaseListener,
+  setGitHubBearerTokenForCurrentProcess: () => setGitHubBearerTokenForCurrentProcess,
+  sendRunPiShellViaServer: () => sendRunPiShellViaServer,
+  sendRunPiPromptViaServer: () => sendRunPiPromptViaServer,
+  selectNextWorkspaceTaskViaServer: () => selectNextWorkspaceTaskViaServer,
+  runRunPiCommandViaServer: () => runRunPiCommandViaServer,
+  resumeRunViaServer: () => resumeRunViaServer,
+  respondRunPiExtensionUiViaServer: () => respondRunPiExtensionUiViaServer,
+  resolveServerConnectionLabel: () => resolveServerConnectionLabel,
+  requestServerJson: () => requestServerJson,
+  registerProjectViaServer: () => registerProjectViaServer,
+  prepareRemoteCheckoutViaServer: () => prepareRemoteCheckoutViaServer,
+  postGitHubTokenViaServer: () => postGitHubTokenViaServer,
+  listWorkspaceTasksViaServer: () => listWorkspaceTasksViaServer,
+  listRunsViaServer: () => listRunsViaServer,
+  listGitHubProjectsViaServer: () => listGitHubProjectsViaServer,
+  getWorkspaceTaskViaServer: () => getWorkspaceTaskViaServer,
+  getRunTimelineViaServer: () => getRunTimelineViaServer,
+  getRunPiStatusViaServer: () => getRunPiStatusViaServer,
+  getRunPiSessionViaServer: () => getRunPiSessionViaServer,
+  getRunPiMessagesViaServer: () => getRunPiMessagesViaServer,
+  getRunPiCommandsViaServer: () => getRunPiCommandsViaServer,
+  getRunPiCapabilitiesViaServer: () => getRunPiCapabilitiesViaServer,
+  getRunLogsViaServer: () => getRunLogsViaServer,
+  getRunDetailsViaServer: () => getRunDetailsViaServer,
+  getGitHubProjectStatusFieldViaServer: () => getGitHubProjectStatusFieldViaServer,
+  getGitHubAuthStatusViaServer: () => getGitHubAuthStatusViaServer,
+  ensureTaskLabelsViaServer: () => ensureTaskLabelsViaServer,
+  ensureServerForCli: () => ensureServerForCli,
+  buildRunPiEventsWebSocketUrl: () => buildRunPiEventsWebSocketUrl,
+  abortRunPiViaServer: () => abortRunPiViaServer
+});
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+function setServerPhaseListener(listener) {
+  const previous = serverPhaseListener;
+  serverPhaseListener = listener;
+  return previous;
+}
+function reportServerPhase(label) {
+  serverPhaseListener?.(label);
+}
+function cleanToken(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
+  const scopedKey = resolve2(projectRoot ?? process.cwd());
+  scopedGitHubBearerTokens.set(scopedKey, cleanToken(token ?? undefined));
+}
+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);
+      return {
+        baseUrl: selected.connection.baseUrl,
+        authToken,
+        connectionKind: "remote",
+        serverProjectRoot
+      };
+    }
+    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 appendTaskFilterParams(url, filters) {
+  if (filters.assignee)
+    url.searchParams.set("assignee", filters.assignee);
+  if (filters.state)
+    url.searchParams.set("state", filters.state);
+  if (filters.status)
+    url.searchParams.set("status", filters.status);
+  if (filters.limit !== undefined)
+    url.searchParams.set("limit", String(filters.limit));
+}
+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;
+}
+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) {
+      return {
+        alias: selected.alias,
+        target: selected.connection.kind === "remote" ? selected.connection.baseUrl : server.baseUrl
+      };
+    }
+  } 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;
+}
+async function listWorkspaceTasksViaServer(context, filters = {}) {
+  const url = new URL("http://rig.local/api/workspace/tasks");
+  appendTaskFilterParams(url, filters);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  if (!Array.isArray(payload)) {
+    throw new CliError("Rig server returned an invalid task list payload.", 1, { hint: "Check the selected server with `rig server status`; mixed CLI/server versions can mismatch \u2014 try `rig doctor`." });
+  }
+  return payload.flatMap((entry) => entry && typeof entry === "object" && !Array.isArray(entry) ? [entry] : []);
+}
+async function getWorkspaceTaskViaServer(context, taskId) {
+  const payload = await requestServerJson(context, `/api/workspace/tasks/${encodeURIComponent(taskId)}`);
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const task = payload.task;
+  return task && typeof task === "object" && !Array.isArray(task) ? task : null;
+}
+async function selectNextWorkspaceTaskViaServer(context, filters = {}) {
+  const url = new URL("http://rig.local/api/workspace/tasks/next");
+  appendTaskFilterParams(url, filters);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new CliError("Rig server returned an invalid next-task payload.", 1, { hint: "Check the selected server with `rig server status`; try `rig task list` to see the raw task set." });
+  }
+  const record = payload;
+  const rawTask = record.task;
+  const task = rawTask && typeof rawTask === "object" && !Array.isArray(rawTask) ? rawTask : null;
+  const count = typeof record.count === "number" && Number.isFinite(record.count) ? record.count : task ? 1 : 0;
+  return { task, count };
+}
+async function getGitHubAuthStatusViaServer(context) {
+  const payload = await requestServerJson(context, "/api/github/auth/status");
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function postGitHubTokenViaServer(context, token, options = {}) {
+  const payload = await requestServerJson(context, "/api/github/auth/token", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ token, selectedRepo: options.selectedRepo, projectRoot: options.projectRoot })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function prepareRemoteCheckoutViaServer(context, input) {
+  const payload = await requestServerJson(context, `/api/projects/${encodeURIComponent(input.repoSlug)}/prepare-checkout`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ checkout: input.checkout, repoUrl: input.repoUrl, baseDir: input.baseDir })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function registerProjectViaServer(context, input) {
+  const payload = await requestServerJson(context, "/api/projects", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(input)
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function isRetryableProjectRootSwitchError(error) {
+  if (!(error instanceof Error))
+    return false;
+  const message = error.message.toLowerCase();
+  return message.includes("rig server request failed (401): auth-required") || message.includes("rig server request failed (401): github-token-required") || message.includes("rig server request failed (502)") || message.includes("rig server request failed (503)") || message.includes("bad gateway") || message.includes("fetch failed") || message.includes("econnrefused") || message.includes("connection refused");
+}
+async function switchServerProjectRootViaServer(context, projectRoot, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 30000;
+  const pollMs = options.pollMs ?? 1000;
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  let switched = null;
+  while (Date.now() < deadline) {
+    try {
+      switched = await requestServerJson(context, "/api/server/project-root", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ projectRoot })
+      });
+      break;
+    } catch (error) {
+      lastError = error;
+      if (!isRetryableProjectRootSwitchError(error))
+        throw error;
+      await sleep(pollMs);
+    }
+  }
+  if (!switched) {
+    throw new CliError(`Rig server did not accept project-root switch to ${projectRoot} before timeout (${lastError instanceof Error ? lastError.message : String(lastError ?? "no response")}).`, 1);
+  }
+  const record = switched && typeof switched === "object" && !Array.isArray(switched) ? switched : {};
+  if (record.ok === true) {
+    writeRepoServerProjectRoot(context.projectRoot, projectRoot);
+    return { ok: true, switched: record };
+  }
+  throw new CliError(`Rig server rejected project-root scope ${projectRoot}: ${String(record.message ?? record.error ?? "unknown error")}`, 1);
+}
+async function listRunsViaServer(context, options = {}) {
+  const url = new URL("http://rig.local/api/runs");
+  if (options.limit !== undefined)
+    url.searchParams.set("limit", String(options.limit));
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  const runs = Array.isArray(payload) ? payload : payload && typeof payload === "object" && !Array.isArray(payload) && Array.isArray(payload.runs) ? payload.runs : [];
+  return runs.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+}
+async function getRunDetailsViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function getRunLogsViaServer(context, runId, options = {}) {
+  const url = new URL(`http://rig.local/api/runs/${encodeURIComponent(runId)}/logs`);
+  if (options.limit !== undefined)
+    url.searchParams.set("limit", String(options.limit));
+  if (options.cursor)
+    url.searchParams.set("cursor", options.cursor);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { entries: [] };
+}
+async function getRunTimelineViaServer(context, runId, options = {}) {
+  const url = new URL(`http://rig.local/api/runs/${encodeURIComponent(runId)}/timeline`);
+  if (options.limit !== undefined)
+    url.searchParams.set("limit", String(options.limit));
+  if (options.cursor)
+    url.searchParams.set("cursor", options.cursor);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { entries: [] };
+}
+async function ensureTaskLabelsViaServer(context) {
+  const payload = await requestServerJson(context, "/api/workspace/task-labels", { method: "POST" });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function listGitHubProjectsViaServer(context, owner) {
+  const url = new URL("http://rig.local/api/github/projects");
+  url.searchParams.set("owner", owner);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { projects: [] };
+}
+async function getGitHubProjectStatusFieldViaServer(context, projectId) {
+  const payload = await requestServerJson(context, `/api/github/projects/${encodeURIComponent(projectId)}/status-field`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function updateWorkspaceTaskViaServer(context, input) {
+  const payload = await requestServerJson(context, "/api/tasks/update", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(input)
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
+}
+async function resumeRunViaServer(context, runId, options) {
+  let targetRunId = runId?.trim() || null;
+  if (!targetRunId) {
+    const candidates = (await listRunsViaServer(context)).filter((run) => RESUMABLE_RUN_STATUSES.has(String(run.status ?? ""))).sort((left, right) => String(right.updatedAt ?? "").localeCompare(String(left.updatedAt ?? "")));
+    targetRunId = typeof candidates[0]?.runId === "string" ? candidates[0].runId : null;
+  }
+  if (!targetRunId) {
+    throw new CliError(options.restart ? "No run is available to restart." : "No resumable run is available.", 2, { hint: "List runs with `rig run list`, then pass an explicit id: `rig run resume <run-id>`." });
+  }
+  const payload = await requestServerJson(context, "/api/runs/resume", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ runId: targetRunId, createdAt: new Date().toISOString(), restart: options.restart })
+  });
+  const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+  if (record.ok === false) {
+    const message = typeof record.error === "string" && record.error.trim() ? record.error : "run resume failed";
+    throw new CliError(`${options.restart ? "restart" : "resume"} failed for ${targetRunId}: ${message}`, 1);
+  }
+  return { ok: true, runId: targetRunId, ...record };
+}
+async function resolveServerConnectionLabel(projectRoot) {
+  try {
+    const selected = resolveSelectedConnection(projectRoot);
+    if (!selected)
+      return "no server selected";
+    if (selected.connection.kind === "remote") {
+      return selected.connection.baseUrl.replace(/^https?:\/\//, "");
+    }
+    return `local (${selected.alias})`;
+  } catch {
+    return "no server selected";
+  }
+}
+async function stopRunViaServer(context, runId) {
+  const payload = await requestServerJson(context, "/api/runs/stop", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ runId })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true, runId };
+}
+async function steerRunViaServer(context, runId, message) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/steer`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ message })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
+}
+async function getRunPiSessionViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function getRunPiMessagesViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/messages`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { messages: [] };
+}
+async function getRunPiStatusViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/status`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function getRunPiCommandsViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/commands`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { commands: [] };
+}
+async function getRunPiCapabilitiesViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/capabilities`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { capabilities: null };
+}
+async function sendRunPiPromptViaServer(context, runId, text, streamingBehavior) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/prompt`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text, streamingBehavior })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function sendRunPiShellViaServer(context, runId, text) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/shell`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function runRunPiCommandViaServer(context, runId, text) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/commands/run`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { type: "done" };
+}
+async function respondRunPiExtensionUiViaServer(context, runId, requestId, valueOrCancel) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/extension-ui/respond`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ requestId, ...valueOrCancel })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function abortRunPiViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/abort`, { method: "POST" });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { aborted: true };
+}
+async function buildRunPiEventsWebSocketUrl(context, runId) {
+  const server = await ensureServerForCli(context.projectRoot);
+  const url = new URL(`${server.baseUrl.replace(/\/+$/, "")}/api/runs/${encodeURIComponent(runId)}/pi/events`);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  if (server.authToken)
+    url.searchParams.set("token", server.authToken);
+  if (server.serverProjectRoot)
+    url.searchParams.set("rigProjectRoot", server.serverProjectRoot);
+  return url.toString();
+}
+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 };
+}
+var scopedGitHubBearerTokens, serverPhaseListener = null, serverReachabilityCache, RESUMABLE_RUN_STATUSES;
+var init__server_client = __esm(() => {
+  init_runner();
+  init__connection_state();
+  scopedGitHubBearerTokens = new Map;
+  serverReachabilityCache = new Map;
+  RESUMABLE_RUN_STATUSES = new Set([
+    "created",
+    "preparing",
+    "running",
+    "validating",
+    "reviewing",
+    "stopped",
+    "failed",
+    "needs-attention",
+    "needs_attention"
+  ]);
+});
+
+// packages/cli/src/commands/_async-ui.ts
+import pc2 from "picocolors";
+async function withSpinner(label, work, options = {}) {
+  if (options.outputMode === "json") {
+    return work(() => {});
+  }
+  if (activeUpdate) {
+    const outer = activeUpdate;
+    outer(label);
+    return work(outer);
+  }
+  const output = options.output ?? process.stderr;
+  const isTty = output.isTTY === true;
+  let lastLabel = label;
+  if (!isTty) {
+    output.write(`${label}
+`);
+    const update2 = (next) => {
+      lastLabel = next;
+    };
+    activeUpdate = update2;
+    const previousListener2 = setServerPhaseListener(update2);
+    try {
+      return await work(update2);
+    } finally {
+      activeUpdate = null;
+      setServerPhaseListener(previousListener2);
+    }
+  }
+  const spinner = createTtySpinner({
+    label,
+    output,
+    frames: MICRO_DRONE_FRAMES,
+    styleFrame: (frame) => renderMicroDroneFrame(Math.max(0, MICRO_DRONE_FRAMES.indexOf(frame)))
+  });
+  const update = (next) => {
+    lastLabel = next;
+    spinner.setLabel(next);
+  };
+  activeUpdate = update;
+  const previousListener = setServerPhaseListener(update);
+  try {
+    const result = await work(update);
+    spinner.stop(options.doneLabel ? `${DONE_SYMBOL} ${options.doneLabel}` : undefined);
+    return result;
+  } catch (error) {
+    spinner.stop(`${FAIL_SYMBOL} ${lastLabel}`);
+    throw error;
+  } finally {
+    activeUpdate = null;
+    setServerPhaseListener(previousListener);
+  }
+}
+var DONE_SYMBOL, FAIL_SYMBOL, activeUpdate = null;
+var init__async_ui = __esm(() => {
+  init__spinner();
+  init__server_client();
+  init_theme();
+  DONE_SYMBOL = pc2.green("\u25C7");
+  FAIL_SYMBOL = pc2.red("\u25A0");
+});
+
+// packages/cli/src/commands/inbox.ts
+var exports_inbox = {};
+__export(exports_inbox, {
+  readPendingInboxCounts: () => readPendingInboxCounts,
+  printPendingInboxFooter: () => printPendingInboxFooter,
+  listInboxRecords: () => listInboxRecords,
+  executeInbox: () => executeInbox
+});
+async function listInboxRecords(context, kind, filters) {
+  const params = new URLSearchParams;
+  if (filters.run)
+    params.set("runId", filters.run);
+  if (filters.task)
+    params.set("taskId", filters.task);
+  const query = params.size > 0 ? `?${params.toString()}` : "";
+  const payload = await requestServerJson(context, `/api/inbox/${kind}${query}`);
+  const records = Array.isArray(payload) ? payload : [];
+  return filters.pendingOnly ? records.filter((entry) => (entry.status ?? "pending") !== "resolved") : records;
+}
+async function readPendingInboxCounts(context) {
+  try {
+    const [approvals, inputs] = await Promise.all([
+      listInboxRecords(context, "approvals", { pendingOnly: true }),
+      listInboxRecords(context, "inputs", { pendingOnly: true })
+    ]);
+    return { approvals: approvals.length, inputs: inputs.length };
+  } catch {
+    return null;
+  }
+}
+async function printPendingInboxFooter(context) {
+  if (context.outputMode !== "text")
+    return;
+  const counts = await readPendingInboxCounts(context);
+  if (!counts || counts.approvals === 0 && counts.inputs === 0)
+    return;
+  const parts = [];
+  if (counts.approvals > 0)
+    parts.push(`${counts.approvals} approval${counts.approvals === 1 ? "" : "s"}`);
+  if (counts.inputs > 0)
+    parts.push(`${counts.inputs} input request${counts.inputs === 1 ? "" : "s"}`);
+  console.log(`
+\u26A0 ${parts.join(" and ")} pending \u2014 run \`rig inbox\` to review.`);
+}
+function renderList(context, kind, records) {
+  if (context.outputMode === "text") {
+    printFormattedOutput(formatInboxList(kind, records));
+  }
+}
+async function watchInbox(context, filters) {
+  const render = async () => {
+    const [approvals, inputs] = await Promise.all([
+      listInboxRecords(context, "approvals", { ...filters, pendingOnly: true }),
+      listInboxRecords(context, "inputs", { ...filters, pendingOnly: true })
+    ]);
+    console.clear();
+    console.log(`rig inbox \u2014 watching (Ctrl-C to stop) \u2014 ${new Date().toLocaleTimeString()}`);
+    renderList(context, "approvals", approvals);
+    renderList(context, "inputs", inputs);
+    if (approvals.length === 0 && inputs.length === 0) {
+      console.log("Nothing pending.");
+    } else {
+      console.log(`
+Resolve with: rig inbox approve --run <id> --request <id> --decision approve|reject`);
+    }
+  };
+  await render();
+  const server = await ensureServerForCli(context.projectRoot);
+  const relevant = /"type":"rig\.(approval|user-input)\./;
+  const fallbackTimer = setInterval(() => {
+    render();
+  }, 30000);
+  fallbackTimer.unref?.();
+  for (;; ) {
+    try {
+      const response = await fetch(`${server.baseUrl}/api/server/events`, {
+        headers: {
+          ...server.authToken ? { authorization: `Bearer ${server.authToken}` } : {},
+          ...server.serverProjectRoot ? { "x-rig-project-root": server.serverProjectRoot } : {},
+          accept: "text/event-stream"
+        }
+      });
+      if (!response.ok || !response.body)
+        throw new Error(`SSE ${response.status}`);
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder;
+      for (;; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        const chunk = decoder.decode(value, { stream: true });
+        if (relevant.test(chunk)) {
+          await render();
+        }
+      }
+    } catch {
+      await render();
+      await new Promise((resolveSleep) => setTimeout(resolveSleep, 2000));
+    }
+  }
+}
+async function executeInbox(context, args) {
+  const [command = "approvals", ...rest] = args;
+  switch (command) {
+    case "approvals": {
+      let pending = rest;
+      const run = takeOption(pending, "--run");
+      pending = run.rest;
+      const task = takeOption(pending, "--task");
+      pending = task.rest;
+      requireNoExtraArgs(pending, "rig inbox approvals [--run <id>] [--task <id>]");
+      const approvals = await withSpinner("Reading approvals from server\u2026", () => listInboxRecords(context, "approvals", { run: run.value, task: task.value }), { outputMode: context.outputMode });
+      renderList(context, "approvals", approvals);
+      return { ok: true, group: "inbox", command, details: { approvals } };
+    }
+    case "inputs": {
+      let pending = rest;
+      const run = takeOption(pending, "--run");
+      pending = run.rest;
+      const task = takeOption(pending, "--task");
+      pending = task.rest;
+      requireNoExtraArgs(pending, "rig inbox inputs [--run <id>] [--task <id>]");
+      const requests = await withSpinner("Reading input requests from server\u2026", () => listInboxRecords(context, "inputs", { run: run.value, task: task.value }), { outputMode: context.outputMode });
+      renderList(context, "inputs", requests);
+      return { ok: true, group: "inbox", command, details: { requests } };
+    }
+    case "approve": {
+      let pending = rest;
+      const run = takeOption(pending, "--run");
+      pending = run.rest;
+      const request = takeOption(pending, "--request");
+      pending = request.rest;
+      const decision = takeOption(pending, "--decision");
+      pending = decision.rest;
+      const note = takeOption(pending, "--note");
+      pending = note.rest;
+      requireNoExtraArgs(pending, "rig inbox approve --run <id> --request <id> --decision approve|reject [--note <text>]");
+      if (!run.value || !request.value || !decision.value) {
+        throw new CliError("approve requires --run, --request, and --decision. List pending requests with `rig inbox approvals`.");
+      }
+      if (decision.value !== "approve" && decision.value !== "reject") {
+        throw new CliError("decision must be approve or reject.", 1, { hint: "Re-run as `rig inbox approve --run <id> --request <id> --decision approve|reject`." });
+      }
+      const result = await withSpinner(`Resolving approval ${request.value}\u2026`, () => requestServerJson(context, "/api/inbox/approvals/resolve", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          runId: run.value,
+          requestId: request.value,
+          decision: decision.value,
+          note: note.value ?? null
+        })
+      }), { outputMode: context.outputMode });
+      return { ok: true, group: "inbox", command, details: { result } };
+    }
+    case "respond": {
+      let pending = rest;
+      const run = takeOption(pending, "--run");
+      pending = run.rest;
+      const request = takeOption(pending, "--request");
+      pending = request.rest;
+      const answers = [];
+      const remaining = [];
+      for (let index = 0;index < pending.length; index += 1) {
+        const current = pending[index];
+        if (current === "--answer") {
+          const next = pending[index + 1];
+          if (!next || next.startsWith("-")) {
+            throw new CliError("Missing value for --answer", 1, { hint: "Pass key=value pairs, e.g. `rig inbox respond --run <id> --request <id> --answer key=value`." });
+          }
+          answers.push(next);
+          index += 1;
+          continue;
+        }
+        if (current !== undefined) {
+          remaining.push(current);
+        }
+      }
+      requireNoExtraArgs(remaining, "rig inbox respond --run <id> --request <id> --answer key=value [--answer key=value]");
+      if (!run.value || !request.value || answers.length === 0) {
+        throw new CliError("respond requires --run, --request, and at least one --answer. List pending requests with `rig inbox inputs`.");
+      }
+      const parsedAnswers = Object.fromEntries(answers.map((entry) => {
+        const [key, ...restValue] = entry.split("=");
+        return [key, restValue.join("=")];
+      }));
+      const result = await withSpinner(`Sending response for ${request.value}\u2026`, () => requestServerJson(context, "/api/inbox/inputs/respond", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          runId: run.value,
+          requestId: request.value,
+          answers: parsedAnswers
+        })
+      }), { outputMode: context.outputMode });
+      return { ok: true, group: "inbox", command, details: { result } };
+    }
+    case "watch": {
+      let pending = rest;
+      const run = takeOption(pending, "--run");
+      pending = run.rest;
+      const task = takeOption(pending, "--task");
+      pending = task.rest;
+      requireNoExtraArgs(pending, "rig inbox watch [--run <id>] [--task <id>]");
+      return await watchInbox(context, { run: run.value, task: task.value });
+    }
+    default:
+      throw new CliError(`Unknown inbox command: ${command}. Use approvals|inputs|approve|respond|watch.`);
+  }
+}
+var init_inbox = __esm(() => {
+  init_runner();
+  init__cli_format();
+  init__server_client();
+  init__async_ui();
+});
+
+// packages/cli/src/app-opentui/adapters/common.ts
+function adapterContextFromRuntime(runtime, renderer) {
+  return {
+    projectRoot: runtime.getState().projectRoot,
+    renderer,
+    ensureRuntime: () => runtime.getRunnerContext(),
+    emit: (event) => runtime.emit(event),
+    getState: () => runtime.getState()
+  };
+}
+function projectRootOf(ctx) {
+  const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
+  if (typeof root === "string" && root.trim())
+    return root;
+  throw new Error("Rig app adapter requires a projectRoot.");
+}
+function normalizeAppError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const rawHint = error instanceof Error ? error.hint : undefined;
+  return {
+    message,
+    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {}
+  };
+}
+function emitStarted(ctx, label, optimistic) {
+  ctx.emit({ type: "action.started", label, ...optimistic ? { optimistic } : {} });
+}
+function emitProgress(ctx, label, detail, data) {
+  ctx.emit({ type: "action.progress", label, ...detail ? { detail } : {}, ...data ? { data } : {} });
+}
+function emitCompleted(ctx, label, data) {
+  ctx.emit({ type: "action.completed", label, ...data ? { data } : {} });
+}
+function emitFailed(ctx, label, error, data) {
+  if (data)
+    patchData(ctx, data);
+  const normalized = normalizeAppError(error);
+  ctx.emit({
+    type: "action.failed",
+    label,
+    message: normalized.message,
+    ...normalized.hint ? { hint: normalized.hint } : {},
+    cause: error
+  });
+}
+function patchData(ctx, data) {
+  ctx.emit({ type: "data.patch", data });
+}
+function patchFooter(ctx, footer) {
+  ctx.emit({ type: "footer.patch", footer });
+}
+function stringField(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+      return String(value);
+  }
+  return fallback;
+}
+function payloadString(intent, key) {
+  const value = intent.action.payload?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+// packages/cli/src/app-opentui/adapters/inbox.ts
+function createInboxAdapter() {
+  return {
+    id: "inbox",
+    async handleIntent(runtime, intent) {
+      if (intent.scene !== "inbox" && !intent.action.kind.startsWith("inbox-"))
+        return false;
+      const ctx = adapterContextFromRuntime(runtime);
+      if (intent.action.kind === "inbox-approve" || intent.action.kind === "inbox-reject") {
+        const requestId = payloadString(intent, "requestId");
+        let match = requestId ? findInboxRecord(ctx, "approvals", requestId) : null;
+        if (requestId && !match)
+          match = findInRecords((await refreshInbox(ctx)).approvals, requestId);
+        if (requestId && match) {
+          await resolveApproval(ctx, { runId: match.runId, requestId: match.requestId, decision: intent.action.kind === "inbox-approve" ? "approve" : "reject" });
+          return true;
+        }
+      }
+      if (intent.action.kind === "inbox-answer") {
+        const requestId = payloadString(intent, "requestId");
+        let match = requestId ? findInboxRecord(ctx, "inputs", requestId) : null;
+        if (requestId && !match)
+          match = findInRecords((await refreshInbox(ctx)).inputs, requestId);
+        const answer = payloadString(intent, "answer");
+        if (requestId && match && answer) {
+          await answerInputRequest(ctx, { runId: match.runId, requestId: match.requestId, answers: { answer } });
+          return true;
+        }
+      }
+      await refreshInbox(ctx);
+      return true;
+    }
+  };
+}
+function findInRecords(records, requestId) {
+  return records.find((record) => record.requestId === requestId || record.requestId.startsWith(requestId)) ?? null;
+}
+function findInboxRecord(ctx, kind, requestId) {
+  const inbox = ctx.getState().data?.inbox;
+  if (!inbox || typeof inbox !== "object" || Array.isArray(inbox))
+    return null;
+  const records = inbox[kind];
+  if (!Array.isArray(records))
+    return null;
+  return findInRecords(records, requestId);
+}
+function normalizeInboxRecord(kind, record) {
+  const runId = stringField(record, ["runId"]);
+  const requestId = stringField(record, ["requestId", "id"]);
+  if (!runId || !requestId)
+    return null;
+  const taskId = stringField(record, ["taskId"]);
+  const nested = record.record && typeof record.record === "object" && !Array.isArray(record.record) ? record.record : {};
+  return {
+    kind,
+    runId,
+    requestId,
+    status: stringField(record, ["status"], "pending"),
+    title: stringField(nested, ["title", "prompt", "message", "toolName"], kind === "approvals" ? "approval request" : "input request"),
+    raw: record,
+    ...taskId ? { taskId } : {}
+  };
+}
+async function refreshInbox(ctx, filters = {}) {
+  const label = "Loading inbox";
+  emitStarted(ctx, label);
+  try {
+    const { listInboxRecords: listInboxRecords2 } = await Promise.resolve().then(() => (init_inbox(), exports_inbox));
+    const context = { projectRoot: projectRootOf(ctx) };
+    emitProgress(ctx, label, "reading approvals and input requests");
+    const [approvalsRaw, inputsRaw] = await Promise.all([
+      listInboxRecords2(context, "approvals", { run: filters.run, task: filters.task, pendingOnly: filters.pendingOnly ?? true }),
+      listInboxRecords2(context, "inputs", { run: filters.run, task: filters.task, pendingOnly: filters.pendingOnly ?? true })
+    ]);
+    const approvals = approvalsRaw.flatMap((entry) => {
+      const normalized = normalizeInboxRecord("approvals", entry);
+      return normalized ? [normalized] : [];
+    });
+    const inputs = inputsRaw.flatMap((entry) => {
+      const normalized = normalizeInboxRecord("inputs", entry);
+      return normalized ? [normalized] : [];
+    });
+    patchData(ctx, { inbox: { approvals, inputs, refreshedAt: new Date().toISOString() } });
+    patchFooter(ctx, { inbox: `${approvals.length + inputs.length} pending` });
+    emitCompleted(ctx, label, { approvals: approvals.length, inputs: inputs.length });
+    return { approvals, inputs };
+  } catch (error) {
+    emitFailed(ctx, label, error);
+    throw error;
+  }
+}
+async function resolveApproval(ctx, input) {
+  const label = `${input.decision === "approve" ? "Approving" : "Rejecting"} ${input.requestId}`;
+  emitStarted(ctx, label, {
+    inboxPatch: { kind: "approvals", runId: input.runId, requestId: input.requestId, status: input.decision === "approve" ? "approving" : "rejecting" }
+  });
+  patchData(ctx, { inboxOptimistic: { kind: "approvals", ...input, status: input.decision === "approve" ? "approving" : "rejecting" } });
+  try {
+    const { requestServerJson: requestServerJson2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
+    const result = await requestServerJson2({ projectRoot: projectRootOf(ctx) }, "/api/inbox/approvals/resolve", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ runId: input.runId, requestId: input.requestId, decision: input.decision, note: input.note ?? null })
+    });
+    const record = result && typeof result === "object" && !Array.isArray(result) ? result : { ok: true };
+    emitCompleted(ctx, label, { runId: input.runId, requestId: input.requestId, decision: input.decision, result: record });
+    await refreshInbox(ctx).catch(() => ({ approvals: [], inputs: [] }));
+    return record;
+  } catch (error) {
+    emitFailed(ctx, label, error, { runId: input.runId, requestId: input.requestId, revert: { status: "pending" } });
+    throw error;
+  }
+}
+async function answerInputRequest(ctx, input) {
+  const label = `Answering ${input.requestId}`;
+  emitStarted(ctx, label, {
+    inboxPatch: { kind: "inputs", runId: input.runId, requestId: input.requestId, status: "answering" }
+  });
+  patchData(ctx, { inboxOptimistic: { kind: "inputs", ...input, status: "answering" } });
+  try {
+    const { requestServerJson: requestServerJson2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
+    const result = await requestServerJson2({ projectRoot: projectRootOf(ctx) }, "/api/inbox/inputs/respond", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ runId: input.runId, requestId: input.requestId, answers: input.answers })
+    });
+    const record = result && typeof result === "object" && !Array.isArray(result) ? result : { ok: true };
+    emitCompleted(ctx, label, { runId: input.runId, requestId: input.requestId, result: record });
+    await refreshInbox(ctx).catch(() => ({ approvals: [], inputs: [] }));
+    return record;
+  } catch (error) {
+    emitFailed(ctx, label, error, { runId: input.runId, requestId: input.requestId, revert: { status: "pending" } });
+    throw error;
+  }
+}
+export {
+  resolveApproval,
+  refreshInbox,
+  normalizeInboxRecord,
+  createInboxAdapter,
+  answerInputRequest
+};