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

package/dist/src/commands.js

@@ -107,7 +107,6 @@ function statusColor(status) {
     case "validating":
     case "reviewing":
     case "closing-out":
-    case "stopping":
       return cyan;
     case "needs-attention":
     case "needs_attention":
@@ -244,7 +243,7 @@ function createTtySpinner(input) {
       output.write("\r\x1B[2K");
   };
   render();
-  const timer = isTty ? setInterval(render, input.intervalMs ?? 16) : null;
+  const timer = isTty ? setInterval(render, input.intervalMs ?? 120) : null;
   return {
     setLabel(next) {
       label = next;
@@ -864,28 +863,12 @@ function readRepoConnection(projectRoot) {
     selected,
     project: typeof record.project === "string" ? record.project : undefined,
     linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
-    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined,
-    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
+    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined
   };
 }
 function writeRepoConnection(projectRoot, state) {
   writeJsonFile2(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)
@@ -897,41 +880,13 @@ function resolveSelectedConnection(projectRoot, options = {}) {
   if (!connection) {
     throw new CliError(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
   }
-  return { alias: repo.selected, connection, serverProjectRoot: rootAllowedForSelection(repo, connection) };
+  return { alias: repo.selected, connection, serverProjectRoot: repo.serverProjectRoot };
 }
-function writeRepoServerProjectRoot(projectRoot, serverProjectRoot, metadata = {}) {
+function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
   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 } : {}
-  });
+  writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
 }
 function isRemoteConnectionSelected(projectRoot) {
   return resolveSelectedConnection(projectRoot)?.connection.kind === "remote";
@@ -941,8 +896,8 @@ var init__connection_state = __esm(() => {
 });
 
 // packages/cli/src/commands/_server-client.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname3, isAbsolute, resolve as resolve10 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve10 } from "path";
 import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
 function setServerPhaseListener(listener) {
   const previous = serverPhaseListener;
@@ -960,21 +915,17 @@ function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
   const scopedKey = resolve10(projectRoot ?? process.cwd());
   scopedGitHubBearerTokens.set(scopedKey, cleanToken(token ?? undefined));
 }
-function readRemoteAuthState(projectRoot) {
+function readPrivateRemoteSessionToken(projectRoot) {
   const path = resolve10(projectRoot, ".rig", "state", "github-auth.json");
   if (!existsSync6(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync4(path, "utf8"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    return cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined);
   } 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 = resolve10(projectRoot);
   if (scopedGitHubBearerTokens.has(scopedKey))
@@ -985,421 +936,18 @@ function readGitHubBearerTokenForRemote(projectRoot) {
   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 = resolve10(projectRoot, ".rig", "state", "project-link.json");
+  const path = resolve10(projectRoot, ".rig", "state", "github-auth.json");
   if (!existsSync6(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync4(path, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-      return null;
-    return normalizeRepoSlug(typeof parsed.repoSlug === "string" ? String(parsed.repoSlug) : null);
+    return cleanToken(typeof parsed.token === "string" ? parsed.token : undefined);
   } catch {
     return null;
   }
 }
-function writeProjectLinkConnection(projectRoot, repoSlug, alias) {
-  const path = resolve10(projectRoot, ".rig", "state", "project-link.json");
-  mkdirSync6(dirname3(path), { recursive: true });
-  writeFileSync5(path, `${JSON.stringify({ repoSlug, connection: alias, linkedAt: new Date().toISOString() }, null, 2)}
-`, "utf8");
-}
-function remoteLinkRepairCommand(repoSlug) {
-  return repoSlug ? `rig server repair-link --repo ${repoSlug}` : "rig server repair-link --repo owner/repo";
-}
-function formatRemoteProjectLinkHint(resolution) {
-  const repair = remoteLinkRepairCommand(resolution.repoSlug);
-  if (resolution.status === "auth_required") {
-    return `Authenticate the selected remote${resolution.alias ? ` (${resolution.alias})` : ""}, then run \`${repair}\`. Use \`rig github auth import-gh\` or \`rig init --repair --server remote --github-auth device${resolution.repoSlug ? ` --repo ${resolution.repoSlug}` : ""}\`.`;
-  }
-  if (resolution.status === "missing_project") {
-    return `Record the repo slug, then run \`${repair}\` (or \`rig init --repo owner/repo --server remote --github-auth device\`).`;
-  }
-  if (resolution.status === "not_remote")
-    return "Select a remote server with `rig server use <alias>` before repairing a remote project link.";
-  return `Run \`${repair}\` to backfill or prepare a server-host checkout for the selected remote${resolution.alias ? ` (${resolution.alias})` : ""}.`;
-}
-function remoteProjectLinkFailure(input) {
-  const partial = {
-    status: input.status,
-    alias: input.alias,
-    baseUrl: input.baseUrl,
-    repoSlug: input.repoSlug
-  };
-  return {
-    ok: false,
-    ...input,
-    hint: formatRemoteProjectLinkHint(partial),
-    next: remoteLinkRepairCommand(input.repoSlug)
-  };
-}
-function remoteProjectLinkSuccess(input) {
-  return {
-    ok: true,
-    status: input.status,
-    alias: input.alias,
-    baseUrl: input.baseUrl,
-    repoSlug: input.repoSlug,
-    serverProjectRoot: input.serverProjectRoot,
-    source: input.source,
-    prepared: input.prepared ?? input.status === "prepared",
-    validated: input.validated ?? false,
-    message: input.message ?? `Remote project link ready for ${input.repoSlug}.`,
-    hint: "Remote-scoped task/run/status requests will send x-rig-project-root for this server-host checkout.",
-    next: "rig task list"
-  };
-}
-function localCheckoutPathCandidate(projectRoot, candidate) {
-  try {
-    const local = resolve10(projectRoot);
-    const resolved = resolve10(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 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;
+function readLocalConnectionFallbackToken(projectRoot) {
+  return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
 }
 async function ensureServerForCli(projectRoot) {
   try {
@@ -1407,12 +955,12 @@ async function ensureServerForCli(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 });
+      const serverProjectRoot = selected.serverProjectRoot ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
       return {
         baseUrl: selected.connection.baseUrl,
         authToken,
         connectionKind: "remote",
-        serverProjectRoot: link.ok ? link.serverProjectRoot ?? null : null
+        serverProjectRoot
       };
     }
     reportServerPhase("Starting local Rig server\u2026");
@@ -1430,6 +978,29 @@ async function ensureServerForCli(projectRoot) {
     throw error;
   }
 }
+async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken) {
+  const repo = readRepoConnection(projectRoot);
+  const slug = repo?.project?.trim();
+  if (!slug)
+    return null;
+  try {
+    const 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);
@@ -1440,23 +1011,10 @@ function appendTaskFilterParams(url, filters) {
   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));
+    merged.set("authorization", `Bearer ${authToken}`);
   }
   return merged;
 }
@@ -1516,41 +1074,15 @@ async function buildServerFailureContext(projectRoot, server) {
     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);
-  }
+  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(requestUrl, {
+    response = await fetch(`${server.baseUrl}${pathname}`, {
       ...init,
       headers
     });
@@ -1612,26 +1144,11 @@ async function getGitHubAuthStatusViaServer(context) {
   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`." });
-  }
+  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) {
@@ -1909,14 +1426,6 @@ function permissionAllowsPr(payload) {
 function isNotFoundError(error) {
   return /\b(404|not found)\b/i.test(message(error));
 }
-function isLoopbackBaseUrl(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 projectCheckoutReady(payload) {
   if (!payload || typeof payload !== "object" || Array.isArray(payload))
     return null;
@@ -1970,38 +1479,25 @@ async function runFastTaskRunPreflight(context, options = {}) {
     }
   }
   const repo = readRepoConnection(context.projectRoot);
-  const remoteWithoutProjectLink = selectedServer?.connectionKind === "remote" && !repo?.project;
-  let remoteRootBlocked = false;
-  checks.push(repo ? preflightCheck("project-link", "project linked to selected server", repo.project ? "pass" : remoteWithoutProjectLink ? "fail" : "warn", `${repo.selected}${repo.project ? ` -> ${repo.project}` : " (missing project link)"}`, remoteWithoutProjectLink ? "Run `rig server repair-link --repo owner/repo` or `rig init --repo owner/repo --server remote` to restore the remote project link." : "Run `rig init --yes --repo owner/repo` to record the GitHub repo slug.") : preflightCheck("project-link", "project linked to selected server", legacyServerCompatibility ? "warn" : "fail", "missing .rig/state/connection.json", "Run `rig init` or `rig server use <alias|local>`."));
-  if (selectedServer?.connectionKind === "remote" && repo?.project && !selectedServer.serverProjectRoot) {
-    const link = await ensureRemoteProjectRootLink(context.projectRoot, { mode: "backfill-only", authToken: selectedServer.authToken });
-    const loopbackDevRemote = !selectedServer.authToken && isLoopbackBaseUrl(selectedServer.baseUrl);
-    checks.push(preflightCheck("remote-project-root-link", "remote server checkout/root linked", link.ok ? "pass" : loopbackDevRemote ? "warn" : "fail", link.ok ? `${link.repoSlug} -> ${link.serverProjectRoot}` : link.message, link.ok ? undefined : loopbackDevRemote ? "Loopback development remotes may continue without x-rig-project-root; production remotes must run `rig server repair-link`." : link.hint));
-    remoteRootBlocked = !link.ok && !loopbackDevRemote;
-  }
+  checks.push(repo ? preflightCheck("project-link", "project linked to Rig server", repo.project ? "pass" : "warn", `${repo.selected}${repo.project ? ` -> ${repo.project}` : ""}`, "Run `rig init --yes --repo owner/repo` to record the GitHub repo slug.") : preflightCheck("project-link", "project linked to Rig server", legacyServerCompatibility ? "warn" : "fail", "missing .rig/state/connection.json", "Run `rig init` or `rig server use <alias|local>`."));
   try {
     const auth = await request("/api/github/auth/status");
     checks.push(isAuthenticated(auth) ? preflightCheck("github-auth", "GitHub auth valid", "pass") : preflightCheck("github-auth", "GitHub auth valid", legacyServerCompatibility ? "warn" : "fail", "not authenticated", "Run `rig github auth import-gh` or `rig github auth token --token <token>`."));
   } catch (error) {
     checks.push(preflightCheck("github-auth", "GitHub auth valid", legacyServerCompatibility ? "warn" : "fail", message(error), "Fix GitHub auth on the selected Rig server."));
   }
-  if (!remoteRootBlocked) {
-    try {
-      const projection = await request("/api/workspace/task-projection");
-      checks.push(preflightCheck("task-projection", "task projection ready", "pass", JSON.stringify(projection).slice(0, 120)));
-    } catch (error) {
-      checks.push(preflightCheck("task-projection", "task projection ready", "warn", message(error), "Refresh task projection with `rig task list` before launching."));
-    }
-    try {
-      const permissions = await request("/api/github/repo/permissions");
-      const allowed = permissionAllowsPr(permissions);
-      checks.push(allowed === false ? preflightCheck("github-repo-permissions", "GitHub PR permissions", "fail", JSON.stringify(permissions).slice(0, 120), "Grant the selected GitHub token permission to push branches and open PRs.") : preflightCheck("github-repo-permissions", "GitHub PR permissions", allowed === true ? "pass" : "warn", JSON.stringify(permissions).slice(0, 120), "Confirm the selected token can push branches and open PRs."));
-    } catch (error) {
-      checks.push(preflightCheck("github-repo-permissions", "GitHub PR permissions", "warn", message(error), "Ensure the selected token can push branches and open PRs."));
-    }
-  } else {
-    checks.push(preflightCheck("task-projection", "task projection ready", "warn", "skipped until remote project-root link is repaired", "Run `rig server repair-link`, then retry."));
-    checks.push(preflightCheck("github-repo-permissions", "GitHub PR permissions", "warn", "skipped until remote project-root link is repaired", "Run `rig server repair-link`, then retry."));
+  try {
+    const projection = await request("/api/workspace/task-projection");
+    checks.push(preflightCheck("task-projection", "task projection ready", "pass", JSON.stringify(projection).slice(0, 120)));
+  } catch (error) {
+    checks.push(preflightCheck("task-projection", "task projection ready", "warn", message(error), "Refresh task projection with `rig task list` before launching."));
+  }
+  try {
+    const permissions = await request("/api/github/repo/permissions");
+    const allowed = permissionAllowsPr(permissions);
+    checks.push(allowed === false ? preflightCheck("github-repo-permissions", "GitHub PR permissions", "fail", JSON.stringify(permissions).slice(0, 120), "Grant the selected GitHub token permission to push branches and open PRs.") : preflightCheck("github-repo-permissions", "GitHub PR permissions", allowed === true ? "pass" : "warn", JSON.stringify(permissions).slice(0, 120), "Confirm the selected token can push branches and open PRs."));
+  } catch (error) {
+    checks.push(preflightCheck("github-repo-permissions", "GitHub PR permissions", "warn", message(error), "Ensure the selected token can push branches and open PRs."));
   }
   if (repo?.project) {
     try {
@@ -2013,24 +1509,19 @@ async function runFastTaskRunPreflight(context, options = {}) {
     }
   }
   if (taskId) {
-    if (!remoteRootBlocked) {
-      try {
-        const tasks = await request(`/api/workspace/tasks?limit=200&refresh=1`);
-        const found = Array.isArray(tasks) && tasks.some((task) => taskMatchesId(task, taskId));
-        checks.push(found ? preflightCheck("issue", "task/issue accessible", "pass", taskId) : preflightCheck("issue", "task/issue accessible", legacyServerCompatibility ? "warn" : "fail", taskId, "Confirm the issue exists and matches the configured task filters."));
-      } catch (error) {
-        checks.push(preflightCheck("issue", "task/issue accessible", legacyServerCompatibility ? "warn" : "fail", message(error), "Fix the task source before launching a run."));
-      }
-      try {
-        const runs = await request("/api/runs?limit=200");
-        const duplicate = activeDuplicateRun(runs, taskId);
-        checks.push(duplicate ? preflightCheck("duplicate-active-run", "one active run per task", "fail", String(duplicate.runId ?? taskId), "Attach to or stop the existing run before starting another one for this task.") : preflightCheck("duplicate-active-run", "one active run per task", "pass", taskId));
-      } catch (error) {
-        checks.push(preflightCheck("duplicate-active-run", "one active run per task", "warn", message(error), "Could not list active runs; the server will still reject conflicting runs if configured."));
-      }
-    } else {
-      checks.push(preflightCheck("issue", "task/issue accessible", "fail", "skipped until remote project-root link is repaired", "Run `rig server repair-link`, then retry."));
-      checks.push(preflightCheck("duplicate-active-run", "one active run per task", "warn", "skipped until remote project-root link is repaired", "Run `rig server repair-link`, then retry."));
+    try {
+      const tasks = await request(`/api/workspace/tasks?limit=200&refresh=1`);
+      const found = Array.isArray(tasks) && tasks.some((task) => taskMatchesId(task, taskId));
+      checks.push(found ? preflightCheck("issue", "task/issue accessible", "pass", taskId) : preflightCheck("issue", "task/issue accessible", legacyServerCompatibility ? "warn" : "fail", taskId, "Confirm the issue exists and matches the configured task filters."));
+    } catch (error) {
+      checks.push(preflightCheck("issue", "task/issue accessible", legacyServerCompatibility ? "warn" : "fail", message(error), "Fix the task source before launching a run."));
+    }
+    try {
+      const runs = await request("/api/runs?limit=200");
+      const duplicate = activeDuplicateRun(runs, taskId);
+      checks.push(duplicate ? preflightCheck("duplicate-active-run", "one active run per task", "fail", String(duplicate.runId ?? taskId), "Attach to or stop the existing run before starting another one for this task.") : preflightCheck("duplicate-active-run", "one active run per task", "pass", taskId));
+    } catch (error) {
+      checks.push(preflightCheck("duplicate-active-run", "one active run per task", "warn", message(error), "Could not list active runs; the server will still reject conflicting runs if configured."));
     }
   }
   if ((options.runtimeAdapter ?? "pi") === "pi") {
@@ -2099,8 +1590,18 @@ import {
   readJsonlFile as readJsonlFile2,
   writeAuthorityRunRecord
 } from "@rig/runtime/control-plane/authority-files";
-function normalizeRuntimeAdapter(_value) {
-  return "pi";
+function normalizeRuntimeAdapter(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return "pi";
+  }
+  if (normalized === "codex" || normalized === "codex-cli" || normalized === "codex-app-server" || normalized === "gpt-codex") {
+    return "codex";
+  }
+  if (normalized === "pi" || normalized === "rig-pi" || normalized === "@rig/pi") {
+    return "pi";
+  }
+  return "claude-code";
 }
 function readLatestBeadRecord(projectRoot, taskId) {
   const issuesPath = resolve11(resolveControlPlaneMonorepoRoot(projectRoot), ".beads", "issues.jsonl");
@@ -2514,19 +2015,16 @@ function formatConnectionList(connections) {
   return [formatSection("Rig servers", `${rows.length} available`), `${pc3.bold(pad("ALIAS", aliasWidth))}  ${pc3.bold("KIND")}  ${pc3.bold("TARGET")}`, ...lines, "", ...formatNextSteps(["Select one: `rig server use <alias|local>`"])].join(`
 `);
 }
-function formatConnectionStatus(selected, connections, repo, remoteProjectLink) {
+function formatConnectionStatus(selected, connections) {
   const connection = selected === "local" ? { kind: "local", mode: "auto" } : connections[selected];
   const target = !connection ? "not configured" : connection.kind === "remote" ? connection.baseUrl : "local";
-  const rootLabel = remoteProjectLink ? remoteProjectLink.ok ? `ready \xB7 ${remoteProjectLink.serverProjectRoot ?? repo?.serverProjectRoot ?? "linked"}` : `${remoteProjectLink.status ?? "needs repair"} \xB7 ${remoteProjectLink.hint ?? remoteProjectLink.message ?? "run rig server repair-link"}` : repo?.serverProjectRoot ? repo.serverProjectRoot : "not required";
   return [
     formatSection("Rig server", "selected for this repo"),
     `${themeFaint("\u2502")} ${themeDim("selected ")} ${pc3.bold(selected)}`,
     `${themeFaint("\u2502")} ${themeDim("kind     ")} ${formatStatusPill(connection?.kind ?? "unknown")}`,
     `${themeFaint("\u2502")} ${themeDim("target   ")} ${target ?? "not configured"}`,
-    ...repo?.project ? [`${themeFaint("\u2502")} ${themeDim("project  ")} ${repo.project}`] : [],
-    ...connection?.kind === "remote" ? [`${themeFaint("\u2502")} ${themeDim("root     ")} ${rootLabel}`] : [],
     "",
-    ...formatNextSteps(remoteProjectLink && !remoteProjectLink.ok ? ["Repair remote link: `rig server repair-link`", "Authenticate first if needed: `rig github auth import-gh`"] : ["Change: `rig server use <alias|local>`", "List saved servers: `rig server list`"])
+    ...formatNextSteps(["Change: `rig server use <alias|local>`", "List saved servers: `rig server list`"])
   ].join(`
 `);
 }
@@ -3025,7 +2523,7 @@ var init__operator_surface = __esm(() => {
 });
 
 // packages/cli/src/commands/_pi-frontend.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync10, mkdtempSync, readFileSync as readFileSync10, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync8, mkdtempSync, readFileSync as readFileSync10, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir6, tmpdir } from "os";
 import { join as join3 } from "path";
 import { main as runPiMain } from "@earendil-works/pi-coding-agent";
@@ -3057,27 +2555,10 @@ function buildOperatorPiEnv(input) {
     ...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 = join3(homedir6(), ".rig", "drones", runId.slice(0, 8));
-  mkdirSync10(localCwd, { recursive: true });
+  mkdirSync8(localCwd, { recursive: true });
   trustDroneCwd(localCwd);
   installRigPiTheme();
   let sessionFileArg = [];
@@ -3099,28 +2580,21 @@ async function prepareOperatorConsole(context, runId, tempSessionDir) {
         return line;
       }).join(`
 `);
-      writeFileSync8(localSessionPath, content);
+      writeFileSync6(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 = join3(homedir6(), ".pi", "agent");
-    mkdirSync10(agentDir, { recursive: true });
+    mkdirSync8(agentDir, { recursive: true });
     const trustPath = join3(agentDir, "trust.json");
     const store = existsSync14(trustPath) ? JSON.parse(readFileSync10(trustPath, "utf8")) : {};
     if (store[localCwd] !== true) {
       store[localCwd] = true;
-      writeFileSync8(trustPath, `${JSON.stringify(store, null, "\t")}
+      writeFileSync6(trustPath, `${JSON.stringify(store, null, "\t")}
 `);
     }
   } catch {}
@@ -3128,38 +2602,15 @@ function trustDroneCwd(localCwd) {
 function installRigPiTheme() {
   try {
     const themesDir = join3(homedir6(), ".pi", "agent", "themes");
-    mkdirSync10(themesDir, { recursive: true });
+    mkdirSync8(themesDir, { recursive: true });
     const themePath = join3(themesDir, "rig.json");
     const next = `${JSON.stringify(RIG_PI_THEME, null, "\t")}
 `;
     if (!existsSync14(themePath) || readFileSync10(themePath, "utf8") !== next) {
-      writeFileSync8(themePath, next);
+      writeFileSync6(themePath, next);
     }
   } catch {}
 }
-async function runWithProcessExitGuard(body) {
-  const realExit = process.exit;
-  let exitCode = 0;
-  let signalQuit = () => {};
-  const quit = new Promise((resolve22) => {
-    signalQuit = resolve22;
-  });
-  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(join3(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 });
@@ -3175,20 +2626,15 @@ async function attachRunBundledPiFrontend(context, input) {
   };
   let detached = false;
   try {
-    const piArgs = [
-      "--offline",
+    await runPiMain([
       "--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);
-    }
+    ], {
+      extensionFactories: [piRigExtensionFactory]
+    });
     detached = true;
   } finally {
     restoreEnv();
@@ -3208,17 +2654,10 @@ async function attachRunBundledPiFrontend(context, input) {
     rendered: "stock Pi operator console with the pi-rig extension"
   };
 }
-var TERMINAL_RUN_STATUSES, OperatorTranscriptUnavailableError, RIG_PI_THEME;
+var 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(message2) {
-      super(message2);
-      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",
@@ -3373,7 +2812,7 @@ async function attachRunOperatorView(context, input) {
     }
     const pollMs = Math.max(250, Math.trunc(input.pollMs ?? 2000));
     let timelineCursor = snapshot.timelineCursor;
-    while (!detached && !TERMINAL_RUN_STATUSES2.has(runStatusFromPayload(snapshot.run))) {
+    while (!detached && !TERMINAL_RUN_STATUSES.has(runStatusFromPayload(snapshot.run))) {
       await Bun.sleep(pollMs);
       snapshot = await readOperatorSnapshot(context, input.runId, { timelineCursor });
       timelineCursor = snapshot.timelineCursor;
@@ -3385,13 +2824,13 @@ async function attachRunOperatorView(context, input) {
   }
   return { ...snapshot, steered, detached };
 }
-var TERMINAL_RUN_STATUSES2;
+var TERMINAL_RUN_STATUSES;
 var init__operator_view = __esm(() => {
   init__server_client();
   init__operator_surface();
   init__pi_frontend();
   init__async_ui();
-  TERMINAL_RUN_STATUSES2 = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
+  TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
 });
 
 // packages/cli/src/commands/_help-catalog.ts
@@ -3561,13 +3000,12 @@ var init__help_catalog = __esm(() => {
     {
       name: "server",
       summary: "Choose, inspect, and start the Rig server that owns tasks and runs.",
-      usage: ["rig server <status|list|add|use|repair-link|start> [options]"],
+      usage: ["rig server <status|list|add|use|start> [options]"],
       commands: [
-        { command: "status", description: "Show the selected server and remote project-root link for this repo.", primary: true },
+        { command: "status", description: "Show the selected server for this repo.", primary: true },
         { command: "use local", description: "Switch this repo to the local Rig server.", primary: true },
         { command: "add <alias> <url>", description: "Save a remote Rig server URL.", primary: true },
         { command: "use <alias>", description: "Select a saved remote server alias.", primary: true },
-        { command: "repair-link [--prepare|--backfill-only] [--repo owner/repo]", description: "Backfill or prepare the selected remote's server-host checkout link.", primary: true },
         { command: "list", description: "List saved local/remote server aliases.", primary: true },
         { command: "start [--host <host>] [--port <n>]", description: "Start a local rig-server process." }
       ],
@@ -3575,7 +3013,6 @@ var init__help_catalog = __esm(() => {
         "rig server status",
         "rig server add prod https://where.rig-does.work",
         "rig server use prod",
-        "rig server repair-link --repo owner/repo",
         "rig server use local",
         "rig server start --port 3773"
       ],
@@ -3750,62 +3187,30 @@ var init__help_catalog = __esm(() => {
     }
   ];
   ADVANCED_GROUPS = [
-    {
-      name: "setup",
-      summary: "Bootstrap/check local setup.",
-      usage: ["rig setup <bootstrap|check|preflight>"],
-      commands: [
-        { command: "bootstrap", description: "Bootstrap local setup dependencies.", primary: true },
-        { command: "check", description: "Check local setup state (toolchain, deps, config).", primary: true },
-        { command: "preflight", description: "Run preflight checks before a run.", primary: true }
-      ]
-    },
-    {
-      name: "profile",
-      summary: "Runtime profile/model defaults.",
-      usage: ["rig profile <show|set>"],
-      commands: [
-        { command: "show", description: "Show the active execution profile.", primary: true },
-        { command: "set [--model <model>] [--runtime <runtime>] [--plugin <plugin>]", description: "Set model/runtime/plugin profile defaults.", primary: true }
-      ]
-    },
+    { name: "setup", summary: "Bootstrap/check local setup.", usage: ["rig setup <bootstrap|check|preflight>"], commands: [{ command: "bootstrap|check|preflight", description: "Setup helpers." }] },
+    { name: "profile", summary: "Runtime profile/model defaults.", usage: ["rig profile <show|set>"], commands: [{ command: "show", description: "Show active profile." }] },
     {
       name: "review",
       summary: "Inspect or change completion review gate policy.",
       usage: ["rig review <show|set>"],
       commands: [
         { command: "show", description: "Show current review gate settings." },
-        { command: "set <off|advisory|required> [--provider <provider>]", description: "Change review strictness/provider (e.g. --provider greptile)." }
+        { command: "set <off|advisory|required> [--provider greptile]", description: "Change review strictness/provider." }
       ],
       examples: ["rig review show", "rig review set required --provider greptile"],
       next: ["Use `rig inbox approvals` for blocked run handoffs."]
     },
     {
       name: "browser",
-      summary: "Browser workstation actions for browser-required tasks: launch, check, CDP probe, profile reset, and app-specific smokes.",
-      usage: ["rig browser <help|explain|demo|hp-next|cdp-probe|profile-persistence|profile-lock-check|smoke-test> [options]"],
+      summary: "Browser/app diagnostics for browser-required tasks.",
+      usage: ["rig browser <help|explain|demo|app|hp-next> [options]"],
       commands: [
-        { command: "help", description: "Rich browser command help (canonical: `rig browser help`).", primary: true },
-        { command: "explain", description: "Explain the browser-required task contract and runtime helper commands.", primary: true },
-        { command: "demo [--port <n>] [--profile <name>] [--state-dir <path>] [--target-url <url>] [--keep-open] [--no-build]", description: "Run a guided real browser/agent demo flow.", primary: true },
-        { command: "hp-next dev", description: "Start hp-next Rig Browser in dev/watch mode.", primary: true },
-        { command: "hp-next start", description: "Build/start the hp-next browser workstation without watch mode.", primary: true },
-        { command: "hp-next check", description: "Validate the hp-next CDP endpoint on the configured port.", primary: true },
-        { command: "hp-next e2e", description: "Run hp-next browser e2e smoke checks through Rig Browser.", primary: true },
-        { command: "hp-next reset", description: "Reset the hp-next browser profile when stale browser state is suspected.", primary: true },
-        { command: "cdp-probe", description: "Run an isolated CDP attach/evaluate/layout probe." },
-        { command: "profile-persistence", description: "Verify a named browser profile persists browser state." },
-        { command: "profile-lock-check", description: "Verify concurrent launches reject the same profile." },
-        { command: "smoke-test", description: "Run the browser package smoke test." }
-      ],
-      examples: [
-        "rig browser help",
-        "rig browser hp-next check",
-        "rig browser hp-next e2e",
-        "rig browser cdp-probe",
-        "rig browser profile-lock-check"
-      ],
-      next: ["Inside a task run, use rig-browser-launch, rig-browser-check, and rig-browser-attach-info from the worker PATH."]
+        { command: "help", description: "Rich browser command help (canonical: `rig browser help`)." },
+        { command: "explain", description: "Explain the browser-required task contract." },
+        { command: "demo", description: "Run browser demo flows against a local page." },
+        { command: "app", description: "Launch the Rig Browser workstation app." },
+        { command: "hp-next <dev|check|e2e|reset>", description: "Drive the hp-next browser test harness." }
+      ]
     },
     {
       name: "pi",
@@ -3820,60 +3225,12 @@ var init__help_catalog = __esm(() => {
       examples: ["rig pi search subagents", "rig pi add pi-subagents", "rig pi list"],
       next: ["Config-managed extensions: declare `runtime: { pi: { packages: [...] } }` in rig.config.ts \u2014 workers pick them up automatically."]
     },
-    {
-      name: "queue",
-      summary: "Run task queues locally.",
-      usage: ["rig queue run [--workers <n>] [--max-tasks <n>] [--action validate|verify|pipeline] [--isolation off|worktree] [--no-runtime-reuse] [--fail-fast] [--skip-project-sync]"],
-      commands: [
-        { command: "run [--workers <n>] [--max-tasks <n>] [--action validate|verify|pipeline] [--isolation off|worktree] [--no-runtime-reuse] [--fail-fast] [--skip-project-sync]", description: "Process queue work: drain matching tasks with N workers, optional per-task action and isolation.", primary: true }
-      ]
-    },
-    {
-      name: "agent",
-      summary: "Runtime agent workspace helpers.",
-      usage: ["rig agent <list|prepare|run|cleanup>"],
-      commands: [
-        { command: "list", description: "List prepared agent runtimes.", primary: true },
-        { command: "prepare [--id <id>] [--mode <mode>] [--task <task>]", description: "Prepare an isolated agent runtime workspace.", primary: true },
-        { command: "run [--id <id>] [--mode <mode>] [--task <task>] [--skip-project-sync]", description: "Prepare (if needed) and run an agent in its workspace.", primary: true },
-        { command: "cleanup [--all] [--id <id>]", description: "Remove prepared agent workspaces.", primary: true }
-      ]
-    },
+    { name: "queue", summary: "Run task queues locally.", usage: ["rig queue run [options]"], commands: [{ command: "run", description: "Process queue work." }] },
+    { name: "agent", summary: "Runtime agent workspace helpers.", usage: ["rig agent <list|prepare|run|cleanup>"], commands: [{ command: "list", description: "List prepared agents." }] },
     { name: "inspector", summary: "Event stream and drift scanners.", usage: ["rig inspector <stream|scan-upstream-drift>"], commands: [{ command: "stream", description: "Stream events." }] },
-    {
-      name: "dist",
-      summary: "Build/install packaged Rig CLI.",
-      usage: ["rig dist <build|install|doctor|rebuild-agent>"],
-      commands: [
-        { command: "build [--output-dir <dir>]", description: "Build the distributable Rig CLI.", primary: true },
-        { command: "install [--scope <scope>] [--path <path>]", description: "Install the built CLI to a scope/path.", primary: true },
-        { command: "doctor", description: "Diagnose the dist toolchain and install state.", primary: true },
-        { command: "rebuild-agent", description: "Rebuild the agent runtime image, pruning stale images.", primary: true }
-      ]
-    },
+    { name: "dist", summary: "Build/install packaged Rig CLI.", usage: ["rig dist <build|install|doctor>"], commands: [{ command: "build", description: "Build distribution." }] },
     { name: "workspace", summary: "Workspace topology/service helpers.", usage: ["rig workspace <summary|topology|remote-hosts>"], commands: [{ command: "summary", description: "Show workspace summary." }] },
-    {
-      name: "remote",
-      summary: "Compatibility remote orchestration controls.",
-      usage: ["rig remote <status|tasks|watch|pause|resume|continue|stop|refresh|add-iterations|remove-iterations|endpoint ...>"],
-      commands: [
-        { command: "status [--remote <alias>]", description: "Show the remote orchestration state.", primary: true },
-        { command: "tasks [--remote <alias>]", description: "List the remote's tracked tasks.", primary: true },
-        { command: "watch [--remote <alias>] [--seconds <n>] [--event <type>]", description: "Stream remote orchestration events.", primary: true },
-        { command: "pause [--remote <alias>]", description: "Pause the running remote orchestration.", primary: true },
-        { command: "resume [--remote <alias>] [--max-workers <n>] [--max-iterations <n>] [--direct-merge]", description: "Resume the remote with optional tuning.", primary: true },
-        { command: "continue [--remote <alias>]", description: "Continue a paused remote orchestration.", primary: true },
-        { command: "stop [--remote <alias>]", description: "Stop the remote orchestration.", primary: true },
-        { command: "refresh [--remote <alias>]", description: "Refresh remote state.", primary: true },
-        { command: "add-iterations [--count <n>] [--remote <alias>]", description: "Grant the remote more iterations.", primary: true },
-        { command: "remove-iterations [--count <n>] [--remote <alias>]", description: "Reduce the remote's iteration budget.", primary: true },
-        { command: "endpoint list", description: "List configured remote endpoints.", primary: true },
-        { command: "endpoint add --alias <alias> --host <host> --port <n> [--token <token>]", description: "Register a remote endpoint.", primary: true },
-        { command: "endpoint remove --alias <alias>", description: "Remove a remote endpoint.", primary: true },
-        { command: "endpoint test [--alias <alias>]", description: "Test connectivity to a remote endpoint.", primary: true },
-        { command: "endpoint doctor", description: "Diagnose remote endpoint configuration.", primary: true }
-      ]
-    },
+    { name: "remote", summary: "Compatibility remote orchestration controls.", usage: ["rig remote <status|watch|pause|resume|...>"], commands: [{ command: "status", description: "Show remote state." }] },
     { name: "git", summary: "Pass through to Rig git-flow helper.", usage: ["rig git <args...>"], commands: [{ command: "<args...>", description: "Advanced git flow operations." }] },
     { name: "harness", summary: "Pass through to runtime harness CLI.", usage: ["rig harness <args...>"], commands: [{ command: "<args...>", description: "Advanced harness operations." }] },
     { name: "test", summary: "Project test wrappers.", usage: ["rig test <unit|e2e|all>"], commands: [{ command: "all", description: "Run configured project tests." }] }
@@ -3940,7 +3297,7 @@ var init__task_picker = __esm(() => {
 // packages/cli/src/commands/task.ts
 import { readFileSync as readFileSync11 } from "fs";
 import { spawnSync as spawnSync3 } from "child_process";
-import { resolve as resolve22 } from "path";
+import { resolve as resolve21 } from "path";
 import {
   taskArtifactDir,
   taskArtifacts,
@@ -4218,7 +3575,7 @@ async function executeTask(context, args, options) {
       const fileFlag = takeOption(rest.slice(1), "--file");
       let content;
       if (fileFlag.value) {
-        content = readFileSync11(resolve22(context.projectRoot, fileFlag.value), "utf-8");
+        content = readFileSync11(resolve21(context.projectRoot, fileFlag.value), "utf-8");
       } else {
         content = await readStdin();
       }
@@ -4456,47 +3813,6 @@ var init_task = __esm(() => {
   init__connection_state();
 });
 
-// packages/cli/src/commands/_server-events.ts
-import { WsTransport } from "@rig/client";
-import { RIG_WS_CHANNELS } from "@rig/contracts";
-function buildRigWebSocketUrl(baseUrl, authToken) {
-  const url = new URL(baseUrl);
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  if (authToken)
-    url.searchParams.set("token", authToken);
-  return url.toString();
-}
-async function connectRigServerEvents(projectRoot, handlers) {
-  const { baseUrl, authToken } = await ensureServerForCli(projectRoot);
-  const transport = new WsTransport(buildRigWebSocketUrl(baseUrl, authToken));
-  const unsubscribers = [];
-  if (handlers.onSnapshotInvalidated)
-    unsubscribers.push(transport.subscribe(RIG_WS_CHANNELS.snapshotInvalidated, handlers.onSnapshotInvalidated));
-  if (handlers.onRunLogAppended)
-    unsubscribers.push(transport.subscribe(RIG_WS_CHANNELS.runLogAppended, handlers.onRunLogAppended));
-  if (handlers.onEngineEvent)
-    unsubscribers.push(transport.subscribe(RIG_WS_CHANNELS.event, handlers.onEngineEvent));
-  let status = "connecting";
-  unsubscribers.push(transport.subscribeState((state) => {
-    status = state.status;
-    handlers.onStatus?.(state.status);
-  }));
-  return {
-    connected: () => status === "connected",
-    close: () => {
-      for (const unsubscribe of unsubscribers) {
-        try {
-          unsubscribe();
-        } catch {}
-      }
-      transport.dispose();
-    }
-  };
-}
-var init__server_events = __esm(() => {
-  init__server_client();
-});
-
 // packages/cli/src/app/board.ts
 var exports_board = {};
 __export(exports_board, {
@@ -4528,7 +3844,6 @@ function statusRank(status) {
     case "pending":
     case "preparing":
     case "adopted":
-    case "stopping":
       return 2;
     case "completed":
     case "merged":
@@ -4568,10 +3883,6 @@ class RunsList {
   selectedRun() {
     return this.visibleRuns()[this.selected] ?? null;
   }
-  patchRun(runId, patch) {
-    this.runs = this.runs.map((run) => run.runId === runId ? { ...run, ...patch } : run);
-    this.clampSelection();
-  }
   cycleSort() {
     this.sortMode = this.sortMode === "active" ? "recent" : this.sortMode === "recent" ? "status" : "active";
     this.clampSelection();
@@ -4794,14 +4105,6 @@ class InboxView {
   selectedItem() {
     return this.items[this.selected] ?? null;
   }
-  patchItem(requestId, summary) {
-    this.items = this.items.map((item) => item.requestId === requestId ? { ...item, summary } : item);
-  }
-  removeItem(requestId) {
-    const previousIndex = this.selected;
-    this.items = this.items.filter((item) => item.requestId !== requestId);
-    this.selected = Math.max(0, Math.min(previousIndex, Math.max(0, this.items.length - 1)));
-  }
   invalidate() {}
   render(width) {
     return this.renderLines(width).map((line) => truncateToWidth(line, Math.max(10, width - 1)));
@@ -5023,14 +4326,9 @@ async function runOperatorBoard(context, options = {}) {
     tui.stop();
   };
   let refreshInFlight = false;
-  const refresh = async (options2 = {}) => {
+  const refresh = async () => {
     if (refreshInFlight)
       return;
-    if (!options2.quiet) {
-      notice = "refreshing fleet\u2026";
-      renderFooter();
-      tui.requestRender();
-    }
     if (!hasRigProject(context.projectRoot)) {
       list.loading = false;
       list.noProject = true;
@@ -5113,7 +4411,6 @@ async function runOperatorBoard(context, options = {}) {
   };
   const resolveApproval = async (item, decision) => {
     notice = `${decision === "approve" ? "approving" : "rejecting"} ${item.requestId.slice(0, 12)}\u2026`;
-    inboxView.patchItem(item.requestId, `${decision === "approve" ? "approving" : "rejecting"}\u2026 ${item.summary}`);
     renderFooter();
     tui.requestRender();
     try {
@@ -5122,10 +4419,8 @@ async function runOperatorBoard(context, options = {}) {
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ runId: item.runId, requestId: item.requestId, decision, note: null })
       });
-      inboxView.removeItem(item.requestId);
       notice = `${decision === "approve" ? "approved" : "rejected"} \u2014 drone resumes`;
     } catch (error) {
-      inboxView.patchItem(item.requestId, item.summary);
       notice = `resolve failed: ${oneLine(error instanceof Error ? error.message : String(error))}`;
     }
     renderFooter();
@@ -5134,7 +4429,6 @@ async function runOperatorBoard(context, options = {}) {
   };
   const answerInput = async (item, text2) => {
     notice = `answering ${item.requestId.slice(0, 12)}\u2026`;
-    inboxView.patchItem(item.requestId, `answering\u2026 ${item.summary}`);
     renderFooter();
     tui.requestRender();
     try {
@@ -5147,10 +4441,8 @@ async function runOperatorBoard(context, options = {}) {
           answers: { [item.questionId ?? "response"]: text2 }
         })
       });
-      inboxView.removeItem(item.requestId);
       notice = "answer sent \u2014 drone resumes";
     } catch (error) {
-      inboxView.patchItem(item.requestId, item.summary);
       notice = `answer failed: ${oneLine(error instanceof Error ? error.message : String(error))}`;
     }
     renderFooter();
@@ -5299,7 +4591,6 @@ async function runOperatorBoard(context, options = {}) {
       const run = list.selectedRun();
       if (run) {
         notice = `stop requested for ${run.runId.slice(0, 8)}\u2026`;
-        list.patchRun(run.runId, { status: "stopping" });
         renderFooter();
         tui.requestRender();
         stopRunViaServer(context, run.runId).then(() => refresh()).catch(() => refresh());
@@ -5307,9 +4598,6 @@ async function runOperatorBoard(context, options = {}) {
       return { consume: true };
     }
     if (data === "r") {
-      notice = "refreshing fleet\u2026";
-      renderFooter();
-      tui.requestRender();
       refresh();
       return { consume: true };
     }
@@ -5335,39 +4623,21 @@ async function runOperatorBoard(context, options = {}) {
       tui.requestRender();
     }
   }, BOARD_TICK_MS);
-  const live = { subscription: null };
-  const refreshActiveView = () => {
-    refresh({ quiet: true });
-    if (view === "tasks")
-      refreshTasks();
-    if (view === "inbox")
-      refreshInbox();
-  };
-  connectRigServerEvents(context.projectRoot, {
-    onSnapshotInvalidated: () => refreshActiveView()
-  }).then((subscription) => {
-    live.subscription = subscription;
-  }).catch(() => {
-    live.subscription = null;
-  });
   const refreshTimer = setInterval(() => {
-    if (live.subscription?.connected())
-      return;
     refresh();
   }, BOARD_REFRESH_MS);
   tui.start();
-  refresh({ quiet: true });
-  await new Promise((resolve25) => {
+  refresh();
+  await new Promise((resolve24) => {
     const poll = setInterval(() => {
       if (stopped) {
         clearInterval(poll);
-        resolve25();
+        resolve24();
       }
     }, 50);
   });
   clearInterval(animation);
   clearInterval(refreshTimer);
-  live.subscription?.close();
   return outcome;
 }
 async function runOperatorBoardLoop(context, attach, options = {}) {
@@ -5380,13 +4650,12 @@ async function runOperatorBoardLoop(context, attach, options = {}) {
     await attach(outcome.runId);
   }
 }
-var BOARD_REFRESH_MS = 5000, BOARD_TICK_MS = 16, BOARD_TASK_PAGE = 20;
+var BOARD_REFRESH_MS = 5000, BOARD_TICK_MS = 250, BOARD_TASK_PAGE = 20;
 var init_board = __esm(() => {
   init_theme();
   init__help_catalog();
   init__server_client();
   init__authority_runs();
-  init__server_events();
   init_inbox();
   init_task();
 });
@@ -5397,7 +4666,7 @@ import {
   existsSync as existsSync18,
   readFileSync as readFileSync13
 } from "fs";
-import { resolve as resolve25 } from "path";
+import { resolve as resolve24 } from "path";
 import { readBuildConfig } from "@rig/runtime/build-time-config";
 
 // packages/cli/src/commands/browser.ts
@@ -7904,7 +7173,7 @@ import {
   chmodSync,
   copyFileSync as copyFileSync2,
   existsSync as existsSync8,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync6,
   readdirSync,
   readlinkSync,
   rmSync as rmSync3,
@@ -8021,7 +7290,7 @@ async function executeDist(context, args) {
       requireNoExtraArgs(pending, "rig dist install [--scope user|system] [--path <dir>]");
       const scope = parseInstallScope(scopeResult.value);
       const installDir = resolveInstallDir(scope, pathResult.value);
-      mkdirSync7(installDir, { recursive: true });
+      mkdirSync6(installDir, { recursive: true });
       let source = await findLatestDistBinary(context.projectRoot);
       let buildDir = null;
       if (!source) {
@@ -8076,7 +7345,7 @@ async function executeDist(context, args) {
       const fp = await computeRuntimeImageFingerprint(context.projectRoot);
       const currentId = computeRuntimeImageId(fp);
       const imagesDir = resolve13(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "images");
-      mkdirSync7(imagesDir, { recursive: true });
+      mkdirSync6(imagesDir, { recursive: true });
       let pruned = 0;
       for (const entry of readdirSync(imagesDir, { withFileTypes: true })) {
         if (entry.isDirectory() && entry.name !== currentId) {
@@ -8088,9 +7357,9 @@ async function executeDist(context, args) {
         console.log(`Pruned ${pruned} stale image(s).`);
       }
       const imageDir = resolve13(imagesDir, currentId);
-      mkdirSync7(resolve13(imageDir, "bin/hooks"), { recursive: true });
-      mkdirSync7(resolve13(imageDir, "bin/plugins"), { recursive: true });
-      mkdirSync7(resolve13(imageDir, "bin/validators"), { recursive: true });
+      mkdirSync6(resolve13(imageDir, "bin/hooks"), { recursive: true });
+      mkdirSync6(resolve13(imageDir, "bin/plugins"), { recursive: true });
+      mkdirSync6(resolve13(imageDir, "bin/validators"), { recursive: true });
       const hookNames = [
         "scope-guard",
         "import-guard",
@@ -8115,8 +7384,8 @@ async function executeDist(context, args) {
       const binPluginsDir = resolve13(resolveControlPlaneHostBinDir(context.projectRoot), "plugins");
       const validatorsRoot = resolve13(hostProjectRoot, "packages/runtime/src/control-plane/validators");
       const binValidatorsDir = resolve13(resolveControlPlaneHostBinDir(context.projectRoot), "validators");
-      mkdirSync7(binPluginsDir, { recursive: true });
-      mkdirSync7(binValidatorsDir, { recursive: true });
+      mkdirSync6(binPluginsDir, { recursive: true });
+      mkdirSync6(binValidatorsDir, { recursive: true });
       if (existsSync8(pluginsDir)) {
         for (const entry of readdirSync(pluginsDir, { withFileTypes: true })) {
           const m = entry.name.match(/^(.+)\.plugin\.(ts|js|mjs|cjs)$/);
@@ -8223,7 +7492,7 @@ init_inbox();
 init_runner();
 init__connection_state();
 init__server_client();
-import { appendFileSync as appendFileSync2, existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
 import { spawnSync } from "child_process";
 import { basename as basename2, resolve as resolve17 } from "path";
 import { buildRigInitConfigSource } from "@rig/core";
@@ -8409,7 +7678,7 @@ async function buildPiSetupChecks(input = {}) {
 // packages/cli/src/commands/_snapshot-upload.ts
 init__server_client();
 import { mkdir, readdir, readFile, writeFile } from "fs/promises";
-import { dirname as dirname4, resolve as resolve15, relative, sep } from "path";
+import { dirname as dirname3, resolve as resolve15, relative, sep } from "path";
 var SNAPSHOT_ARCHIVE_VERSION = 1;
 var SNAPSHOT_ARCHIVE_CONTENT_TYPE = "application/vnd.rig.snapshot+json";
 var DEFAULT_EXCLUDED_DIRECTORIES = new Set([
@@ -8758,14 +8027,14 @@ function parseRepoSlug(value) {
 }
 function ensureRigPrivateDirs(projectRoot) {
   const rigDir = resolve17(projectRoot, ".rig");
-  mkdirSync8(resolve17(rigDir, "state"), { recursive: true });
-  mkdirSync8(resolve17(rigDir, "logs"), { recursive: true });
-  mkdirSync8(resolve17(rigDir, "runs"), { recursive: true });
-  mkdirSync8(resolve17(rigDir, "tmp"), { recursive: true });
-  mkdirSync8(resolve17(projectRoot, "artifacts"), { recursive: true });
+  mkdirSync7(resolve17(rigDir, "state"), { recursive: true });
+  mkdirSync7(resolve17(rigDir, "logs"), { recursive: true });
+  mkdirSync7(resolve17(rigDir, "runs"), { recursive: true });
+  mkdirSync7(resolve17(rigDir, "tmp"), { recursive: true });
+  mkdirSync7(resolve17(projectRoot, "artifacts"), { recursive: true });
   const taskConfigPath = resolve17(rigDir, "task-config.json");
   if (!existsSync11(taskConfigPath))
-    writeFileSync6(taskConfigPath, `{}
+    writeFileSync5(taskConfigPath, `{}
 `, "utf-8");
 }
 function ensureGitignoreEntries(projectRoot) {
@@ -8793,7 +8062,7 @@ function ensureRigConfigPackageDependencies(projectRoot) {
     ...existsSync11(path) ? existing : { name: "rig-project", private: true },
     devDependencies
   };
-  writeFileSync6(path, `${JSON.stringify(next, null, 2)}
+  writeFileSync5(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
 }
 function applyGitHubProjectConfig(source, options) {
@@ -8819,9 +8088,9 @@ function checkoutForInit(projectRoot, serverKind, strategy) {
   const selected = strategy ?? { kind: "managed-clone" };
   switch (selected.kind) {
     case "managed-clone":
-      return { kind: "managed-clone" };
+      return { kind: "managed-clone", path: projectRoot };
     case "current-ref":
-      return { kind: "current-ref", ...selected.ref ? { ref: selected.ref } : {} };
+      return { kind: "current-ref", path: projectRoot, ...selected.ref ? { ref: selected.ref } : {} };
     case "uploaded-snapshot":
       return { kind: "uploaded-snapshot", path: projectRoot, source: "local-working-tree" };
     case "existing-path":
@@ -9091,7 +8360,7 @@ function remoteGitHubAuthMetadata(payload) {
   };
 }
 function writeRemoteGitHubAuthState(projectRoot, input) {
-  writeFileSync6(resolve17(projectRoot, ".rig", "state", "github-auth.json"), `${JSON.stringify({
+  writeFileSync5(resolve17(projectRoot, ".rig", "state", "github-auth.json"), `${JSON.stringify({
     authenticated: true,
     source: input.source,
     storedOnServer: true,
@@ -9139,7 +8408,7 @@ function runLocalFilesInit(context, options) {
       console.log("rig.config already exists; leaving it unchanged. Pass --repair to rewrite it.");
   } else {
     const projectName = basename2(projectRoot) || "rig-project";
-    writeFileSync6(configTsPath, buildRigInitConfigSource({
+    writeFileSync5(configTsPath, buildRigInitConfigSource({
       projectName,
       taskSource: { kind: "files", path: "tasks" },
       useStandardPlugin: true
@@ -9148,8 +8417,8 @@ function runLocalFilesInit(context, options) {
   ensureRigConfigPackageDependencies(projectRoot);
   const tasksDir = resolve17(projectRoot, "tasks");
   if (!existsSync11(tasksDir)) {
-    mkdirSync8(tasksDir, { recursive: true });
-    writeFileSync6(resolve17(tasksDir, "T-1.json"), `${JSON.stringify({ id: "T-1", title: "My first Rig task", body: "Describe the change you want an agent to make." }, null, 2)}
+    mkdirSync7(tasksDir, { recursive: true });
+    writeFileSync5(resolve17(tasksDir, "T-1.json"), `${JSON.stringify({ id: "T-1", title: "My first Rig task", body: "Describe the change you want an agent to make." }, null, 2)}
 `, "utf-8");
   }
   if (context.outputMode !== "json") {
@@ -9212,7 +8481,7 @@ function runDemoInit(context, options) {
       console.log("rig.config already exists; leaving it unchanged. Pass --repair to rewrite it for the demo.");
     }
   } else {
-    writeFileSync6(configTsPath, buildRigInitConfigSource({
+    writeFileSync5(configTsPath, buildRigInitConfigSource({
       projectName: basename2(projectRoot) || "rig-demo",
       taskSource: { kind: "files", path: DEMO_TASKS_RELATIVE_DIR },
       useStandardPlugin: true
@@ -9221,14 +8490,14 @@ function runDemoInit(context, options) {
   }
   ensureRigConfigPackageDependencies(projectRoot);
   const demoTasksDir = resolve17(projectRoot, DEMO_TASKS_RELATIVE_DIR);
-  mkdirSync8(demoTasksDir, { recursive: true });
+  mkdirSync7(demoTasksDir, { recursive: true });
   const taskIds = [];
   for (const task of DEMO_TASKS) {
     const id = String(task.id);
     taskIds.push(id);
     const taskPath = resolve17(demoTasksDir, `${id}.json`);
     if (!existsSync11(taskPath)) {
-      writeFileSync6(taskPath, `${JSON.stringify(task, null, 2)}
+      writeFileSync5(taskPath, `${JSON.stringify(task, null, 2)}
 `, "utf-8");
     }
   }
@@ -9256,32 +8525,21 @@ function runDemoInit(context, options) {
 }
 async function runControlPlaneInit(context, options) {
   const projectRoot = context.projectRoot;
-  const existingRepoConnection = readRepoConnection(projectRoot);
-  const selectedConnection = (() => {
-    try {
-      return resolveSelectedConnection(projectRoot);
-    } catch {
-      return null;
-    }
-  })();
-  const selectedRemote = selectedConnection?.connection.kind === "remote" ? { alias: selectedConnection.alias, connection: selectedConnection.connection } : null;
-  const detectedSlug = options.repoSlug ?? existingRepoConnection?.project ?? detectOriginRepoSlug(projectRoot);
-  const serverKind = options.server ?? (selectedRemote ? "remote" : "local");
+  const detectedSlug = options.repoSlug ?? detectOriginRepoSlug(projectRoot);
   if (!detectedSlug) {
     const authMethod2 = options.githubAuthMethod ?? (options.githubToken ? "token" : "skip");
-    if (serverKind === "local" && authMethod2 === "skip") {
+    if ((options.server ?? "local") === "local" && authMethod2 === "skip") {
       return runLocalFilesInit(context, options);
     }
     throw new CliError("Could not detect GitHub repo slug from origin. Pass --repo owner/repo \u2014 or run `rig init --yes --server local --github-auth skip` for a local files-source project without GitHub.", 1);
   }
   const repo = parseRepoSlug(detectedSlug);
-  const connectionAlias = options.connectionAlias ?? (serverKind === "local" ? "local" : selectedRemote?.alias ?? "remote");
-  const selectedRemoteUrl = selectedRemote && (!options.connectionAlias || options.connectionAlias === selectedRemote.alias) ? selectedRemote.connection.baseUrl : undefined;
-  const remoteUrl = serverKind === "remote" ? (options.remoteUrl ?? selectedRemoteUrl)?.replace(/\/+$/, "") : undefined;
+  const serverKind = options.server ?? "local";
+  const connectionAlias = options.connectionAlias ?? (serverKind === "local" ? "local" : "remote");
   if (serverKind === "remote") {
-    if (!remoteUrl)
-      throw new CliError("Missing --remote-url for --server remote.", 1, { hint: "Re-run as `rig init --server remote --remote-url https://your-rig-server`, or first select a saved remote with `rig server use <alias>`." });
-    upsertGlobalConnection(connectionAlias, { kind: "remote", baseUrl: remoteUrl });
+    if (!options.remoteUrl)
+      throw new CliError("Missing --remote-url for --server remote.", 1, { hint: "Re-run as `rig init --server remote --remote-url https://your-rig-server`." });
+    upsertGlobalConnection(connectionAlias, { kind: "remote", baseUrl: options.remoteUrl });
   }
   writeRepoConnection(projectRoot, {
     selected: connectionAlias,
@@ -9304,11 +8562,11 @@ async function runControlPlaneInit(context, options) {
         taskSource: { kind: "github-issues", owner: repo.owner, repo: repo.repo },
         useStandardPlugin: true
       }), options);
-      writeFileSync6(configTsPath, source, "utf-8");
+      writeFileSync5(configTsPath, source, "utf-8");
     }
     ensureRigConfigPackageDependencies(projectRoot);
   }
-  writeFileSync6(resolve17(projectRoot, ".rig", "state", "project-link.json"), `${JSON.stringify({ repoSlug: repo.slug, connection: connectionAlias, linkedAt: new Date().toISOString() }, null, 2)}
+  writeFileSync5(resolve17(projectRoot, ".rig", "state", "project-link.json"), `${JSON.stringify({ repoSlug: repo.slug, connection: connectionAlias, linkedAt: new Date().toISOString() }, null, 2)}
 `, "utf8");
   const checkout = checkoutForInit(projectRoot, serverKind, options.remoteCheckout);
   let uploadedSnapshot = null;
@@ -9323,7 +8581,7 @@ async function runControlPlaneInit(context, options) {
   let githubAuth = null;
   let deviceAuth = null;
   const authMethod = options.githubAuthMethod ?? (options.githubToken ? "token" : "skip");
-  const remoteGhTokenWarning = serverKind === "remote" && authMethod === "gh" ? `This sends a GitHub token from this machine to ${remoteUrl ?? "the remote Rig server"}.` : null;
+  const remoteGhTokenWarning = serverKind === "remote" && authMethod === "gh" ? `This sends a GitHub token from this machine to ${options.remoteUrl ?? "the remote Rig server"}.` : null;
   if (remoteGhTokenWarning && !options.yes) {
     throw new CliError(`${remoteGhTokenWarning} Re-run with --yes to confirm this explicit token transfer.`, 1);
   }
@@ -9636,64 +8894,14 @@ Usage: rig init`, 1);
 // packages/cli/src/commands/github.ts
 init_runner();
 init__server_client();
-init__connection_state();
 init__async_ui();
 import { spawnSync as spawnSync2 } from "child_process";
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname5, resolve as resolve18 } from "path";
 function printPayload(context, payload, fallback) {
   if (context.outputMode === "json")
     console.log(JSON.stringify(payload, null, 2));
   else
     console.log(fallback);
 }
-function apiSessionTokenFrom2(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const token = payload.apiSessionToken;
-  return typeof token === "string" && token.trim() ? token.trim() : null;
-}
-function payloadString(payload, key) {
-  const value = payload[key];
-  return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function payloadRecord(payload, key) {
-  const value = payload[key];
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function remoteNamespaceMetadata(result) {
-  const namespace = payloadRecord(result, "userNamespace");
-  return {
-    ...payloadString(result, "login") ? { login: payloadString(result, "login") } : {},
-    ...payloadString(result, "userId") ? { userId: payloadString(result, "userId") } : {},
-    ...namespace && payloadString(namespace, "key") ? { userNamespaceKey: payloadString(namespace, "key") } : {},
-    ...namespace && payloadString(namespace, "root") ? { userNamespaceRoot: payloadString(namespace, "root") } : {},
-    ...namespace && payloadString(namespace, "checkoutBaseDir") ? { checkoutBaseDir: payloadString(namespace, "checkoutBaseDir") } : {},
-    ...namespace && payloadString(namespace, "snapshotBaseDir") ? { snapshotBaseDir: payloadString(namespace, "snapshotBaseDir") } : {}
-  };
-}
-function persistRemoteAuthSession(context, source, result, fallbackToken) {
-  const apiSessionToken = apiSessionTokenFrom2(result);
-  setGitHubBearerTokenForCurrentProcess(apiSessionToken ?? fallbackToken, context.projectRoot);
-  if (!apiSessionToken)
-    return;
-  const repo = readRepoConnection(context.projectRoot);
-  const path = resolve18(context.projectRoot, ".rig", "state", "github-auth.json");
-  mkdirSync9(dirname5(path), { recursive: true });
-  writeFileSync7(path, `${JSON.stringify({
-    authenticated: true,
-    source,
-    storedOnServer: true,
-    ...repo?.project ? { selectedRepo: repo.project } : {},
-    ...remoteNamespaceMetadata(result),
-    apiSessionToken,
-    updatedAt: new Date().toISOString()
-  }, null, 2)}
-`, "utf8");
-}
-function isSignedIn(status) {
-  return status.signedIn === true || status.authenticated === true;
-}
 function readGhToken() {
   const result = spawnSync2("gh", ["auth", "token"], { encoding: "utf8" });
   if (result.status !== 0) {
@@ -9715,7 +8923,7 @@ async function executeGithub(context, args) {
       if (rest.length > 0)
         throw new CliError("Usage: rig github auth status", 1);
       const status = await withSpinner("Checking GitHub auth on the server\u2026", () => getGitHubAuthStatusViaServer(context), { outputMode: context.outputMode });
-      printPayload(context, status, `GitHub auth: ${isSignedIn(status) ? "authenticated" : "unauthenticated"}`);
+      printPayload(context, status, `GitHub auth: ${status.authenticated ? "authenticated" : "unauthenticated"}`);
       return { ok: true, group: "github", command: "auth status", details: status };
     }
     case "token": {
@@ -9725,20 +8933,16 @@ async function executeGithub(context, args) {
       const token = parsed.value?.trim();
       if (!token)
         throw new CliError("Missing --token value.", 1, { hint: "Re-run as `rig github auth token --token <token>`." });
-      const repo = readRepoConnection(context.projectRoot);
-      const result = await withSpinner("Storing GitHub token on the server\u2026", () => postGitHubTokenViaServer(context, token, repo?.project ? { selectedRepo: repo.project } : {}), { outputMode: context.outputMode });
-      persistRemoteAuthSession(context, "token", result, token);
-      printPayload(context, result, "GitHub token stored on the selected server.");
+      const result = await withSpinner("Storing GitHub token on the server\u2026", () => postGitHubTokenViaServer(context, token), { outputMode: context.outputMode });
+      printPayload(context, result, "GitHub token stored on the selected Rig server.");
       return { ok: true, group: "github", command: "auth token", details: result };
     }
     case "import-gh": {
       if (rest.length > 0)
         throw new CliError("Usage: rig github auth import-gh", 1);
       const importedToken = readGhToken();
-      const repo = readRepoConnection(context.projectRoot);
-      const result = await withSpinner("Storing GitHub token on the server\u2026", () => postGitHubTokenViaServer(context, importedToken, repo?.project ? { selectedRepo: repo.project } : {}), { outputMode: context.outputMode });
-      persistRemoteAuthSession(context, "gh", result, importedToken);
-      printPayload(context, result, "GitHub token imported from gh and stored on the selected server.");
+      const result = await withSpinner("Storing GitHub token on the server\u2026", () => postGitHubTokenViaServer(context, importedToken), { outputMode: context.outputMode });
+      printPayload(context, result, "GitHub token imported from gh and stored on the selected Rig server.");
       return { ok: true, group: "github", command: "auth import-gh", details: result };
     }
     default:
@@ -9768,7 +8972,7 @@ init_runner();
 init__authority_runs();
 init__paths();
 import { readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve19 } from "path";
+import { resolve as resolve18 } from "path";
 import {
   appendRunJournalEvent,
   appendRunLogEntry,
@@ -9805,7 +9009,7 @@ function touchAuthorityRun(projectRoot, runId) {
   if (!current) {
     return;
   }
-  writeJsonFile3(resolve19(resolveAuthorityRunDir(projectRoot, runId), "run.json"), {
+  writeJsonFile3(resolve18(resolveAuthorityRunDir(projectRoot, runId), "run.json"), {
     ...current,
     updatedAt: new Date().toISOString()
   });
@@ -10043,7 +9247,7 @@ init_runner();
 init__server_client();
 init__async_ui();
 import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve20 } from "path";
+import { resolve as resolve19 } from "path";
 import {
   listAuthorityRuns,
   readAuthorityRun as readAuthorityRun3,
@@ -10087,7 +9291,7 @@ async function executeInspect(context, args) {
         }
         return { ok: true, group: "inspect", command, details: { task: requiredTask, runId: fallback.runId, source: "server", entries } };
       }
-      const logsPath = resolve20(resolveAuthorityRunDir2(context.projectRoot, latestRun.runId), "logs.jsonl");
+      const logsPath = resolve19(resolveAuthorityRunDir2(context.projectRoot, latestRun.runId), "logs.jsonl");
       if (!existsSync12(logsPath)) {
         throw new CliError(`No logs found for run ${latestRun.runId}.`, 1, { hint: `Try \`rig run show ${latestRun.runId}\` or \`rig run replay ${latestRun.runId}\`.` });
       }
@@ -10175,7 +9379,7 @@ async function executeInspect(context, args) {
       return { ok: true, group: "inspect", command };
     case "audit": {
       requireNoExtraArgs(rest, "rig inspect audit");
-      const auditPath = resolve20(resolveHarnessPaths2(context.projectRoot).logsDir, "audit.jsonl");
+      const auditPath = resolve19(resolveHarnessPaths2(context.projectRoot).logsDir, "audit.jsonl");
       if (!existsSync12(auditPath)) {
         console.log("No audit log found.");
       } else {
@@ -10834,7 +10038,7 @@ import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/co
 
 // packages/cli/src/commands/_run-replay.ts
 import { existsSync as existsSync13, readdirSync as readdirSync2 } from "fs";
-import { join as join2, resolve as resolve21 } from "path";
+import { join as join2, resolve as resolve20 } from "path";
 import {
   readAuthorityRun as readAuthorityRun4,
   readJsonlFile as readJsonlFile3,
@@ -10927,7 +10131,7 @@ function resolveRunSessionFile(record) {
   const sessionId = text(piSession.sessionId);
   if (!cwd || !sessionId)
     return null;
-  const sessionDir = resolve21(cwd, ".rig", "session");
+  const sessionDir = resolve20(cwd, ".rig", "session");
   try {
     const match = readdirSync2(sessionDir).find((name) => name.endsWith(`_${sessionId}.jsonl`));
     return match ? join2(sessionDir, match) : null;
@@ -11425,9 +10629,6 @@ async function executeRun(context, args) {
           console.log(`Stop requested: ${runId}`);
         return { ok: true, group: "run", command, details: stopped };
       }
-      if (isRemoteConnectionSelected(context.projectRoot)) {
-        throw new CliError("Remote run stop requires an explicit run id.", 2, { hint: "Run `rig run list`, then `rig run stop <run-id>`." });
-      }
       const result = await runStop(context.projectRoot);
       if (result.remaining.length > 0) {
         throw new CliError(`Failed to stop run(s): ${result.remaining.join(", ")}`, 1, { hint: "Check `rig run status`, then retry `rig run stop <run-id>` for the remaining runs." });
@@ -11460,7 +10661,6 @@ init_drone_ui();
 init_runner();
 init__connection_state();
 init__cli_format();
-init__server_client();
 function usageName(options) {
   return `rig ${options.group}`;
 }
@@ -11480,46 +10680,13 @@ function parseConnection(alias, value, options) {
   }
   return { kind: "remote", baseUrl: parsed.toString().replace(/\/+$/, "") };
 }
-function printJsonOrText(context, _payload, text2) {
-  if (context.outputMode !== "json") {
+function printJsonOrText(context, payload, text2) {
+  if (context.outputMode === "json") {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
     console.log(text2);
   }
 }
-function formatRemoteProjectLinkText(result) {
-  return formatSuccessCard(result.ok ? "Remote project link ready" : "Remote project link needs repair", [
-    ["selected", result.alias ?? "remote"],
-    ["target", result.baseUrl ?? "unknown"],
-    ["repo", result.repoSlug ?? "owner/repo"],
-    ["status", result.status],
-    ...result.serverProjectRoot ? [["server root", result.serverProjectRoot]] : [],
-    ["next", result.ok ? result.next ?? "rig task list" : result.hint]
-  ]);
-}
-function parseRepairLinkArgs(rest, usage) {
-  let repoSlug;
-  let mode = "prepare-if-missing";
-  const pending = [...rest];
-  while (pending.length > 0) {
-    const token = pending.shift();
-    if (token === "--repo") {
-      const value = pending.shift()?.trim();
-      if (!value)
-        throw new CliError(`Missing --repo value. Usage: ${usage}`, 1);
-      const normalized = normalizeRepoSlug(value);
-      if (!normalized)
-        throw new CliError(`Invalid --repo value: ${value}`, 1, { hint: "Use the canonical owner/repo slug, e.g. `--repo humanity-org/humanwork`." });
-      repoSlug = normalized;
-    } else if (token === "--backfill-only") {
-      mode = "backfill-only";
-    } else if (token === "--prepare") {
-      mode = "prepare-if-missing";
-    } else {
-      throw new CliError(`Unexpected argument: ${String(token)}
-Usage: ${usage}`, 1);
-    }
-  }
-  return { repoSlug, mode };
-}
 async function promptForConnectionAlias(context) {
   const state = readGlobalConnections();
   const repo = readRepoConnection(context.projectRoot);
@@ -11573,67 +10740,31 @@ async function executeConnectionCommand(context, args, options) {
       }
       if (!alias)
         throw new CliError(`Missing alias. Usage: ${usageName(options)} use <alias|local>`, 1);
-      let selectedConnection = { kind: "local", mode: "auto" };
       if (alias !== "local") {
         const state = readGlobalConnections();
-        const connection = state.connections[alias];
-        if (!connection)
+        if (!state.connections[alias])
           throw new CliError(`Unknown Rig server: ${alias}`, 1, { hint: "Run `rig server list` to see saved aliases, or save one with `rig server add <alias> <url>`." });
-        selectedConnection = connection;
-      }
-      const previousRepo = readRepoConnection(context.projectRoot);
-      const preserveRemoteRoot = Boolean(previousRepo?.serverProjectRoot && previousRepo.selected === alias && selectedConnection.kind === "remote" && previousRepo.serverProjectRootAlias === alias && previousRepo.serverProjectRootBaseUrl === selectedConnection.baseUrl);
-      const repoState = {
-        selected: alias,
-        ...previousRepo?.project ? { project: previousRepo.project } : {},
-        linkedAt: new Date().toISOString(),
-        ...preserveRemoteRoot ? {
-          serverProjectRoot: previousRepo.serverProjectRoot,
-          serverProjectRootAlias: previousRepo.serverProjectRootAlias,
-          serverProjectRootBaseUrl: previousRepo.serverProjectRootBaseUrl
-        } : {}
-      };
+      }
+      const repoState = { selected: alias, linkedAt: new Date().toISOString() };
       writeRepoConnection(context.projectRoot, repoState);
-      const remoteProjectLink = alias !== "local" ? await ensureRemoteProjectRootLink(context.projectRoot, { mode: "backfill-only" }).catch((error) => ({
-        ok: false,
-        status: "error",
-        message: error instanceof Error ? error.message : String(error),
-        hint: "Run `rig server repair-link` after authenticating the selected remote."
-      })) : null;
-      const latestRepo = readRepoConnection(context.projectRoot);
-      const details = { selected: latestRepo?.selected ?? alias, repo: latestRepo, remoteProjectLink };
-      printJsonOrText(context, details, formatSuccessCard("Rig server selected", [
+      printJsonOrText(context, repoState, formatSuccessCard("Rig server selected", [
         ["selected", alias],
         ["scope", "this repo"],
-        ...remoteProjectLink ? [["remote link", remoteProjectLink.ok ? `ready (${remoteProjectLink.serverProjectRoot ?? "linked"})` : `${remoteProjectLink.status}: ${remoteProjectLink.hint}`]] : [],
-        ["next", remoteProjectLink && !remoteProjectLink.ok ? "rig server repair-link" : "rig task list"]
+        ["next", "rig task list"]
       ]));
-      return { ok: true, group: options.group, command: "use", details };
-    }
-    case "repair-link": {
-      const parsed = parseRepairLinkArgs(rest, `${usageName(options)} repair-link [--prepare|--backfill-only] [--repo owner/repo]`);
-      const result = await repairRemoteProjectRootLink(context, parsed);
-      printJsonOrText(context, result, formatRemoteProjectLinkText(result));
-      return { ok: true, group: options.group, command: "repair-link", details: result };
+      return { ok: true, group: options.group, command: "use", details: repoState };
     }
     case "status": {
       requireNoExtraArgs(rest, `${usageName(options)} status`);
       const repo = readRepoConnection(context.projectRoot);
       const global = readGlobalConnections();
-      const remoteProjectLink = repo?.selected && repo.selected !== "local" ? await ensureRemoteProjectRootLink(context.projectRoot, { mode: "backfill-only" }).catch((error) => ({
-        ok: false,
-        status: "error",
-        message: error instanceof Error ? error.message : String(error),
-        hint: "Run `rig server repair-link` after authenticating the selected remote."
-      })) : null;
-      const latestRepo = readRepoConnection(context.projectRoot) ?? repo;
-      const details = { selected: latestRepo?.selected ?? "local", repo: latestRepo, connections: global.connections, remoteProjectLink };
-      printJsonOrText(context, details, formatConnectionStatus(details.selected, global.connections, latestRepo ?? null, remoteProjectLink));
+      const details = { selected: repo?.selected ?? "local", repo, connections: global.connections };
+      printJsonOrText(context, details, formatConnectionStatus(details.selected, global.connections));
       return { ok: true, group: options.group, command: "status", details };
     }
     default:
       throw new CliError(`Unknown ${options.group} command: ${String(command)}
-Usage: ${usageName(options)} <list|add|use|status|repair-link>`, 1);
+Usage: ${usageName(options)} <list|add|use|status>`, 1);
   }
 }
 
@@ -11641,7 +10772,7 @@ Usage: ${usageName(options)} <list|add|use|status|repair-link>`, 1);
 init__server_client();
 async function executeServer(context, args, options) {
   const [command = "status", ...rest] = args;
-  if (["status", "list", "add", "use", "repair-link"].includes(command)) {
+  if (["status", "list", "add", "use"].includes(command)) {
     return executeConnectionCommand(context, [command, ...rest], { group: "server", interactiveUse: true });
   }
   switch (command) {
@@ -11849,8 +10980,8 @@ init_task();
 
 // packages/cli/src/commands/task-run-driver.ts
 init_runner();
-import { copyFileSync as copyFileSync3, existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync12, statSync as statSync2, writeFileSync as writeFileSync9 } from "fs";
-import { resolve as resolve23 } from "path";
+import { copyFileSync as copyFileSync3, existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync12, statSync as statSync2, writeFileSync as writeFileSync7 } from "fs";
+import { resolve as resolve22 } from "path";
 import { spawn as spawn2, spawnSync as spawnSync4 } from "child_process";
 import { createInterface as createLineInterface } from "readline";
 import { loadConfig as loadConfig2 } from "@rig/core/load-config";
@@ -11949,12 +11080,12 @@ function copyUntrackedDirtyFiles(sourceRoot, targetRoot) {
     return 0;
   let copied = 0;
   for (const relativePath of listed.stdout.split("\x00").filter(Boolean)) {
-    const sourcePath = resolve23(sourceRoot, relativePath);
-    const targetPath = resolve23(targetRoot, relativePath);
+    const sourcePath = resolve22(sourceRoot, relativePath);
+    const targetPath = resolve22(targetRoot, relativePath);
     try {
       if (!statSync2(sourcePath).isFile())
         continue;
-      mkdirSync11(resolve23(targetPath, ".."), { recursive: true });
+      mkdirSync9(resolve22(targetPath, ".."), { recursive: true });
       copyFileSync3(sourcePath, targetPath);
       copied += 1;
     } catch {}
@@ -11993,7 +11124,7 @@ function buildDirtyBaselineHandshakeEnv(input) {
     return { RIG_BASELINE_MODE: input.baselineMode ?? "head" };
   return {
     RIG_BASELINE_MODE: "dirty-snapshot",
-    RIG_DIRTY_BASELINE_READY_FILE: resolve23(input.projectRoot, ".rig", "runs", input.runId, "dirty-baseline.ready.json")
+    RIG_DIRTY_BASELINE_READY_FILE: resolve22(input.projectRoot, ".rig", "runs", input.runId, "dirty-baseline.ready.json")
   };
 }
 function positiveInt(value, fallback) {
@@ -12098,9 +11229,9 @@ function createCommandRunner(binary) {
     const stderrChunks = [];
     child.stdout.on("data", (chunk) => stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))));
     child.stderr.on("data", (chunk) => stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))));
-    return await new Promise((resolve24) => {
-      child.once("error", (error) => resolve24({ exitCode: 1, stderr: error.message }));
-      child.once("close", (code) => resolve24({
+    return await new Promise((resolve23) => {
+      child.once("error", (error) => resolve23({ exitCode: 1, stderr: error.message }));
+      child.once("close", (code) => resolve23({
         exitCode: code ?? 1,
         stdout: Buffer.concat(stdoutChunks).toString("utf8"),
         stderr: Buffer.concat(stderrChunks).toString("utf8")
@@ -12174,7 +11305,7 @@ async function runTaskRunPostValidationLifecycle(input) {
     config,
     sourceTask: input.sourceTask,
     uploadedSnapshot: input.uploadedSnapshot,
-    artifactRoot: resolve23(input.projectRoot, "artifacts", taskId3),
+    artifactRoot: resolve22(input.projectRoot, "artifacts", taskId3),
     command: ghCommand,
     gitCommand,
     steerPi,
@@ -12304,7 +11435,7 @@ function summarizeValidationFailure(projectRoot, taskId3) {
     return null;
   }
   for (const artifactDir of resolveTaskArtifactDirs2(projectRoot, taskId3)) {
-    const summary = readJsonFile3(resolve23(artifactDir, "validation-summary.json"), null);
+    const summary = readJsonFile3(resolve22(artifactDir, "validation-summary.json"), null);
     if (!summary || summary.status !== "fail") {
       continue;
     }
@@ -12385,9 +11516,9 @@ function readTaskRunAcceptedArtifactState(input) {
   if (!input.taskId || !input.workspaceDir) {
     return { accepted: false, reason: null };
   }
-  const artifactDir = resolve23(input.workspaceDir, "artifacts", input.taskId);
-  const reviewStatusPath = resolve23(artifactDir, "review-status.txt");
-  const taskResultPath = resolve23(artifactDir, "task-result.json");
+  const artifactDir = resolve22(input.workspaceDir, "artifacts", input.taskId);
+  const reviewStatusPath = resolve22(artifactDir, "review-status.txt");
+  const taskResultPath = resolve22(artifactDir, "task-result.json");
   const reviewStatus = readTaskRunReviewStatus(reviewStatusPath);
   if (reviewStatus !== "APPROVED") {
     return { accepted: false, reason: null };
@@ -12424,12 +11555,12 @@ function resolveTaskRunRetryContext(input) {
   if (!input.taskId || !input.workspaceDir) {
     return { shouldRetry: false, failureDetail: null, nextPrompt: null };
   }
-  const artifactDir = resolve23(input.workspaceDir, "artifacts", input.taskId);
-  const reviewStatePath = resolve23(artifactDir, "review-state.json");
-  const reviewFeedbackPath = resolve23(artifactDir, "review-feedback.md");
-  const reviewStatusPath = resolve23(artifactDir, "review-status.txt");
-  const failedApproachesPath = resolve23(input.workspaceDir, ".rig", "state", "failed_approaches.md");
-  const validationSummaryPath = resolve23(artifactDir, "validation-summary.json");
+  const artifactDir = resolve22(input.workspaceDir, "artifacts", input.taskId);
+  const reviewStatePath = resolve22(artifactDir, "review-state.json");
+  const reviewFeedbackPath = resolve22(artifactDir, "review-feedback.md");
+  const reviewStatusPath = resolve22(artifactDir, "review-status.txt");
+  const failedApproachesPath = resolve22(input.workspaceDir, ".rig", "state", "failed_approaches.md");
+  const validationSummaryPath = resolve22(artifactDir, "validation-summary.json");
   const reviewState = readJsonFile3(reviewStatePath, null);
   const reviewStatus = readTaskRunReviewStatus(reviewStatusPath);
   const reviewRejected = isTaskRunReviewRejected(reviewState);
@@ -12839,15 +11970,15 @@ async function executeRigOwnedTaskRun(context, input) {
   const loadedAutomationConfig = await loadTaskRunAutomationConfig(context.projectRoot);
   const automationConfig = input.prMode ? { ...loadedAutomationConfig ?? {}, pr: { ...loadedAutomationConfig?.pr ?? {}, mode: input.prMode } } : loadedAutomationConfig;
   const planningClassification = classifyPlanningNeed({ config: automationConfig, sourceTask });
-  const planningArtifactPath = resolve23("artifacts", runtimeTaskId, "implementation-plan.md");
+  const planningArtifactPath = resolve22("artifacts", runtimeTaskId, "implementation-plan.md");
   const persistedPlanning = {
     ...planningClassification,
     classifier: input.runtimeAdapter === "pi" ? "pi-rig-structured-policy" : "rig-structured-policy",
     artifactPath: planningClassification.planningRequired ? planningArtifactPath : null,
     classifiedAt: new Date().toISOString()
   };
-  mkdirSync11(resolve23(context.projectRoot, ".rig", "runs", input.runId), { recursive: true });
-  writeFileSync9(resolve23(context.projectRoot, ".rig", "runs", input.runId, "planning-classification.json"), `${JSON.stringify(persistedPlanning, null, 2)}
+  mkdirSync9(resolve22(context.projectRoot, ".rig", "runs", input.runId), { recursive: true });
+  writeFileSync7(resolve22(context.projectRoot, ".rig", "runs", input.runId, "planning-classification.json"), `${JSON.stringify(persistedPlanning, null, 2)}
 `, "utf8");
   patchAuthorityRun(context.projectRoot, input.runId, { planning: persistedPlanning });
   prompt = `${prompt}
@@ -12897,7 +12028,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
   let verificationStarted = false;
   let reviewStarted = false;
   let latestRuntimeWorkspace = resumeMode && typeof existingRunRecord?.worktreePath === "string" ? existingRunRecord.worktreePath : null;
-  let latestSessionDir = resumeMode && typeof existingRunRecord?.sessionPath === "string" ? resolve23(existingRunRecord.sessionPath, "..") : null;
+  let latestSessionDir = resumeMode && typeof existingRunRecord?.sessionPath === "string" ? resolve22(existingRunRecord.sessionPath, "..") : null;
   let latestLogsDir = resumeMode && typeof existingRunRecord?.logRoot === "string" ? existingRunRecord.logRoot : null;
   let latestProviderCommand = null;
   let latestRuntimeBranch = resumeMode && typeof existingRunRecord?.branch === "string" ? existingRunRecord.branch : null;
@@ -12983,10 +12114,10 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       setRunStatusOrFail(context.projectRoot, input.runId, "running");
       patchAuthorityRun(context.projectRoot, input.runId, {
         worktreePath: latestRuntimeWorkspace,
-        artifactRoot: latestRuntimeWorkspace && input.taskId ? resolve23(latestRuntimeWorkspace, "artifacts", input.taskId) : null,
+        artifactRoot: latestRuntimeWorkspace && input.taskId ? resolve22(latestRuntimeWorkspace, "artifacts", input.taskId) : null,
         logRoot: latestLogsDir,
-        sessionPath: latestSessionDir ? resolve23(latestSessionDir, "session.json") : null,
-        sessionLogPath: latestLogsDir ? resolve23(latestLogsDir, "agent-stdout.log") : null,
+        sessionPath: latestSessionDir ? resolve22(latestSessionDir, "session.json") : null,
+        sessionLogPath: latestLogsDir ? resolve22(latestLogsDir, "agent-stdout.log") : null,
         branch: runtimeId
       });
       if (!dirtyBaselineApplied && input.baselineMode === "dirty-snapshot" && latestRuntimeWorkspace) {
@@ -12994,8 +12125,8 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         const dirty = applyDirtyBaselineSnapshot({ sourceRoot: context.projectRoot, targetRoot: latestRuntimeWorkspace });
         const readyFile = childEnv.RIG_DIRTY_BASELINE_READY_FILE;
         if (readyFile) {
-          mkdirSync11(resolve23(readyFile, ".."), { recursive: true });
-          writeFileSync9(readyFile, `${JSON.stringify({ ...dirty, workspaceDir: latestRuntimeWorkspace, appliedAt: new Date().toISOString() }, null, 2)}
+          mkdirSync9(resolve22(readyFile, ".."), { recursive: true });
+          writeFileSync7(readyFile, `${JSON.stringify({ ...dirty, workspaceDir: latestRuntimeWorkspace, appliedAt: new Date().toISOString() }, null, 2)}
 `, "utf8");
         }
         appendRunLog(context.projectRoot, input.runId, {
@@ -13391,7 +12522,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
     let acceptedArtifactObservedAt = null;
     let acceptedArtifactPollTimer = null;
     let acceptedArtifactKillTimer = null;
-    const attemptExit = await new Promise((resolve24) => {
+    const attemptExit = await new Promise((resolve23) => {
       let settled = false;
       const settle = (result) => {
         if (settled)
@@ -13399,7 +12530,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         settled = true;
         if (acceptedArtifactPollTimer)
           clearInterval(acceptedArtifactPollTimer);
-        resolve24(result);
+        resolve23(result);
       };
       const pollAcceptedArtifacts = () => {
         const artifactState = readTaskRunAcceptedArtifactState({
@@ -13602,7 +12733,7 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
   }
   if (planningClassification.planningRequired) {
     const planWorkspace = latestRuntimeWorkspace ?? context.projectRoot;
-    const expectedPlanPath = resolve23(planWorkspace, planningArtifactPath);
+    const expectedPlanPath = resolve22(planWorkspace, planningArtifactPath);
     if (!existsSync15(expectedPlanPath)) {
       const failedAt = new Date().toISOString();
       const failureDetail = `Planning was required (${planningClassification.reason}) but ${planningArtifactPath} was not written before implementation completed.`;
@@ -13772,9 +12903,9 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
       });
       emitServerRunEvent({ type: "log", runId: input.runId, title: "Pi PR feedback fix stderr" });
     });
-    const exitCode = await new Promise((resolve24) => {
-      child.once("error", () => resolve24(1));
-      child.once("close", (code) => resolve24(code ?? 1));
+    const exitCode = await new Promise((resolve23) => {
+      child.once("error", () => resolve23(1));
+      child.once("close", (code) => resolve23(code ?? 1));
     });
     for (const pendingLog of flushPendingClaudeToolUseLogs({
       runId: input.runId,
@@ -13915,8 +13046,8 @@ async function executeTest(context, args) {
 init_runner();
 init__parsers();
 init__paths();
-import { existsSync as existsSync16, mkdirSync as mkdirSync12, readdirSync as readdirSync3, writeFileSync as writeFileSync10 } from "fs";
-import { resolve as resolve24 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, readdirSync as readdirSync3, writeFileSync as writeFileSync8 } from "fs";
+import { resolve as resolve23 } from "path";
 import { createPluginHost } from "@rig/core";
 import {
   isSupportedBunVersion as isSupportedBunVersion2,
@@ -13971,12 +13102,12 @@ function runSetupInit(projectRoot) {
   const stateDir = resolveControlPlaneHostStateDir(projectRoot);
   const logsDir = resolveControlPlaneHostLogsDir(projectRoot);
   const artifactsDir = resolveControlPlaneArtifactsDir(projectRoot);
-  mkdirSync12(stateDir, { recursive: true });
-  mkdirSync12(logsDir, { recursive: true });
-  mkdirSync12(artifactsDir, { recursive: true });
-  const failuresPath = resolve24(stateDir, "failed_approaches.md");
+  mkdirSync10(stateDir, { recursive: true });
+  mkdirSync10(logsDir, { recursive: true });
+  mkdirSync10(artifactsDir, { recursive: true });
+  const failuresPath = resolve23(stateDir, "failed_approaches.md");
   if (!existsSync16(failuresPath)) {
-    writeFileSync10(failuresPath, `# Failed Approaches
+    writeFileSync8(failuresPath, `# Failed Approaches
 
 `, "utf-8");
   }
@@ -13993,17 +13124,17 @@ async function runSetupCheck(projectRoot, outputMode = "text") {
 }
 async function runSetupPreflight(projectRoot, outputMode = "text") {
   await runSetupCheck(projectRoot, outputMode);
-  const validationRoot = resolve24(resolveControlPlaneDefinitionRoot(projectRoot), "validation");
+  const validationRoot = resolve23(resolveControlPlaneDefinitionRoot(projectRoot), "validation");
   if (existsSync16(validationRoot)) {
     const validators = readdirSync3(validationRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
     for (const validator of validators) {
-      const script = resolve24(validationRoot, validator.name, "validate.sh");
+      const script = resolve23(validationRoot, validator.name, "validate.sh");
       if (existsSync16(script)) {
         console.log(`OK: validator script ${script}`);
       }
     }
   }
-  const hooksRoot = resolve24(resolveControlPlaneDefinitionRoot(projectRoot), "hooks");
+  const hooksRoot = resolve23(resolveControlPlaneDefinitionRoot(projectRoot), "hooks");
   if (existsSync16(hooksRoot)) {
     const hooks = readdirSync3(hooksRoot).filter((name) => name.endsWith(".sh"));
     for (const hook of hooks) {
@@ -14150,7 +13281,7 @@ var PROJECT_REQUIRED_GROUPS = new Set([
 ]);
 var RIG_CONFIG_FILENAMES = ["rig.config.ts", "rig.config.mts", "rig.config.json"];
 function hasInitializedRigProject(projectRoot) {
-  return RIG_CONFIG_FILENAMES.some((name) => existsSync18(resolve25(projectRoot, name))) || existsSync18(resolve25(projectRoot, ".rig"));
+  return RIG_CONFIG_FILENAMES.some((name) => existsSync18(resolve24(projectRoot, name))) || existsSync18(resolve24(projectRoot, ".rig"));
 }
 function requireInitializedRigProject(context, group) {
   if (hasInitializedRigProject(context.projectRoot)) {
@@ -14204,7 +13335,7 @@ function resolveTopLevelLaunchState(context) {
   let selectedServer = null;
   if (projectInitialized) {
     try {
-      const statePath = resolve25(context.projectRoot, ".rig", "state", "connection.json");
+      const statePath = resolve24(context.projectRoot, ".rig", "state", "connection.json");
       if (existsSync18(statePath)) {
         const parsed = JSON.parse(readFileSync13(statePath, "utf-8"));
         selectedServer = parsed.remoteUrl || parsed.url || parsed.selected || null;
@@ -14213,14 +13344,8 @@ function resolveTopLevelLaunchState(context) {
   }
   return { projectInitialized, selectedServer, version: process.env.RIG_CLI_VERSION || readBuildConfig().RIG_CLI_VERSION || undefined };
 }
-function envTruthy(value) {
-  if (!value)
-    return false;
-  const normalized = value.trim().toLowerCase();
-  return normalized !== "0" && normalized !== "false" && normalized !== "no";
-}
 function shouldOpenApp(context) {
-  return context.outputMode === "text" && Boolean(process.stdin.isTTY && process.stdout.isTTY) && process.env.RIG_CLI_PLAIN_HELP !== "1" && process.env.RIG_PLAIN !== "1" && !envTruthy(process.env.CI);
+  return context.outputMode === "text" && Boolean(process.stdin.isTTY && process.stdout.isTTY) && process.env.RIG_CLI_PLAIN_HELP !== "1";
 }
 async function openApp(context, options = {}) {
   const { runOperatorBoardLoop: runOperatorBoardLoop2 } = await Promise.resolve().then(() => (init_board(), exports_board));