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

package/dist/src/app-opentui/adapters/pi-attach.js

@@ -1,2101 +0,0 @@
-// @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/app-opentui/adapters/common.ts
-function projectRootOf(ctx) {
-  const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
-  if (typeof root === "string" && root.trim())
-    return root;
-  throw new Error("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 });
-}
-async function releaseRendererForExternalTui(ctx) {
-  const renderer = ctx.renderer;
-  if (!renderer)
-    return;
-  if (renderer.suspend) {
-    await renderer.suspend();
-    return;
-  }
-  if (renderer.destroy) {
-    await renderer.destroy();
-  }
-}
-async function resumeRendererAfterExternalTui(ctx) {
-  await ctx.renderer?.resume?.();
-}
-function arrayFromPayload(value) {
-  if (Array.isArray(value)) {
-    return value.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
-  }
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    const entries = value.entries;
-    if (Array.isArray(entries))
-      return arrayFromPayload(entries);
-  }
-  return [];
-}
-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;
-}
-
-// 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";
-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/commands/_connection-state.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, resolve } from "path";
-function resolveGlobalConnectionsPath(env = process.env) {
-  const explicit = env.RIG_CONNECTIONS_FILE?.trim();
-  if (explicit)
-    return resolve(explicit);
-  const stateDir = env.RIG_GLOBAL_STATE_DIR?.trim();
-  if (stateDir)
-    return resolve(stateDir, "connections.json");
-  return resolve(homedir(), ".rig", "connections.json");
-}
-function resolveRepoConnectionPath(projectRoot) {
-  return resolve(projectRoot, ".rig", "state", "connection.json");
-}
-function readJsonFile(path) {
-  if (!existsSync(path))
-    return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch (error) {
-    throw new CliError(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1, { hint: "Fix or delete that file, then re-select a server with `rig server use <alias|local>`." });
-  }
-}
-function writeJsonFile(path, value) {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-function normalizeConnection(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const record = value;
-  if (record.kind === "local")
-    return { kind: "local", mode: "auto" };
-  if (record.kind === "remote" && typeof record.baseUrl === "string" && record.baseUrl.trim()) {
-    const baseUrl = record.baseUrl.trim().replace(/\/+$/, "");
-    return { kind: "remote", baseUrl };
-  }
-  return null;
-}
-function readGlobalConnections(options = {}) {
-  const path = resolveGlobalConnectionsPath(options.env ?? process.env);
-  const payload = readJsonFile(path);
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    return { connections: {} };
-  }
-  const rawConnections = payload.connections;
-  const connections = {};
-  if (rawConnections && typeof rawConnections === "object" && !Array.isArray(rawConnections)) {
-    for (const [alias, raw] of Object.entries(rawConnections)) {
-      const connection = normalizeConnection(raw);
-      if (connection)
-        connections[alias] = connection;
-    }
-  }
-  return { connections };
-}
-function readRepoConnection(projectRoot) {
-  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const record = payload;
-  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
-  if (!selected)
-    return null;
-  return {
-    selected,
-    project: typeof record.project === "string" ? record.project : undefined,
-    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
-    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined,
-    serverProjectRootAlias: typeof record.serverProjectRootAlias === "string" && record.serverProjectRootAlias.trim() ? record.serverProjectRootAlias.trim() : undefined,
-    serverProjectRootBaseUrl: typeof record.serverProjectRootBaseUrl === "string" && record.serverProjectRootBaseUrl.trim() ? record.serverProjectRootBaseUrl.trim().replace(/\/+$/, "") : undefined
-  };
-}
-function writeRepoConnection(projectRoot, state) {
-  writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
-}
-function rootAllowedForSelection(repo, connection) {
-  const root = repo.serverProjectRoot?.trim();
-  if (!root)
-    return;
-  if (connection.kind === "remote") {
-    if (repo.serverProjectRootAlias !== repo.selected)
-      return;
-    if (repo.serverProjectRootBaseUrl !== connection.baseUrl)
-      return;
-  } else if (repo.serverProjectRootAlias && repo.serverProjectRootAlias !== repo.selected) {
-    return;
-  }
-  return root;
-}
-function resolveSelectedConnection(projectRoot, options = {}) {
-  const repo = readRepoConnection(projectRoot);
-  if (!repo)
-    return null;
-  if (repo.selected === "local")
-    return { alias: "local", connection: { kind: "local", mode: "auto" }, serverProjectRoot: repo.serverProjectRoot };
-  const global = readGlobalConnections(options);
-  const connection = global.connections[repo.selected];
-  if (!connection) {
-    throw new CliError(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
-  }
-  return { alias: repo.selected, connection, serverProjectRoot: rootAllowedForSelection(repo, connection) };
-}
-function writeRepoServerProjectRoot(projectRoot, serverProjectRoot, metadata = {}) {
-  const repo = readRepoConnection(projectRoot);
-  if (!repo)
-    return;
-  let inferred = metadata;
-  if (!inferred.alias || !inferred.baseUrl) {
-    try {
-      const selected = resolveSelectedConnection(projectRoot);
-      if (selected?.connection.kind === "remote") {
-        inferred = {
-          alias: inferred.alias ?? selected.alias,
-          baseUrl: inferred.baseUrl ?? selected.connection.baseUrl
-        };
-      }
-    } catch {}
-  }
-  writeRepoConnection(projectRoot, {
-    ...repo,
-    ...metadata.project ? { project: metadata.project } : {},
-    serverProjectRoot,
-    ...inferred.alias ? { serverProjectRootAlias: inferred.alias } : {},
-    ...inferred.baseUrl ? { serverProjectRootBaseUrl: inferred.baseUrl.replace(/\/+$/, "") } : {}
-  });
-}
-function clearRepoServerProjectRoot(projectRoot) {
-  const repo = readRepoConnection(projectRoot);
-  if (!repo)
-    return;
-  writeRepoConnection(projectRoot, {
-    selected: repo.selected,
-    ...repo.project ? { project: repo.project } : {},
-    ...repo.linkedAt ? { linkedAt: repo.linkedAt } : {}
-  });
-}
-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,
-  repairRemoteProjectRootLink: () => repairRemoteProjectRootLink,
-  registerProjectViaServer: () => registerProjectViaServer,
-  prepareRemoteCheckoutViaServer: () => prepareRemoteCheckoutViaServer,
-  postGitHubTokenViaServer: () => postGitHubTokenViaServer,
-  normalizeRepoSlug: () => normalizeRepoSlug,
-  listWorkspaceTasksViaServer: () => listWorkspaceTasksViaServer,
-  listRunsViaServer: () => listRunsViaServer,
-  listGitHubProjectsViaServer: () => listGitHubProjectsViaServer,
-  isRemoteProjectRootLinkError: () => isRemoteProjectRootLinkError,
-  inspectRemoteProjectLink: () => inspectRemoteProjectLink,
-  getWorkspaceTaskViaServer: () => getWorkspaceTaskViaServer,
-  getRunTimelineViaServer: () => getRunTimelineViaServer,
-  getRunPiStatusViaServer: () => getRunPiStatusViaServer,
-  getRunPiSessionViaServer: () => getRunPiSessionViaServer,
-  getRunPiMessagesViaServer: () => getRunPiMessagesViaServer,
-  getRunPiCommandsViaServer: () => getRunPiCommandsViaServer,
-  getRunPiCapabilitiesViaServer: () => getRunPiCapabilitiesViaServer,
-  getRunLogsViaServer: () => getRunLogsViaServer,
-  getRunDetailsViaServer: () => getRunDetailsViaServer,
-  getGitHubProjectStatusFieldViaServer: () => getGitHubProjectStatusFieldViaServer,
-  getGitHubAuthStatusViaServer: () => getGitHubAuthStatusViaServer,
-  formatRemoteProjectLinkHint: () => formatRemoteProjectLinkHint,
-  ensureTaskLabelsViaServer: () => ensureTaskLabelsViaServer,
-  ensureServerForCli: () => ensureServerForCli,
-  ensureRemoteProjectRootLink: () => ensureRemoteProjectRootLink,
-  buildRunPiEventsWebSocketUrl: () => buildRunPiEventsWebSocketUrl,
-  abortRunPiViaServer: () => abortRunPiViaServer
-});
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, isAbsolute, resolve as resolve2 } from "path";
-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 readRemoteAuthState(projectRoot) {
-  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
-  if (!existsSync2(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function readPrivateRemoteSessionToken(projectRoot) {
-  const parsed = readRemoteAuthState(projectRoot);
-  return parsed ? cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined) : null;
-}
-function readGitHubBearerTokenForRemote(projectRoot) {
-  const scopedKey = resolve2(projectRoot);
-  if (scopedGitHubBearerTokens.has(scopedKey))
-    return scopedGitHubBearerTokens.get(scopedKey) ?? null;
-  const privateSession = readPrivateRemoteSessionToken(projectRoot);
-  if (privateSession)
-    return privateSession;
-  return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
-}
-function readStoredGitHubAuthToken(projectRoot) {
-  const parsed = readRemoteAuthState(projectRoot);
-  return parsed ? cleanToken(typeof parsed.token === "string" ? parsed.token : undefined) : null;
-}
-function inferRemoteServerProjectRootCandidateFromAuthState(projectRoot, repoSlug) {
-  if (!/^[^/]+\/[^/]+$/.test(repoSlug))
-    return null;
-  const repo = readRepoConnection(projectRoot);
-  const auth = readRemoteAuthState(projectRoot);
-  const authUpdatedAt = typeof auth?.updatedAt === "string" ? Date.parse(auth.updatedAt) : Number.NaN;
-  const repoLinkedAt = typeof repo?.linkedAt === "string" ? Date.parse(repo.linkedAt) : Number.NaN;
-  if (Number.isFinite(authUpdatedAt) && Number.isFinite(repoLinkedAt) && authUpdatedAt + 1000 < repoLinkedAt)
-    return null;
-  const checkoutBaseDir = typeof auth?.checkoutBaseDir === "string" && auth.checkoutBaseDir.trim() ? auth.checkoutBaseDir.trim() : null;
-  if (!checkoutBaseDir)
-    return null;
-  return `${checkoutBaseDir.replace(/\/+$/, "")}/${repoSlug}`;
-}
-function readLocalConnectionFallbackToken(projectRoot) {
-  return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
-}
-function normalizeRepoSlug(value) {
-  const slug = value?.trim();
-  return slug && /^[^/\s]+\/[^/\s]+$/.test(slug) ? slug : null;
-}
-function readProjectLinkSlug(projectRoot) {
-  const path = resolve2(projectRoot, ".rig", "state", "project-link.json");
-  if (!existsSync2(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-      return null;
-    return normalizeRepoSlug(typeof parsed.repoSlug === "string" ? String(parsed.repoSlug) : null);
-  } catch {
-    return null;
-  }
-}
-function writeProjectLinkConnection(projectRoot, repoSlug, alias) {
-  const path = resolve2(projectRoot, ".rig", "state", "project-link.json");
-  mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync2(path, `${JSON.stringify({ repoSlug, connection: alias, linkedAt: new Date().toISOString() }, null, 2)}
-`, "utf8");
-}
-function remoteLinkRepairCommand(repoSlug) {
-  return repoSlug ? `rig server repair-link --repo ${repoSlug}` : "rig server repair-link --repo owner/repo";
-}
-function isRemoteProjectRootLinkError(error) {
-  const text = error instanceof Error ? error.message : String(error ?? "");
-  return /no server-host project root link|remote project(?:-root)? link|x-rig-project-root|serverProjectRoot/i.test(text);
-}
-function formatRemoteProjectLinkHint(resolution) {
-  const repair = remoteLinkRepairCommand(resolution.repoSlug);
-  if (resolution.status === "auth_required") {
-    return `Authenticate the selected remote${resolution.alias ? ` (${resolution.alias})` : ""}, then run \`${repair}\`. Use \`rig github auth import-gh\` or \`rig init --repair --server remote --github-auth device${resolution.repoSlug ? ` --repo ${resolution.repoSlug}` : ""}\`.`;
-  }
-  if (resolution.status === "missing_project") {
-    return `Record the repo slug, then run \`${repair}\` (or \`rig init --repo owner/repo --server remote --github-auth device\`).`;
-  }
-  if (resolution.status === "not_remote")
-    return "Select a remote server with `rig server use <alias>` before repairing a remote project link.";
-  return `Run \`${repair}\` to backfill or prepare a server-host checkout for the selected remote${resolution.alias ? ` (${resolution.alias})` : ""}.`;
-}
-function remoteProjectLinkFailure(input) {
-  const partial = {
-    status: input.status,
-    alias: input.alias,
-    baseUrl: input.baseUrl,
-    repoSlug: input.repoSlug
-  };
-  return {
-    ok: false,
-    ...input,
-    hint: formatRemoteProjectLinkHint(partial),
-    next: remoteLinkRepairCommand(input.repoSlug)
-  };
-}
-function remoteProjectLinkSuccess(input) {
-  return {
-    ok: true,
-    status: input.status,
-    alias: input.alias,
-    baseUrl: input.baseUrl,
-    repoSlug: input.repoSlug,
-    serverProjectRoot: input.serverProjectRoot,
-    source: input.source,
-    prepared: input.prepared ?? input.status === "prepared",
-    validated: input.validated ?? false,
-    message: input.message ?? `Remote project link ready for ${input.repoSlug}.`,
-    hint: "Remote-scoped task/run/status requests will send x-rig-project-root for this server-host checkout.",
-    next: "rig task list"
-  };
-}
-function localCheckoutPathCandidate(projectRoot, candidate) {
-  try {
-    const local = resolve2(projectRoot);
-    const resolved = resolve2(candidate);
-    return resolved === local || resolved.startsWith(`${local}/`);
-  } catch {
-    return false;
-  }
-}
-async function requestRemoteProjectLinkJson(baseUrl, pathname, authToken, init = {}) {
-  const requestUrl = new URL(`${baseUrl}${pathname}`);
-  if (authToken && queryAuthFallbackEnabled())
-    requestUrl.searchParams.set("rt", authToken);
-  const response = await fetch(requestUrl, {
-    ...init,
-    headers: mergeHeaders(init.headers, authToken)
-  });
-  const text = await response.text();
-  const payload = text.trim().length > 0 ? (() => {
-    try {
-      return JSON.parse(text);
-    } catch {
-      return null;
-    }
-  })() : null;
-  return { ok: response.ok, status: response.status, payload, text };
-}
-function payloadError(payload, fallback) {
-  if (payload && typeof payload === "object" && !Array.isArray(payload)) {
-    const record = payload;
-    const value = record.error ?? record.message ?? record.reason;
-    if (typeof value === "string" && value.trim())
-      return value.trim();
-  }
-  return fallback;
-}
-function checkoutPathsFromProjectPayload(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return [];
-  const project = payload.project;
-  if (!project || typeof project !== "object" || Array.isArray(project))
-    return [];
-  const checkouts = project.checkouts;
-  if (!Array.isArray(checkouts))
-    return [];
-  return [...checkouts].reverse().flatMap((entry) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry))
-      return [];
-    const path = entry.path;
-    return typeof path === "string" && path.trim() ? [path.trim()] : [];
-  });
-}
-function checkoutPathFromPreparePayload(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const checkout = payload.checkout;
-  if (!checkout || typeof checkout !== "object" || Array.isArray(checkout))
-    return null;
-  const path = checkout.path;
-  return typeof path === "string" && path.trim() ? path.trim() : null;
-}
-async function validateAndPersistRemoteRoot(input) {
-  const candidate = input.candidate.trim();
-  if (!candidate || !isAbsolute(candidate)) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      message: `Remote project root candidate is not an absolute server-host path: ${candidate || "(empty)"}.`
-    });
-  }
-  if (localCheckoutPathCandidate(input.projectRoot, candidate)) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      message: `Refusing to use local checkout path ${candidate} as a remote server project root.`
-    });
-  }
-  let response;
-  try {
-    response = await requestRemoteProjectLinkJson(input.baseUrl, "/api/server/project-root", input.authToken, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ projectRoot: candidate })
-    });
-  } catch (error) {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      message: `Could not validate remote project root ${candidate}: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-  if (response.status === 401 || response.status === 403) {
-    return remoteProjectLinkFailure({
-      status: "auth_required",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      statusCode: response.status,
-      message: `Remote server ${input.alias} requires authentication before validating project root ${candidate}.`
-    });
-  }
-  if (!response.ok) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      statusCode: response.status,
-      message: `Remote server rejected project root ${candidate} (${response.status}): ${payloadError(response.payload, response.text || "project-root validation failed")}`
-    });
-  }
-  const record = response.payload && typeof response.payload === "object" && !Array.isArray(response.payload) ? response.payload : {};
-  if (record.ok !== true) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias: input.alias,
-      baseUrl: input.baseUrl,
-      repoSlug: input.repoSlug,
-      message: `Remote server did not accept project root ${candidate}: ${payloadError(response.payload, "project-root validation failed")}`
-    });
-  }
-  const accepted = typeof record.projectRoot === "string" && record.projectRoot.trim() ? record.projectRoot.trim() : typeof record.requestedProjectRoot === "string" && record.requestedProjectRoot.trim() ? record.requestedProjectRoot.trim() : candidate;
-  writeRepoServerProjectRoot(input.projectRoot, accepted, { alias: input.alias, baseUrl: input.baseUrl, project: input.repoSlug });
-  writeProjectLinkConnection(input.projectRoot, input.repoSlug, input.alias);
-  const status = input.status ?? (input.prepared ? "prepared" : "backfilled");
-  return remoteProjectLinkSuccess({
-    status,
-    alias: input.alias,
-    baseUrl: input.baseUrl,
-    repoSlug: input.repoSlug,
-    serverProjectRoot: accepted,
-    source: input.source,
-    prepared: input.prepared,
-    validated: true,
-    message: status === "ready" ? `Remote project link already points to ${accepted} and was validated on ${input.alias}.` : input.prepared ? `Prepared and linked remote checkout ${accepted} for ${input.repoSlug}.` : `Backfilled remote checkout ${accepted} for ${input.repoSlug}.`
-  });
-}
-async function ensureRemoteProjectRootLink(projectRoot, options = {}) {
-  let selected;
-  try {
-    selected = resolveSelectedConnection(projectRoot);
-  } catch (error) {
-    return remoteProjectLinkFailure({ status: "error", message: error instanceof Error ? error.message : String(error) });
-  }
-  if (!selected || selected.connection.kind !== "remote") {
-    return remoteProjectLinkFailure({ status: "not_remote", message: "No remote Rig server is selected for this repo." });
-  }
-  const repo = readRepoConnection(projectRoot);
-  const explicitRepoRequested = options.repoSlug !== undefined;
-  const explicitRepoSlug = explicitRepoRequested ? normalizeRepoSlug(options.repoSlug) : null;
-  const repoProjectSlug = normalizeRepoSlug(repo?.project);
-  const repoSlug = explicitRepoSlug ?? repoProjectSlug ?? readProjectLinkSlug(projectRoot);
-  const alias = selected.alias;
-  const baseUrl = selected.connection.baseUrl;
-  const authToken = options.authToken === undefined ? readGitHubBearerTokenForRemote(projectRoot) : options.authToken;
-  const mode = options.mode ?? "backfill-only";
-  if (explicitRepoRequested && !explicitRepoSlug) {
-    return remoteProjectLinkFailure({
-      status: "missing_project",
-      alias,
-      baseUrl,
-      message: `Invalid --repo value ${JSON.stringify(options.repoSlug)}. Expected owner/repo.`
-    });
-  }
-  if (!repoSlug) {
-    return remoteProjectLinkFailure({
-      status: "missing_project",
-      alias,
-      baseUrl,
-      message: `Remote server ${alias} is selected, but this checkout has no GitHub repo slug recorded.`
-    });
-  }
-  const skippedCandidates = [];
-  const storedRoot = selected.serverProjectRoot?.trim() || null;
-  const storedRootMatchesResolvedRepo = repoProjectSlug === repoSlug;
-  if (storedRoot && storedRootMatchesResolvedRepo) {
-    if (localCheckoutPathCandidate(projectRoot, storedRoot)) {
-      clearRepoServerProjectRoot(projectRoot);
-      skippedCandidates.push(storedRoot);
-    } else {
-      const storedResult = await validateAndPersistRemoteRoot({
-        projectRoot,
-        alias,
-        baseUrl,
-        authToken,
-        repoSlug,
-        candidate: storedRoot,
-        source: "stored",
-        status: "ready"
-      });
-      if (storedResult.ok || storedResult.status === "auth_required" || storedResult.status === "error")
-        return storedResult;
-      clearRepoServerProjectRoot(projectRoot);
-      skippedCandidates.push(storedRoot);
-    }
-  } else if (storedRoot) {
-    skippedCandidates.push(storedRoot);
-  }
-  const authCandidate = inferRemoteServerProjectRootCandidateFromAuthState(projectRoot, repoSlug);
-  if (authCandidate) {
-    const authResult = await validateAndPersistRemoteRoot({ projectRoot, alias, baseUrl, authToken, repoSlug, candidate: authCandidate, source: "auth-state" });
-    if (authResult.ok || authResult.status === "auth_required")
-      return authResult;
-  }
-  let registryResponse;
-  try {
-    registryResponse = await requestRemoteProjectLinkJson(baseUrl, `/api/projects/${encodeURIComponent(repoSlug)}`, authToken);
-  } catch (error) {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias,
-      baseUrl,
-      repoSlug,
-      message: `Could not read remote project registry for ${repoSlug} on ${alias}: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-  if (registryResponse.status === 401 || registryResponse.status === 403) {
-    return remoteProjectLinkFailure({
-      status: "auth_required",
-      alias,
-      baseUrl,
-      repoSlug,
-      statusCode: registryResponse.status,
-      message: `Remote server ${alias} requires authentication before reading the ${repoSlug} project registry.`
-    });
-  }
-  if (registryResponse.ok) {
-    const candidates = checkoutPathsFromProjectPayload(registryResponse.payload);
-    for (const candidate of candidates) {
-      const result = await validateAndPersistRemoteRoot({ projectRoot, alias, baseUrl, authToken, repoSlug, candidate, source: "registry" });
-      if (result.ok || result.status === "auth_required")
-        return result;
-      skippedCandidates.push(candidate);
-    }
-    if (mode === "backfill-only") {
-      return remoteProjectLinkFailure({
-        status: candidates.length > 0 ? "invalid_root" : "no_server_checkout",
-        alias,
-        baseUrl,
-        repoSlug,
-        message: candidates.length > 0 ? `Remote registry has checkout candidates for ${repoSlug}, but none validated for ${alias}.` : `Remote registry has ${repoSlug}, but no server checkout path is linked yet.`,
-        skippedCandidates
-      });
-    }
-  } else if (registryResponse.status === 404) {
-    if (mode === "backfill-only") {
-      return remoteProjectLinkFailure({
-        status: "project_not_registered",
-        alias,
-        baseUrl,
-        repoSlug,
-        statusCode: registryResponse.status,
-        message: `Remote server ${alias} has no registered project record for ${repoSlug}.`
-      });
-    }
-  } else {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias,
-      baseUrl,
-      repoSlug,
-      statusCode: registryResponse.status,
-      message: `Could not backfill ${repoSlug} from remote registry (${registryResponse.status}): ${payloadError(registryResponse.payload, registryResponse.text || "registry lookup failed")}`,
-      skippedCandidates
-    });
-  }
-  let prepareResponse;
-  try {
-    prepareResponse = await requestRemoteProjectLinkJson(baseUrl, `/api/projects/${encodeURIComponent(repoSlug)}/prepare-checkout`, authToken, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ checkout: { kind: "managed-clone" }, repoUrl: `https://github.com/${repoSlug}.git` })
-    });
-  } catch (error) {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias,
-      baseUrl,
-      repoSlug,
-      message: `Could not prepare remote checkout for ${repoSlug} on ${alias}: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-  if (prepareResponse.status === 401 || prepareResponse.status === 403) {
-    return remoteProjectLinkFailure({
-      status: "auth_required",
-      alias,
-      baseUrl,
-      repoSlug,
-      statusCode: prepareResponse.status,
-      message: `Remote server ${alias} requires authentication before preparing ${repoSlug}.`
-    });
-  }
-  if (!prepareResponse.ok) {
-    return remoteProjectLinkFailure({
-      status: "error",
-      alias,
-      baseUrl,
-      repoSlug,
-      statusCode: prepareResponse.status,
-      message: `Remote checkout prepare failed for ${repoSlug} (${prepareResponse.status}): ${payloadError(prepareResponse.payload, prepareResponse.text || "prepare-checkout failed")}`,
-      skippedCandidates
-    });
-  }
-  const preparedPath = checkoutPathFromPreparePayload(prepareResponse.payload);
-  if (!preparedPath) {
-    return remoteProjectLinkFailure({
-      status: "invalid_root",
-      alias,
-      baseUrl,
-      repoSlug,
-      message: `Remote checkout prepare for ${repoSlug} did not return a checkout.path.`,
-      skippedCandidates
-    });
-  }
-  return validateAndPersistRemoteRoot({ projectRoot, alias, baseUrl, authToken, repoSlug, candidate: preparedPath, source: "prepare", prepared: true });
-}
-async function inspectRemoteProjectLink(projectRoot) {
-  return ensureRemoteProjectRootLink(projectRoot, { mode: "backfill-only" });
-}
-async function repairRemoteProjectRootLink(context, options = {}) {
-  const resolution = await ensureRemoteProjectRootLink(context.projectRoot, { mode: options.mode ?? "prepare-if-missing", repoSlug: options.repoSlug });
-  if (!resolution.ok)
-    throw new CliError(resolution.message, 1, { hint: resolution.hint });
-  return resolution;
-}
-async function ensureServerForCli(projectRoot) {
-  try {
-    const selected = resolveSelectedConnection(projectRoot);
-    if (selected?.connection.kind === "remote") {
-      reportServerPhase(`Connecting to ${selected.alias}\u2026`);
-      const authToken = readGitHubBearerTokenForRemote(projectRoot);
-      const link = await ensureRemoteProjectRootLink(projectRoot, { mode: "backfill-only", authToken });
-      return {
-        baseUrl: selected.connection.baseUrl,
-        authToken,
-        connectionKind: "remote",
-        serverProjectRoot: link.ok ? link.serverProjectRoot ?? null : null
-      };
-    }
-    reportServerPhase("Starting local Rig server\u2026");
-    const connection = await ensureLocalRigServerConnection(projectRoot);
-    return {
-      baseUrl: connection.baseUrl,
-      authToken: connection.authToken ?? readLocalConnectionFallbackToken(projectRoot),
-      connectionKind: "local",
-      serverProjectRoot: resolve2(projectRoot)
-    };
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new CliError(error.message, 1);
-    }
-    throw error;
-  }
-}
-function 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 mergeCookie(existing, name, value) {
-  const encoded = `${name}=${encodeURIComponent(value)}`;
-  if (!existing?.trim())
-    return encoded;
-  const parts = existing.split(";").map((part) => part.trim()).filter((part) => part && !part.startsWith(`${name}=`));
-  return [...parts, encoded].join("; ");
-}
-function queryAuthFallbackEnabled(env = process.env) {
-  return env.RIG_ENABLE_QUERY_AUTH_FALLBACK === "1" || env.RIG_QUERY_AUTH_FALLBACK === "1";
-}
-function mergeHeaders(headers, authToken) {
-  const merged = new Headers(headers);
-  if (authToken) {
-    const bearer = `Bearer ${authToken}`;
-    merged.set("authorization", bearer);
-    merged.set("x-auth", bearer);
-    merged.set("cookie", mergeCookie(merged.get("cookie"), "rig_auth", authToken));
-  }
-  return merged;
-}
-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>`."
-  };
-}
-function isLoopbackRemoteBaseUrl(baseUrl) {
-  try {
-    const host = new URL(baseUrl).hostname.toLowerCase();
-    return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
-  } catch {
-    return false;
-  }
-}
-function canUseRemoteWithoutProjectRoot(pathname) {
-  return pathname === "/health" || pathname === "/api/health" || pathname === "/api/server/status" || pathname === "/api/server/project-root" || pathname.startsWith("/api/github/auth/") || pathname === "/api/projects" || pathname.startsWith("/api/projects/");
-}
-async function requestServerJson(context, pathname, init = {}) {
-  const server = await ensureServerForCli(context.projectRoot);
-  const requestUrl = new URL(`${server.baseUrl}${pathname}`);
-  let scopedServerProjectRoot = server.serverProjectRoot;
-  if (server.connectionKind === "remote" && !scopedServerProjectRoot && !canUseRemoteWithoutProjectRoot(requestUrl.pathname) && (server.authToken || !isLoopbackRemoteBaseUrl(server.baseUrl))) {
-    const link = await ensureRemoteProjectRootLink(context.projectRoot, { mode: "backfill-only", authToken: server.authToken });
-    if (link.ok && link.serverProjectRoot) {
-      scopedServerProjectRoot = link.serverProjectRoot;
-    } else {
-      const repo = readRepoConnection(context.projectRoot);
-      const target = link.alias && link.baseUrl ? `${link.alias} (${link.baseUrl})` : server.baseUrl;
-      throw new CliError(`Remote server ${target} is selected for ${link.repoSlug ?? repo?.project ?? "this repo"}, but this checkout has no server-host project root link. ${link.message}`, 1, { hint: link.hint });
-    }
-  }
-  const headers = mergeHeaders(init.headers, server.authToken);
-  if (scopedServerProjectRoot)
-    headers.set("x-rig-project-root", scopedServerProjectRoot);
-  if (server.connectionKind === "remote" && server.authToken && queryAuthFallbackEnabled()) {
-    requestUrl.searchParams.set("rt", server.authToken);
-  }
-  reportServerPhase(`${(init.method ?? "GET").toUpperCase()} ${pathname.split("?")[0]}\u2026`);
-  let response;
-  try {
-    response = await fetch(requestUrl, {
-      ...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 server = await ensureServerForCli(context.projectRoot);
-  const requestUrl = new URL(`${server.baseUrl}/api/github/auth/token`);
-  reportServerPhase("POST /api/github/auth/token\u2026");
-  let response;
-  try {
-    response = await fetch(requestUrl, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ token, selectedRepo: options.selectedRepo, projectRoot: options.projectRoot ?? server.serverProjectRoot ?? undefined })
-    });
-  } catch (error) {
-    const failure = await buildServerFailureContext(context.projectRoot, server);
-    throw new CliError(`Rig server auth bootstrap failed: ${error instanceof Error ? error.message : String(error)}
-${failure.contextLine}`, 1, { hint: failure.hint });
-  }
-  const payload = await response.json().catch(() => null);
-  if (!response.ok) {
-    const detail = payload && typeof payload === "object" && !Array.isArray(payload) ? String(payload.error ?? JSON.stringify(payload)) : `HTTP ${response.status}`;
-    throw new CliError(`Rig server auth bootstrap failed (${response.status}): ${detail}`, 1, { hint: "Re-run `rig github auth import-gh`, or check the selected server with `rig server status`." });
-  }
-  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/_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/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/_async-ui.ts
-import pc 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 = pc.green("\u25C7");
-  FAIL_SYMBOL = pc.red("\u25A0");
-});
-
-// packages/cli/src/commands/_pi-frontend.ts
-var exports__pi_frontend = {};
-__export(exports__pi_frontend, {
-  shouldRequireOperatorTranscript: () => shouldRequireOperatorTranscript,
-  runWithProcessExitGuard: () => runWithProcessExitGuard,
-  missingOperatorTranscriptMessage: () => missingOperatorTranscriptMessage,
-  buildOperatorPiEnv: () => buildOperatorPiEnv,
-  attachRunBundledPiFrontend: () => attachRunBundledPiFrontend
-});
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, mkdtempSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir2, tmpdir } from "os";
-import { join } from "path";
-import { main as runPiMain } from "@earendil-works/pi-coding-agent";
-import createPiRigExtension from "@rig/pi-rig";
-function setTemporaryEnv(updates) {
-  const previous = new Map;
-  for (const [key, value] of Object.entries(updates)) {
-    previous.set(key, process.env[key]);
-    process.env[key] = value;
-  }
-  return () => {
-    for (const [key, value] of previous) {
-      if (value === undefined)
-        delete process.env[key];
-      else
-        process.env[key] = value;
-    }
-  };
-}
-function buildOperatorPiEnv(input) {
-  return {
-    PI_CODING_AGENT_SESSION_DIR: input.sessionDir,
-    PI_SKIP_VERSION_CHECK: "1",
-    PI_HIDDEN_COMMANDS: "import,fork,clone,tree,new,resume,trust",
-    RIG_PI_OPERATOR_SESSION: "1",
-    RIG_RUN_ID: input.runId,
-    RIG_SERVER_URL: input.serverUrl,
-    ...input.authToken ? { RIG_AUTH_TOKEN: input.authToken } : {},
-    ...input.serverProjectRoot ? { RIG_PROJECT_ROOT: input.serverProjectRoot } : {}
-  };
-}
-function shouldRequireOperatorTranscript(status) {
-  return typeof status === "string" && TERMINAL_RUN_STATUSES.has(status.trim().toLowerCase());
-}
-function missingOperatorTranscriptMessage(runId, status) {
-  const shortRun = runId.trim().slice(0, 8) || "unknown";
-  const statusText = typeof status === "string" && status.trim() ? status.trim() : "terminal";
-  return `Run ${shortRun} is ${statusText}, but no worker Pi session transcript is recorded for this run. It likely failed before Pi started or predates full-session capture. Use \`rig run show ${runId}\` and \`rig run logs ${runId}\` for the lifecycle details.`;
-}
-function statusFromRunDetails(run) {
-  if (!run || typeof run !== "object" || Array.isArray(run))
-    return;
-  const record = run;
-  if (typeof record.status === "string")
-    return record.status;
-  const nested = record.run;
-  return nested && typeof nested === "object" && !Array.isArray(nested) ? nested.status : undefined;
-}
-async function prepareOperatorConsole(context, runId, tempSessionDir) {
-  const server = await ensureServerForCli(context.projectRoot);
-  const localCwd = join(homedir2(), ".rig", "drones", runId.slice(0, 8));
-  mkdirSync3(localCwd, { recursive: true });
-  trustDroneCwd(localCwd);
-  installRigPiTheme();
-  let sessionFileArg = [];
-  try {
-    const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/session-file`);
-    if (payload?.ok && typeof payload.content === "string" && payload.content.trim()) {
-      const fileName = typeof payload.fileName === "string" && payload.fileName.trim() ? payload.fileName.replace(/[^A-Za-z0-9._-]/g, "_") : `rig-run-${runId}.jsonl`;
-      const localSessionPath = join(tempSessionDir, fileName);
-      const content = payload.content.split(`
-`).map((line, index) => {
-        if (index > 0 || !line.trim())
-          return line;
-        try {
-          const header = JSON.parse(line);
-          if (header.type === "session" && typeof header.cwd === "string") {
-            return JSON.stringify({ ...header, cwd: localCwd });
-          }
-        } catch {}
-        return line;
-      }).join(`
-`);
-      writeFileSync3(localSessionPath, content);
-      sessionFileArg = ["--session", localSessionPath];
-    }
-  } catch {}
-  if (sessionFileArg.length === 0) {
-    const run = await getRunDetailsViaServer(context, runId).catch(() => null);
-    const status = statusFromRunDetails(run);
-    if (shouldRequireOperatorTranscript(status)) {
-      throw new OperatorTranscriptUnavailableError(missingOperatorTranscriptMessage(runId, status));
-    }
-  }
-  return { server, sessionFileArg };
-}
-function trustDroneCwd(localCwd) {
-  try {
-    const agentDir = join(homedir2(), ".pi", "agent");
-    mkdirSync3(agentDir, { recursive: true });
-    const trustPath = join(agentDir, "trust.json");
-    const store = existsSync3(trustPath) ? JSON.parse(readFileSync3(trustPath, "utf8")) : {};
-    if (store[localCwd] !== true) {
-      store[localCwd] = true;
-      writeFileSync3(trustPath, `${JSON.stringify(store, null, "\t")}
-`);
-    }
-  } catch {}
-}
-function installRigPiTheme() {
-  try {
-    const themesDir = join(homedir2(), ".pi", "agent", "themes");
-    mkdirSync3(themesDir, { recursive: true });
-    const themePath = join(themesDir, "rig.json");
-    const next = `${JSON.stringify(RIG_PI_THEME, null, "\t")}
-`;
-    if (!existsSync3(themePath) || readFileSync3(themePath, "utf8") !== next) {
-      writeFileSync3(themePath, next);
-    }
-  } catch {}
-}
-async function runWithProcessExitGuard(body) {
-  const realExit = process.exit;
-  let exitCode = 0;
-  let signalQuit = () => {};
-  const quit = new Promise((resolve3) => {
-    signalQuit = resolve3;
-  });
-  const guardedExit = (code) => {
-    exitCode = typeof code === "number" ? code : 0;
-    signalQuit();
-    return;
-  };
-  process.exit = guardedExit;
-  try {
-    await Promise.race([Promise.resolve().then(body), quit]);
-  } finally {
-    process.exit = realExit;
-  }
-  return exitCode;
-}
-function runPiMainReturningOnQuit(args, options) {
-  return runWithProcessExitGuard(() => runPiMain(args, options));
-}
-async function attachRunBundledPiFrontend(context, input) {
-  const tempSessionDir = mkdtempSync(join(tmpdir(), "rig-pi-frontend-sessions-"));
-  const { server, sessionFileArg } = await withSpinner(`Opening Pi console for run ${input.runId}\u2026`, () => prepareOperatorConsole(context, input.runId, tempSessionDir), { outputMode: context.outputMode });
-  const restoreEnv = setTemporaryEnv(buildOperatorPiEnv({
-    runId: input.runId,
-    serverUrl: server.baseUrl,
-    authToken: server.authToken,
-    serverProjectRoot: server.serverProjectRoot,
-    sessionDir: tempSessionDir
-  }));
-  const piRigExtensionFactory = (pi) => {
-    createPiRigExtension(pi);
-  };
-  let detached = false;
-  try {
-    const piArgs = [
-      "--offline",
-      "--no-extensions",
-      "--no-skills",
-      "--no-prompt-templates",
-      "--no-context-files",
-      ...sessionFileArg
-    ];
-    const piOptions = { extensionFactories: [piRigExtensionFactory] };
-    if (input.returnOnQuit) {
-      await runPiMainReturningOnQuit(piArgs, piOptions);
-    } else {
-      await runPiMain(piArgs, piOptions);
-    }
-    detached = true;
-  } finally {
-    restoreEnv();
-    rmSync(tempSessionDir, { recursive: true, force: true });
-  }
-  let run = { runId: input.runId, status: "unknown" };
-  try {
-    run = await getRunDetailsViaServer(context, input.runId);
-  } catch {}
-  return {
-    run,
-    logs: [],
-    timeline: [],
-    timelineCursor: null,
-    steered: input.steered === true,
-    detached,
-    rendered: "stock Pi operator console with the pi-rig extension"
-  };
-}
-var TERMINAL_RUN_STATUSES, OperatorTranscriptUnavailableError, RIG_PI_THEME;
-var init__pi_frontend = __esm(() => {
-  init__server_client();
-  init__async_ui();
-  TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
-  OperatorTranscriptUnavailableError = class OperatorTranscriptUnavailableError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "OperatorTranscriptUnavailableError";
-    }
-  };
-  RIG_PI_THEME = {
-    $schema: "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
-    name: "rig",
-    vars: {
-      acid: "#ccff4d",
-      acidDim: "#a9d63f",
-      cyan: "#56d8ff",
-      red: "#ff5d5d",
-      yellow: "#ffd24d",
-      ink: "#f2f3f6",
-      ink2: "#aeb0ba",
-      ink3: "#6c6e79",
-      ink4: "#44464f",
-      panel: "#101115",
-      panelUser: "#14161b",
-      toolPending: "#0e1013",
-      toolSuccess: "#10150c",
-      toolError: "#1a0f0f",
-      customMsg: "#0f1410"
-    },
-    colors: {
-      accent: "acid",
-      border: "ink4",
-      borderAccent: "acid",
-      borderMuted: "ink4",
-      success: "acid",
-      error: "red",
-      warning: "yellow",
-      muted: "ink3",
-      dim: "ink4",
-      text: "ink",
-      thinkingText: "ink3",
-      selectedBg: "panel",
-      userMessageBg: "panelUser",
-      userMessageText: "ink",
-      customMessageBg: "customMsg",
-      customMessageText: "ink2",
-      customMessageLabel: "acidDim",
-      toolPendingBg: "toolPending",
-      toolSuccessBg: "toolSuccess",
-      toolErrorBg: "toolError",
-      toolTitle: "ink",
-      toolOutput: "ink3",
-      mdHeading: "acid",
-      mdLink: "cyan",
-      mdLinkUrl: "ink4",
-      mdCode: "acidDim",
-      mdCodeBlock: "ink2",
-      mdCodeBlockBorder: "ink4",
-      mdQuote: "ink3",
-      mdQuoteBorder: "ink4",
-      mdHr: "ink4",
-      mdListBullet: "acid",
-      toolDiffAdded: "acid",
-      toolDiffRemoved: "red",
-      toolDiffContext: "ink3",
-      syntaxComment: "ink3",
-      syntaxKeyword: "cyan",
-      syntaxFunction: "acid",
-      syntaxVariable: "ink",
-      syntaxString: "acidDim",
-      syntaxNumber: "yellow",
-      syntaxType: "cyan",
-      syntaxOperator: "ink2",
-      syntaxPunctuation: "ink3",
-      thinkingOff: "ink4",
-      thinkingMinimal: "ink3",
-      thinkingLow: "ink2",
-      thinkingMedium: "cyan",
-      thinkingHigh: "acidDim",
-      thinkingXhigh: "acid",
-      bashMode: "cyan"
-    }
-  };
-});
-
-// packages/cli/src/app-opentui/adapters/inspect.ts
-var exports_inspect = {};
-__export(exports_inspect, {
-  loadInspectRuns: () => loadInspectRuns,
-  loadInspect: () => loadInspect,
-  INSPECT_VIEWS: () => INSPECT_VIEWS
-});
-import { execFile } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync, statSync } from "fs";
-import { resolve as resolve3 } from "path";
-import { promisify } from "util";
-import { resolveTaskArtifactDirs } from "@rig/runtime/control-plane/authority-files";
-import { readTaskArtifactPreview } from "@rig/runtime/control-plane/native/workspace-ops";
-import { resolveHarnessPaths, resolveMonorepoRoot, runCapture } from "@rig/runtime/control-plane/native/utils";
-function isFailureEntry(entry) {
-  const status = `${entry.status ?? entry.level ?? entry.type ?? ""}`.toLowerCase();
-  return status.includes("fail") || status.includes("error");
-}
-async function gitDiff(projectRoot) {
-  try {
-    const { stdout } = await execFileAsync("git", ["diff", "--no-color"], { cwd: projectRoot, maxBuffer: 8 * 1024 * 1024 });
-    return { diff: stdout };
-  } catch (error) {
-    return { diff: "", error: normalizeAppError(error).message };
-  }
-}
-function listArtifacts(projectRoot, taskId) {
-  if (!taskId)
-    return { artifacts: [], error: "run has no task id \u2014 artifacts are resolved per task" };
-  try {
-    const dirs = resolveTaskArtifactDirs(projectRoot, taskId).filter((dir) => existsSync4(dir));
-    const out = [];
-    const seen = new Set;
-    for (const dir of dirs) {
-      for (const name of readdirSync(dir)) {
-        if (seen.has(name))
-          continue;
-        seen.add(name);
-        const path = resolve3(dir, name);
-        try {
-          const stat = statSync(path);
-          out.push({ name, path, sizeBytes: stat.size, isDir: stat.isDirectory() });
-        } catch {
-          out.push({ name, path, sizeBytes: 0, isDir: false });
-        }
-      }
-    }
-    out.sort((left, right) => left.name.localeCompare(right.name));
-    return { artifacts: out };
-  } catch (error) {
-    return { artifacts: [], error: normalizeAppError(error).message };
-  }
-}
-function readArtifact(projectRoot, taskId, fileName) {
-  if (!taskId)
-    return;
-  try {
-    const preview = readTaskArtifactPreview(projectRoot, taskId, fileName);
-    return { name: fileName, contents: preview.contents, truncated: preview.truncated, sizeBytes: preview.sizeBytes };
-  } catch (error) {
-    return { name: fileName, contents: `Failed to read artifact: ${normalizeAppError(error).message}`, truncated: false, sizeBytes: 0 };
-  }
-}
-function loadGraph(projectRoot) {
-  try {
-    const result = runCapture(["br", "--no-db", "list", "--pretty"], resolveMonorepoRoot(projectRoot));
-    if (result.exitCode !== 0)
-      return { graph: "", error: result.stderr || result.stdout || "failed to inspect graph" };
-    return { graph: result.stdout };
-  } catch (error) {
-    return { graph: "", error: normalizeAppError(error).message };
-  }
-}
-function loadAudit(projectRoot) {
-  try {
-    const auditPath = resolve3(resolveHarnessPaths(projectRoot).logsDir, "audit.jsonl");
-    if (!existsSync4(auditPath))
-      return [];
-    return readFileSync4(auditPath, "utf-8").split(/\r?\n/).filter(Boolean).slice(-50).flatMap((raw) => {
-      try {
-        const parsed = JSON.parse(raw);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? [parsed] : [{ detail: raw }];
-      } catch {
-        return [{ detail: raw }];
-      }
-    });
-  } catch {
-    return [];
-  }
-}
-async function loadInspectRuns(ctx, options = {}) {
-  const label = "Loading runs to inspect";
-  emitStarted(ctx, label);
-  try {
-    const projectRoot = projectRootOf(ctx);
-    const { listRunsViaServer: listRunsViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
-    emitProgress(ctx, label, "listing recent runs");
-    const runs = await listRunsViaServer2({ projectRoot }, { limit: options.limit ?? 50 });
-    const options_ = runs.flatMap((record) => {
-      const runId = stringField(record, ["runId", "id"]);
-      if (!runId)
-        return [];
-      const taskId = stringField(record, ["taskId"]);
-      const updatedAt = stringField(record, ["updatedAt", "createdAt"]);
-      return [{
-        runId,
-        status: stringField(record, ["status", "state"], "unknown"),
-        title: stringField(record, ["title", "taskTitle", "taskId"], "untitled run"),
-        ...taskId ? { taskId } : {},
-        ...updatedAt ? { updatedAt } : {}
-      }];
-    });
-    patchData(ctx, { inspectRuns: options_, lastRefreshError: undefined });
-    emitCompleted(ctx, label, { count: options_.length });
-    return options_;
-  } catch (error) {
-    emitFailed(ctx, label, error);
-    throw error;
-  }
-}
-async function loadInspect(ctx, runId) {
-  const cleanRunId = runId.trim();
-  const label = `Inspecting run ${cleanRunId.slice(0, 8)}`;
-  if (!cleanRunId) {
-    await loadInspectRuns(ctx).catch(() => []);
-    const error = new Error("Inspect requires a run id.");
-    throw error;
-  }
-  emitStarted(ctx, label);
-  try {
-    const projectRoot = projectRootOf(ctx);
-    const { getRunDetailsViaServer: getRunDetailsViaServer2, getRunLogsViaServer: getRunLogsViaServer2, getRunTimelineViaServer: getRunTimelineViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
-    const context = { projectRoot };
-    emitProgress(ctx, label, "loading logs, timeline, diff, artifacts, graph, and audit");
-    const [runPayload, logsPayload, timelinePayload, diffResult] = await Promise.all([
-      getRunDetailsViaServer2(context, cleanRunId).catch((error) => ({ error: normalizeAppError(error).message })),
-      getRunLogsViaServer2(context, cleanRunId, { limit: 500 }).catch(() => []),
-      getRunTimelineViaServer2(context, cleanRunId, { limit: 500 }).catch(() => []),
-      gitDiff(projectRoot)
-    ]);
-    const run = runPayload && typeof runPayload === "object" && "run" in runPayload && runPayload.run && typeof runPayload.run === "object" ? runPayload.run : runPayload;
-    const logs = arrayFromPayload(logsPayload);
-    const timeline = arrayFromPayload(timelinePayload);
-    const taskId = stringField(run, ["taskId"]) || undefined;
-    const { artifacts, error: artifactsError } = listArtifacts(projectRoot, taskId);
-    const { graph, error: graphError } = loadGraph(projectRoot);
-    const audit = loadAudit(projectRoot);
-    const state = ctx.getState();
-    const selectedArtifact = typeof state.data?.inspectArtifact === "string" ? state.data.inspectArtifact : undefined;
-    const artifactView = selectedArtifact ? readArtifact(projectRoot, taskId, selectedArtifact) : undefined;
-    const snapshot = {
-      runId: cleanRunId,
-      status: stringField(run, ["status", "state"], "unknown"),
-      title: stringField(run, ["title", "taskId", "id"], "untitled run"),
-      logs,
-      timeline,
-      diff: diffResult.diff,
-      failures: [...logs, ...timeline].filter(isFailureEntry),
-      artifacts,
-      graph,
-      audit,
-      refreshedAt: Date.now(),
-      ...taskId ? { taskId } : {},
-      ...artifactView ? { artifactView } : {},
-      ...diffResult.error ? { diffError: diffResult.error } : {},
-      ...graphError ? { graphError } : {},
-      ...artifactsError ? { artifactsError } : {}
-    };
-    patchData(ctx, { inspect: snapshot, lastRefreshError: undefined });
-    emitCompleted(ctx, label, {
-      runId: cleanRunId,
-      logs: logs.length,
-      timeline: timeline.length,
-      diffBytes: snapshot.diff.length,
-      artifacts: artifacts.length,
-      audit: audit.length
-    });
-    return snapshot;
-  } catch (error) {
-    emitFailed(ctx, label, error, { runId: cleanRunId });
-    throw error;
-  }
-}
-var execFileAsync, INSPECT_VIEWS;
-var init_inspect = __esm(() => {
-  execFileAsync = promisify(execFile);
-  INSPECT_VIEWS = [
-    "logs",
-    "timeline",
-    "artifacts",
-    "artifact",
-    "diff",
-    "failures",
-    "graph",
-    "audit"
-  ];
-});
-// packages/cli/src/app-opentui/adapters/fleet.ts
-function normalizeRunRecord(record) {
-  const runId = stringField(record, ["runId", "id"]);
-  if (!runId)
-    return null;
-  const title = stringField(record, ["title", "taskTitle", "taskId"], "untitled run");
-  const taskId = stringField(record, ["taskId"]);
-  const updatedAt = stringField(record, ["updatedAt", "createdAt"]);
-  return {
-    runId,
-    status: stringField(record, ["status", "state"], "unknown"),
-    title,
-    raw: record,
-    ...taskId ? { taskId } : {},
-    ...updatedAt ? { updatedAt } : {}
-  };
-}
-async function refreshFleet(ctx, options = {}) {
-  const label = "Refreshing fleet";
-  emitStarted(ctx, label);
-  try {
-    const { listRunsViaServer: listRunsViaServer2, resolveServerConnectionLabel: resolveServerConnectionLabel2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
-    const projectRoot = projectRootOf(ctx);
-    emitProgress(ctx, label, "contacting selected server");
-    const [runs, serverLabel] = await Promise.all([
-      listRunsViaServer2({ projectRoot }, { limit: options.limit ?? 50 }),
-      resolveServerConnectionLabel2(projectRoot)
-    ]);
-    const normalized = runs.flatMap((run) => {
-      const entry = normalizeRunRecord(run);
-      return entry ? [entry] : [];
-    });
-    patchData(ctx, { fleet: { runs: normalized, refreshedAt: new Date().toISOString() }, lastRefreshError: undefined });
-    patchFooter(ctx, { server: serverLabel, runs: String(normalized.length) });
-    emitCompleted(ctx, label, { count: normalized.length });
-    return normalized;
-  } catch (error) {
-    emitFailed(ctx, label, error);
-    throw error;
-  }
-}
-
-// packages/cli/src/app-opentui/adapters/pi-attach.ts
-function currentAttachState(ctx, runId) {
-  const value = ctx.getState().data?.piAttach;
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const state = value;
-  return state.runId === runId ? state : null;
-}
-function recordStep(ctx, runId, label, emitLabel) {
-  const now = Date.now();
-  const previous = currentAttachState(ctx, runId);
-  const priorSteps = previous?.steps ?? [];
-  const settled = priorSteps.map((step) => step.status === "running" ? { ...step, status: "done", endedAtMs: step.endedAtMs ?? now } : step);
-  const steps = [...settled, { label, startedAtMs: now, status: "running" }];
-  patchData(ctx, {
-    piAttach: { ...previous ?? { runId, status: "preparing", message: label }, runId, steps }
-  });
-  emitProgress(ctx, emitLabel, label);
-}
-async function preparePiAttachHandoff(ctx, runId) {
-  const cleanRunId = runId.trim();
-  const label = `Preparing Pi ${cleanRunId.slice(0, 8)}`;
-  emitStarted(ctx, label, { piAttach: { runId: cleanRunId, status: "preparing" } });
-  try {
-    const { getRunDetailsViaServer: getRunDetailsViaServer2, getRunPiStatusViaServer: getRunPiStatusViaServer2, resolveServerConnectionLabel: resolveServerConnectionLabel2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
-    const projectRoot = projectRootOf(ctx);
-    recordStep(ctx, cleanRunId, "connecting to server \xB7 checking run and Pi session readiness", label);
-    const [run, piStatus, server] = await Promise.all([
-      getRunDetailsViaServer2({ projectRoot }, cleanRunId).catch((error) => ({ error: error instanceof Error ? error.message : String(error) })),
-      getRunPiStatusViaServer2({ projectRoot }, cleanRunId).catch((error) => ({ error: error instanceof Error ? error.message : String(error) })),
-      resolveServerConnectionLabel2(projectRoot)
-    ]);
-    const state = {
-      runId: cleanRunId,
-      status: "preparing",
-      message: "ready to enter worker Pi",
-      result: { run, piStatus, server },
-      ready: true,
-      ...currentAttachState(ctx, cleanRunId)?.steps ? { steps: currentAttachState(ctx, cleanRunId).steps } : {}
-    };
-    patchData(ctx, { piAttach: state, lastRefreshError: undefined });
-    emitCompleted(ctx, label, { runId: cleanRunId, server });
-    return state;
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    const state = {
-      runId: cleanRunId,
-      status: "failed",
-      message: reason,
-      failureReason: reason,
-      ...currentAttachState(ctx, cleanRunId)?.steps ? { steps: currentAttachState(ctx, cleanRunId).steps } : {}
-    };
-    patchData(ctx, { piAttach: state });
-    emitFailed(ctx, label, error, { runId: cleanRunId });
-    throw error;
-  }
-}
-async function attachRunWithBundledPi(ctx, runId) {
-  const cleanRunId = runId.trim();
-  const label = `Entering Pi ${cleanRunId.slice(0, 8)}`;
-  if (!cleanRunId) {
-    const error = new Error("Attach requires a run id.");
-    emitFailed(ctx, label, error);
-    throw error;
-  }
-  emitStarted(ctx, label, { piAttach: { runId: cleanRunId, status: "entering-pi" } });
-  patchData(ctx, { piAttach: { runId: cleanRunId, status: "entering-pi", message: "handing the terminal to worker Pi\u2026" } });
-  const projectRoot = projectRootOf(ctx);
-  const outputMode = ctx.rig?.outputMode ?? "text";
-  await releaseRendererForExternalTui(ctx);
-  let outcome = null;
-  let attachError = null;
-  try {
-    const { attachRunBundledPiFrontend: attachRunBundledPiFrontend2 } = await Promise.resolve().then(() => (init__pi_frontend(), exports__pi_frontend));
-    outcome = await attachRunBundledPiFrontend2({ projectRoot, outputMode }, { runId: cleanRunId, returnOnQuit: true });
-  } catch (error) {
-    attachError = error;
-  } finally {
-    await resumeRendererAfterExternalTui(ctx);
-  }
-  if (attachError) {
-    const reason = normalizeAppError(attachError).message;
-    patchData(ctx, {
-      piTerminal: undefined,
-      piAttach: { runId: cleanRunId, status: "failed", message: reason, failureReason: reason }
-    });
-    Promise.resolve().then(() => (init_inspect(), exports_inspect)).then(({ loadInspect: loadInspect2 }) => loadInspect2(ctx, cleanRunId)).catch(() => null);
-    emitFailed(ctx, label, attachError, { runId: cleanRunId });
-    throw attachError;
-  }
-  const detached = outcome?.detached === true;
-  patchData(ctx, {
-    piTerminal: undefined,
-    piAttach: { runId: cleanRunId, status: "returned", message: detached ? "detached from worker Pi" : "returned from worker Pi" }
-  });
-  emitCompleted(ctx, label, { runId: cleanRunId, result: { runId: cleanRunId, detached } });
-  ctx.emit({ type: "scene.change", scene: "fleet", intent: { scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } } });
-  refreshFleet(ctx).catch((error) => emitFailed(ctx, "Refresh runs", error));
-  return { runId: cleanRunId, status: "returned", detached };
-}
-export {
-  preparePiAttachHandoff,
-  attachRunWithBundledPi
-};