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

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

@@ -57,6 +57,21 @@ function patchData(ctx, data) {
 function patchFooter(ctx, footer) {
   ctx.emit({ type: "footer.patch", footer });
 }
+async function releaseRendererForExternalTui(ctx) {
+  const renderer = ctx.renderer;
+  if (!renderer)
+    return;
+  if (renderer.suspend) {
+    await renderer.suspend();
+    return;
+  }
+  if (renderer.destroy) {
+    await renderer.destroy();
+  }
+}
+async function resumeRendererAfterExternalTui(ctx) {
+  await ctx.renderer?.resume?.();
+}
 function arrayFromPayload(value) {
   if (Array.isArray(value)) {
     return value.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
@@ -168,12 +183,28 @@ function readRepoConnection(projectRoot) {
     selected,
     project: typeof record.project === "string" ? record.project : undefined,
     linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
-    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined
+    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined,
+    serverProjectRootAlias: typeof record.serverProjectRootAlias === "string" && record.serverProjectRootAlias.trim() ? record.serverProjectRootAlias.trim() : undefined,
+    serverProjectRootBaseUrl: typeof record.serverProjectRootBaseUrl === "string" && record.serverProjectRootBaseUrl.trim() ? record.serverProjectRootBaseUrl.trim().replace(/\/+$/, "") : undefined
   };
 }
 function writeRepoConnection(projectRoot, state) {
   writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
 }
+function rootAllowedForSelection(repo, connection) {
+  const root = repo.serverProjectRoot?.trim();
+  if (!root)
+    return;
+  if (connection.kind === "remote") {
+    if (repo.serverProjectRootAlias !== repo.selected)
+      return;
+    if (repo.serverProjectRootBaseUrl !== connection.baseUrl)
+      return;
+  } else if (repo.serverProjectRootAlias && repo.serverProjectRootAlias !== repo.selected) {
+    return;
+  }
+  return root;
+}
 function resolveSelectedConnection(projectRoot, options = {}) {
   const repo = readRepoConnection(projectRoot);
   if (!repo)
@@ -185,13 +216,41 @@ function resolveSelectedConnection(projectRoot, options = {}) {
   if (!connection) {
     throw new CliError(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
   }
-  return { alias: repo.selected, connection, serverProjectRoot: repo.serverProjectRoot };
+  return { alias: repo.selected, connection, serverProjectRoot: rootAllowedForSelection(repo, connection) };
 }
-function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
+function writeRepoServerProjectRoot(projectRoot, serverProjectRoot, metadata = {}) {
   const repo = readRepoConnection(projectRoot);
   if (!repo)
     return;
-  writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
+  let inferred = metadata;
+  if (!inferred.alias || !inferred.baseUrl) {
+    try {
+      const selected = resolveSelectedConnection(projectRoot);
+      if (selected?.connection.kind === "remote") {
+        inferred = {
+          alias: inferred.alias ?? selected.alias,
+          baseUrl: inferred.baseUrl ?? selected.connection.baseUrl
+        };
+      }
+    } catch {}
+  }
+  writeRepoConnection(projectRoot, {
+    ...repo,
+    ...metadata.project ? { project: metadata.project } : {},
+    serverProjectRoot,
+    ...inferred.alias ? { serverProjectRootAlias: inferred.alias } : {},
+    ...inferred.baseUrl ? { serverProjectRootBaseUrl: inferred.baseUrl.replace(/\/+$/, "") } : {}
+  });
+}
+function clearRepoServerProjectRoot(projectRoot) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return;
+  writeRepoConnection(projectRoot, {
+    selected: repo.selected,
+    ...repo.project ? { project: repo.project } : {},
+    ...repo.linkedAt ? { linkedAt: repo.linkedAt } : {}
+  });
 }
 var init__connection_state = __esm(() => {
   init_runner();
@@ -215,12 +274,16 @@ __export(exports__server_client, {
   respondRunPiExtensionUiViaServer: () => respondRunPiExtensionUiViaServer,
   resolveServerConnectionLabel: () => resolveServerConnectionLabel,
   requestServerJson: () => requestServerJson,
+  repairRemoteProjectRootLink: () => repairRemoteProjectRootLink,
   registerProjectViaServer: () => registerProjectViaServer,
   prepareRemoteCheckoutViaServer: () => prepareRemoteCheckoutViaServer,
   postGitHubTokenViaServer: () => postGitHubTokenViaServer,
+  normalizeRepoSlug: () => normalizeRepoSlug,
   listWorkspaceTasksViaServer: () => listWorkspaceTasksViaServer,
   listRunsViaServer: () => listRunsViaServer,
   listGitHubProjectsViaServer: () => listGitHubProjectsViaServer,
+  isRemoteProjectRootLinkError: () => isRemoteProjectRootLinkError,
+  inspectRemoteProjectLink: () => inspectRemoteProjectLink,
   getWorkspaceTaskViaServer: () => getWorkspaceTaskViaServer,
   getRunTimelineViaServer: () => getRunTimelineViaServer,
   getRunPiStatusViaServer: () => getRunPiStatusViaServer,
@@ -232,13 +295,15 @@ __export(exports__server_client, {
   getRunDetailsViaServer: () => getRunDetailsViaServer,
   getGitHubProjectStatusFieldViaServer: () => getGitHubProjectStatusFieldViaServer,
   getGitHubAuthStatusViaServer: () => getGitHubAuthStatusViaServer,
+  formatRemoteProjectLinkHint: () => formatRemoteProjectLinkHint,
   ensureTaskLabelsViaServer: () => ensureTaskLabelsViaServer,
   ensureServerForCli: () => ensureServerForCli,
+  ensureRemoteProjectRootLink: () => ensureRemoteProjectRootLink,
   buildRunPiEventsWebSocketUrl: () => buildRunPiEventsWebSocketUrl,
   abortRunPiViaServer: () => abortRunPiViaServer
 });
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, isAbsolute, resolve as resolve2 } from "path";
 import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
 function setServerPhaseListener(listener) {
   const previous = serverPhaseListener;
@@ -284,11 +349,10 @@ function readStoredGitHubAuthToken(projectRoot) {
   const parsed = readRemoteAuthState(projectRoot);
   return parsed ? cleanToken(typeof parsed.token === "string" ? parsed.token : undefined) : null;
 }
-function inferRemoteServerProjectRootFromAuthState(projectRoot) {
-  const repo = readRepoConnection(projectRoot);
-  const slug = repo?.project?.trim();
-  if (!slug || !/^[^/]+\/[^/]+$/.test(slug))
+function inferRemoteServerProjectRootCandidateFromAuthState(projectRoot, repoSlug) {
+  if (!/^[^/]+\/[^/]+$/.test(repoSlug))
     return null;
+  const repo = readRepoConnection(projectRoot);
   const auth = readRemoteAuthState(projectRoot);
   const authUpdatedAt = typeof auth?.updatedAt === "string" ? Date.parse(auth.updatedAt) : Number.NaN;
   const repoLinkedAt = typeof repo?.linkedAt === "string" ? Date.parse(repo.linkedAt) : Number.NaN;
@@ -297,25 +361,426 @@ function inferRemoteServerProjectRootFromAuthState(projectRoot) {
   const checkoutBaseDir = typeof auth?.checkoutBaseDir === "string" && auth.checkoutBaseDir.trim() ? auth.checkoutBaseDir.trim() : null;
   if (!checkoutBaseDir)
     return null;
-  const inferred = `${checkoutBaseDir.replace(/\/+$/, "")}/${slug}`;
-  writeRepoServerProjectRoot(projectRoot, inferred);
-  return inferred;
+  return `${checkoutBaseDir.replace(/\/+$/, "")}/${repoSlug}`;
 }
 function readLocalConnectionFallbackToken(projectRoot) {
   return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
 }
+function normalizeRepoSlug(value) {
+  const slug = value?.trim();
+  return slug && /^[^/\s]+\/[^/\s]+$/.test(slug) ? slug : null;
+}
+function readProjectLinkSlug(projectRoot) {
+  const path = resolve2(projectRoot, ".rig", "state", "project-link.json");
+  if (!existsSync2(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return null;
+    return normalizeRepoSlug(typeof parsed.repoSlug === "string" ? String(parsed.repoSlug) : null);
+  } catch {
+    return null;
+  }
+}
+function writeProjectLinkConnection(projectRoot, repoSlug, alias) {
+  const path = resolve2(projectRoot, ".rig", "state", "project-link.json");
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify({ repoSlug, connection: alias, linkedAt: new Date().toISOString() }, null, 2)}
+`, "utf8");
+}
+function remoteLinkRepairCommand(repoSlug) {
+  return repoSlug ? `rig server repair-link --repo ${repoSlug}` : "rig server repair-link --repo owner/repo";
+}
+function isRemoteProjectRootLinkError(error) {
+  const text = error instanceof Error ? error.message : String(error ?? "");
+  return /no server-host project root link|remote project(?:-root)? link|x-rig-project-root|serverProjectRoot/i.test(text);
+}
+function formatRemoteProjectLinkHint(resolution) {
+  const repair = remoteLinkRepairCommand(resolution.repoSlug);
+  if (resolution.status === "auth_required") {
+    return `Authenticate the selected remote${resolution.alias ? ` (${resolution.alias})` : ""}, then run \`${repair}\`. Use \`rig github auth import-gh\` or \`rig init --repair --server remote --github-auth device${resolution.repoSlug ? ` --repo ${resolution.repoSlug}` : ""}\`.`;
+  }
+  if (resolution.status === "missing_project") {
+    return `Record the repo slug, then run \`${repair}\` (or \`rig init --repo owner/repo --server remote --github-auth device\`).`;
+  }
+  if (resolution.status === "not_remote")
+    return "Select a remote server with `rig server use <alias>` before repairing a remote project link.";
+  return `Run \`${repair}\` to backfill or prepare a server-host checkout for the selected remote${resolution.alias ? ` (${resolution.alias})` : ""}.`;
+}
+function remoteProjectLinkFailure(input) {
+  const partial = {
+    status: input.status,
+    alias: input.alias,
+    baseUrl: input.baseUrl,
+    repoSlug: input.repoSlug
+  };
+  return {
+    ok: false,
+    ...input,
+    hint: formatRemoteProjectLinkHint(partial),
+    next: remoteLinkRepairCommand(input.repoSlug)
+  };
+}
+function remoteProjectLinkSuccess(input) {
+  return {
+    ok: true,
+    status: input.status,
+    alias: input.alias,
+    baseUrl: input.baseUrl,
+    repoSlug: input.repoSlug,
+    serverProjectRoot: input.serverProjectRoot,
+    source: input.source,
+    prepared: input.prepared ?? input.status === "prepared",
+    validated: input.validated ?? false,
+    message: input.message ?? `Remote project link ready for ${input.repoSlug}.`,
+    hint: "Remote-scoped task/run/status requests will send x-rig-project-root for this server-host checkout.",
+    next: "rig task list"
+  };
+}
+function localCheckoutPathCandidate(projectRoot, candidate) {
+  try {
+    const local = resolve2(projectRoot);
+    const resolved = resolve2(candidate);
+    return resolved === local || resolved.startsWith(`${local}/`);
+  } catch {
+    return false;
+  }
+}
+async function requestRemoteProjectLinkJson(baseUrl, pathname, authToken, init = {}) {
+  const requestUrl = new URL(`${baseUrl}${pathname}`);
+  if (authToken && queryAuthFallbackEnabled())
+    requestUrl.searchParams.set("rt", authToken);
+  const response = await fetch(requestUrl, {
+    ...init,
+    headers: mergeHeaders(init.headers, authToken)
+  });
+  const text = await response.text();
+  const payload = text.trim().length > 0 ? (() => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  })() : null;
+  return { ok: response.ok, status: response.status, payload, text };
+}
+function payloadError(payload, fallback) {
+  if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+    const record = payload;
+    const value = record.error ?? record.message ?? record.reason;
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  return fallback;
+}
+function checkoutPathsFromProjectPayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return [];
+  const project = payload.project;
+  if (!project || typeof project !== "object" || Array.isArray(project))
+    return [];
+  const checkouts = project.checkouts;
+  if (!Array.isArray(checkouts))
+    return [];
+  return [...checkouts].reverse().flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      return [];
+    const path = entry.path;
+    return typeof path === "string" && path.trim() ? [path.trim()] : [];
+  });
+}
+function checkoutPathFromPreparePayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const checkout = payload.checkout;
+  if (!checkout || typeof checkout !== "object" || Array.isArray(checkout))
+    return null;
+  const path = checkout.path;
+  return typeof path === "string" && path.trim() ? path.trim() : null;
+}
+async function validateAndPersistRemoteRoot(input) {
+  const candidate = input.candidate.trim();
+  if (!candidate || !isAbsolute(candidate)) {
+    return remoteProjectLinkFailure({
+      status: "invalid_root",
+      alias: input.alias,
+      baseUrl: input.baseUrl,
+      repoSlug: input.repoSlug,
+      message: `Remote project root candidate is not an absolute server-host path: ${candidate || "(empty)"}.`
+    });
+  }
+  if (localCheckoutPathCandidate(input.projectRoot, candidate)) {
+    return remoteProjectLinkFailure({
+      status: "invalid_root",
+      alias: input.alias,
+      baseUrl: input.baseUrl,
+      repoSlug: input.repoSlug,
+      message: `Refusing to use local checkout path ${candidate} as a remote server project root.`
+    });
+  }
+  let response;
+  try {
+    response = await requestRemoteProjectLinkJson(input.baseUrl, "/api/server/project-root", input.authToken, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ projectRoot: candidate })
+    });
+  } catch (error) {
+    return remoteProjectLinkFailure({
+      status: "error",
+      alias: input.alias,
+      baseUrl: input.baseUrl,
+      repoSlug: input.repoSlug,
+      message: `Could not validate remote project root ${candidate}: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  if (response.status === 401 || response.status === 403) {
+    return remoteProjectLinkFailure({
+      status: "auth_required",
+      alias: input.alias,
+      baseUrl: input.baseUrl,
+      repoSlug: input.repoSlug,
+      statusCode: response.status,
+      message: `Remote server ${input.alias} requires authentication before validating project root ${candidate}.`
+    });
+  }
+  if (!response.ok) {
+    return remoteProjectLinkFailure({
+      status: "invalid_root",
+      alias: input.alias,
+      baseUrl: input.baseUrl,
+      repoSlug: input.repoSlug,
+      statusCode: response.status,
+      message: `Remote server rejected project root ${candidate} (${response.status}): ${payloadError(response.payload, response.text || "project-root validation failed")}`
+    });
+  }
+  const record = response.payload && typeof response.payload === "object" && !Array.isArray(response.payload) ? response.payload : {};
+  if (record.ok !== true) {
+    return remoteProjectLinkFailure({
+      status: "invalid_root",
+      alias: input.alias,
+      baseUrl: input.baseUrl,
+      repoSlug: input.repoSlug,
+      message: `Remote server did not accept project root ${candidate}: ${payloadError(response.payload, "project-root validation failed")}`
+    });
+  }
+  const accepted = typeof record.projectRoot === "string" && record.projectRoot.trim() ? record.projectRoot.trim() : typeof record.requestedProjectRoot === "string" && record.requestedProjectRoot.trim() ? record.requestedProjectRoot.trim() : candidate;
+  writeRepoServerProjectRoot(input.projectRoot, accepted, { alias: input.alias, baseUrl: input.baseUrl, project: input.repoSlug });
+  writeProjectLinkConnection(input.projectRoot, input.repoSlug, input.alias);
+  const status = input.status ?? (input.prepared ? "prepared" : "backfilled");
+  return remoteProjectLinkSuccess({
+    status,
+    alias: input.alias,
+    baseUrl: input.baseUrl,
+    repoSlug: input.repoSlug,
+    serverProjectRoot: accepted,
+    source: input.source,
+    prepared: input.prepared,
+    validated: true,
+    message: status === "ready" ? `Remote project link already points to ${accepted} and was validated on ${input.alias}.` : input.prepared ? `Prepared and linked remote checkout ${accepted} for ${input.repoSlug}.` : `Backfilled remote checkout ${accepted} for ${input.repoSlug}.`
+  });
+}
+async function ensureRemoteProjectRootLink(projectRoot, options = {}) {
+  let selected;
+  try {
+    selected = resolveSelectedConnection(projectRoot);
+  } catch (error) {
+    return remoteProjectLinkFailure({ status: "error", message: error instanceof Error ? error.message : String(error) });
+  }
+  if (!selected || selected.connection.kind !== "remote") {
+    return remoteProjectLinkFailure({ status: "not_remote", message: "No remote Rig server is selected for this repo." });
+  }
+  const repo = readRepoConnection(projectRoot);
+  const explicitRepoRequested = options.repoSlug !== undefined;
+  const explicitRepoSlug = explicitRepoRequested ? normalizeRepoSlug(options.repoSlug) : null;
+  const repoProjectSlug = normalizeRepoSlug(repo?.project);
+  const repoSlug = explicitRepoSlug ?? repoProjectSlug ?? readProjectLinkSlug(projectRoot);
+  const alias = selected.alias;
+  const baseUrl = selected.connection.baseUrl;
+  const authToken = options.authToken === undefined ? readGitHubBearerTokenForRemote(projectRoot) : options.authToken;
+  const mode = options.mode ?? "backfill-only";
+  if (explicitRepoRequested && !explicitRepoSlug) {
+    return remoteProjectLinkFailure({
+      status: "missing_project",
+      alias,
+      baseUrl,
+      message: `Invalid --repo value ${JSON.stringify(options.repoSlug)}. Expected owner/repo.`
+    });
+  }
+  if (!repoSlug) {
+    return remoteProjectLinkFailure({
+      status: "missing_project",
+      alias,
+      baseUrl,
+      message: `Remote server ${alias} is selected, but this checkout has no GitHub repo slug recorded.`
+    });
+  }
+  const skippedCandidates = [];
+  const storedRoot = selected.serverProjectRoot?.trim() || null;
+  const storedRootMatchesResolvedRepo = repoProjectSlug === repoSlug;
+  if (storedRoot && storedRootMatchesResolvedRepo) {
+    if (localCheckoutPathCandidate(projectRoot, storedRoot)) {
+      clearRepoServerProjectRoot(projectRoot);
+      skippedCandidates.push(storedRoot);
+    } else {
+      const storedResult = await validateAndPersistRemoteRoot({
+        projectRoot,
+        alias,
+        baseUrl,
+        authToken,
+        repoSlug,
+        candidate: storedRoot,
+        source: "stored",
+        status: "ready"
+      });
+      if (storedResult.ok || storedResult.status === "auth_required" || storedResult.status === "error")
+        return storedResult;
+      clearRepoServerProjectRoot(projectRoot);
+      skippedCandidates.push(storedRoot);
+    }
+  } else if (storedRoot) {
+    skippedCandidates.push(storedRoot);
+  }
+  const authCandidate = inferRemoteServerProjectRootCandidateFromAuthState(projectRoot, repoSlug);
+  if (authCandidate) {
+    const authResult = await validateAndPersistRemoteRoot({ projectRoot, alias, baseUrl, authToken, repoSlug, candidate: authCandidate, source: "auth-state" });
+    if (authResult.ok || authResult.status === "auth_required")
+      return authResult;
+  }
+  let registryResponse;
+  try {
+    registryResponse = await requestRemoteProjectLinkJson(baseUrl, `/api/projects/${encodeURIComponent(repoSlug)}`, authToken);
+  } catch (error) {
+    return remoteProjectLinkFailure({
+      status: "error",
+      alias,
+      baseUrl,
+      repoSlug,
+      message: `Could not read remote project registry for ${repoSlug} on ${alias}: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  if (registryResponse.status === 401 || registryResponse.status === 403) {
+    return remoteProjectLinkFailure({
+      status: "auth_required",
+      alias,
+      baseUrl,
+      repoSlug,
+      statusCode: registryResponse.status,
+      message: `Remote server ${alias} requires authentication before reading the ${repoSlug} project registry.`
+    });
+  }
+  if (registryResponse.ok) {
+    const candidates = checkoutPathsFromProjectPayload(registryResponse.payload);
+    for (const candidate of candidates) {
+      const result = await validateAndPersistRemoteRoot({ projectRoot, alias, baseUrl, authToken, repoSlug, candidate, source: "registry" });
+      if (result.ok || result.status === "auth_required")
+        return result;
+      skippedCandidates.push(candidate);
+    }
+    if (mode === "backfill-only") {
+      return remoteProjectLinkFailure({
+        status: candidates.length > 0 ? "invalid_root" : "no_server_checkout",
+        alias,
+        baseUrl,
+        repoSlug,
+        message: candidates.length > 0 ? `Remote registry has checkout candidates for ${repoSlug}, but none validated for ${alias}.` : `Remote registry has ${repoSlug}, but no server checkout path is linked yet.`,
+        skippedCandidates
+      });
+    }
+  } else if (registryResponse.status === 404) {
+    if (mode === "backfill-only") {
+      return remoteProjectLinkFailure({
+        status: "project_not_registered",
+        alias,
+        baseUrl,
+        repoSlug,
+        statusCode: registryResponse.status,
+        message: `Remote server ${alias} has no registered project record for ${repoSlug}.`
+      });
+    }
+  } else {
+    return remoteProjectLinkFailure({
+      status: "error",
+      alias,
+      baseUrl,
+      repoSlug,
+      statusCode: registryResponse.status,
+      message: `Could not backfill ${repoSlug} from remote registry (${registryResponse.status}): ${payloadError(registryResponse.payload, registryResponse.text || "registry lookup failed")}`,
+      skippedCandidates
+    });
+  }
+  let prepareResponse;
+  try {
+    prepareResponse = await requestRemoteProjectLinkJson(baseUrl, `/api/projects/${encodeURIComponent(repoSlug)}/prepare-checkout`, authToken, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ checkout: { kind: "managed-clone" }, repoUrl: `https://github.com/${repoSlug}.git` })
+    });
+  } catch (error) {
+    return remoteProjectLinkFailure({
+      status: "error",
+      alias,
+      baseUrl,
+      repoSlug,
+      message: `Could not prepare remote checkout for ${repoSlug} on ${alias}: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  if (prepareResponse.status === 401 || prepareResponse.status === 403) {
+    return remoteProjectLinkFailure({
+      status: "auth_required",
+      alias,
+      baseUrl,
+      repoSlug,
+      statusCode: prepareResponse.status,
+      message: `Remote server ${alias} requires authentication before preparing ${repoSlug}.`
+    });
+  }
+  if (!prepareResponse.ok) {
+    return remoteProjectLinkFailure({
+      status: "error",
+      alias,
+      baseUrl,
+      repoSlug,
+      statusCode: prepareResponse.status,
+      message: `Remote checkout prepare failed for ${repoSlug} (${prepareResponse.status}): ${payloadError(prepareResponse.payload, prepareResponse.text || "prepare-checkout failed")}`,
+      skippedCandidates
+    });
+  }
+  const preparedPath = checkoutPathFromPreparePayload(prepareResponse.payload);
+  if (!preparedPath) {
+    return remoteProjectLinkFailure({
+      status: "invalid_root",
+      alias,
+      baseUrl,
+      repoSlug,
+      message: `Remote checkout prepare for ${repoSlug} did not return a checkout.path.`,
+      skippedCandidates
+    });
+  }
+  return validateAndPersistRemoteRoot({ projectRoot, alias, baseUrl, authToken, repoSlug, candidate: preparedPath, source: "prepare", prepared: true });
+}
+async function inspectRemoteProjectLink(projectRoot) {
+  return ensureRemoteProjectRootLink(projectRoot, { mode: "backfill-only" });
+}
+async function repairRemoteProjectRootLink(context, options = {}) {
+  const resolution = await ensureRemoteProjectRootLink(context.projectRoot, { mode: options.mode ?? "prepare-if-missing", repoSlug: options.repoSlug });
+  if (!resolution.ok)
+    throw new CliError(resolution.message, 1, { hint: resolution.hint });
+  return resolution;
+}
 async function ensureServerForCli(projectRoot) {
   try {
     const selected = resolveSelectedConnection(projectRoot);
     if (selected?.connection.kind === "remote") {
       reportServerPhase(`Connecting to ${selected.alias}\u2026`);
       const authToken = readGitHubBearerTokenForRemote(projectRoot);
-      const serverProjectRoot = selected.serverProjectRoot ?? inferRemoteServerProjectRootFromAuthState(projectRoot) ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
+      const link = await ensureRemoteProjectRootLink(projectRoot, { mode: "backfill-only", authToken });
       return {
         baseUrl: selected.connection.baseUrl,
         authToken,
         connectionKind: "remote",
-        serverProjectRoot
+        serverProjectRoot: link.ok ? link.serverProjectRoot ?? null : null
       };
     }
     reportServerPhase("Starting local Rig server\u2026");
@@ -333,32 +798,6 @@ async function ensureServerForCli(projectRoot) {
     throw error;
   }
 }
-async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken) {
-  const repo = readRepoConnection(projectRoot);
-  const slug = repo?.project?.trim();
-  if (!slug)
-    return null;
-  try {
-    const url = new URL(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`);
-    if (authToken && queryAuthFallbackEnabled())
-      url.searchParams.set("rt", authToken);
-    const response = await fetch(url, {
-      headers: mergeHeaders(undefined, authToken)
-    });
-    if (!response.ok)
-      return null;
-    const payload = await response.json();
-    const project = payload.project && typeof payload.project === "object" && !Array.isArray(payload.project) ? payload.project : null;
-    const checkouts = Array.isArray(project?.checkouts) ? project.checkouts : [];
-    const latestCheckout = [...checkouts].reverse().find((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.path === "string"));
-    const path = typeof latestCheckout?.path === "string" && latestCheckout.path.trim() ? latestCheckout.path.trim() : null;
-    if (path)
-      writeRepoServerProjectRoot(projectRoot, path);
-    return path;
-  } catch {
-    return null;
-  }
-}
 function appendTaskFilterParams(url, filters) {
   if (filters.assignee)
     url.searchParams.set("assignee", filters.assignee);
@@ -459,13 +898,20 @@ function canUseRemoteWithoutProjectRoot(pathname) {
 async function requestServerJson(context, pathname, init = {}) {
   const server = await ensureServerForCli(context.projectRoot);
   const requestUrl = new URL(`${server.baseUrl}${pathname}`);
-  if (server.connectionKind === "remote" && !server.serverProjectRoot && !canUseRemoteWithoutProjectRoot(requestUrl.pathname) && (server.authToken || !isLoopbackRemoteBaseUrl(server.baseUrl))) {
-    const repo = readRepoConnection(context.projectRoot);
-    throw new CliError(`Remote server is selected for ${repo?.project ?? "this repo"}, but this checkout has no server-host project root link.`, 1, { hint: "Run `rig init --repair` or `rig init --yes --repo owner/repo --server remote` to repair the remote project link before task/run commands." });
+  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 (server.serverProjectRoot)
-    headers.set("x-rig-project-root", server.serverProjectRoot);
+  if (scopedServerProjectRoot)
+    headers.set("x-rig-project-root", scopedServerProjectRoot);
   if (server.connectionKind === "remote" && server.authToken && queryAuthFallbackEnabled()) {
     requestUrl.searchParams.set("rt", server.authToken);
   }
@@ -830,6 +1276,486 @@ var init__server_client = __esm(() => {
   ]);
 });
 
+// packages/cli/src/commands/_spinner.ts
+function createTtySpinner(input) {
+  const output = input.output ?? process.stdout;
+  const isTty = output.isTTY === true;
+  const frames = input.frames && input.frames.length > 0 ? input.frames : SPINNER_FRAMES;
+  let label = input.label;
+  let frame = 0;
+  let paused = false;
+  let stopped = false;
+  let lastPrintedLabel = "";
+  const render = () => {
+    if (stopped || paused)
+      return;
+    if (!isTty) {
+      if (label !== lastPrintedLabel) {
+        output.write(`${label}
+`);
+        lastPrintedLabel = label;
+      }
+      return;
+    }
+    frame = (frame + 1) % frames.length;
+    const glyph = frames[frame] ?? frames[0] ?? "";
+    output.write(`\r\x1B[2K${input.styleFrame ? input.styleFrame(glyph) : glyph} ${label}`);
+  };
+  const clearLine = () => {
+    if (isTty)
+      output.write("\r\x1B[2K");
+  };
+  render();
+  const timer = isTty ? setInterval(render, input.intervalMs ?? 16) : null;
+  return {
+    setLabel(next) {
+      label = next;
+      render();
+    },
+    pause() {
+      paused = true;
+      clearLine();
+    },
+    resume() {
+      if (stopped)
+        return;
+      paused = false;
+      render();
+    },
+    stop(finalLine) {
+      if (stopped)
+        return;
+      stopped = true;
+      if (timer)
+        clearInterval(timer);
+      clearLine();
+      if (finalLine)
+        output.write(`${finalLine}
+`);
+    }
+  };
+}
+var SPINNER_FRAMES;
+var init__spinner = __esm(() => {
+  SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+});
+
+// packages/cli/src/app/theme.ts
+function hexToRgb(hex) {
+  const value = hex.replace("#", "");
+  return [
+    Number.parseInt(value.slice(0, 2), 16),
+    Number.parseInt(value.slice(2, 4), 16),
+    Number.parseInt(value.slice(4, 6), 16)
+  ];
+}
+function fg(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[39m`;
+}
+function bold(text) {
+  return `\x1B[1m${text}\x1B[22m`;
+}
+function microDroneFrame(tick) {
+  const blade = MICRO_BLADES[tick % MICRO_BLADES.length];
+  const eye = EYE_FRAMES[Math.floor(tick / 2) % EYE_FRAMES.length];
+  return `(${blade})${eye}(${blade})`;
+}
+function renderMicroDroneFrame(tick) {
+  const blade = MICRO_BLADES[tick % MICRO_BLADES.length];
+  const eye = EYE_FRAMES[Math.floor(tick / 2) % EYE_FRAMES.length];
+  return `${ink4("(")}${cyan(blade)}${ink4(")")}${bold(accent(eye))}${ink4("(")}${cyan(blade)}${ink4(")")}`;
+}
+var RIG_PALETTE, ink, ink2, ink3, ink4, accent, accentDim, cyan, red, yellow, DRONE_ART, EYE_FRAMES, DRONE_WIDTH, DRONE_HEIGHT, MICRO_BLADES, MICRO_DRONE_FRAMES;
+var init_theme = __esm(() => {
+  RIG_PALETTE = {
+    ink: "#f2f3f6",
+    ink2: "#aeb0ba",
+    ink3: "#6c6e79",
+    ink4: "#44464f",
+    accent: "#ccff4d",
+    accentDim: "#a9d63f",
+    cyan: "#56d8ff",
+    red: "#ff5d5d",
+    yellow: "#ffd24d"
+  };
+  ink = fg(RIG_PALETTE.ink);
+  ink2 = fg(RIG_PALETTE.ink2);
+  ink3 = fg(RIG_PALETTE.ink3);
+  ink4 = fg(RIG_PALETTE.ink4);
+  accent = fg(RIG_PALETTE.accent);
+  accentDim = fg(RIG_PALETTE.accentDim);
+  cyan = fg(RIG_PALETTE.cyan);
+  red = fg(RIG_PALETTE.red);
+  yellow = fg(RIG_PALETTE.yellow);
+  DRONE_ART = [
+    "  .-=-.                   .-=-.   ",
+    " ( !!! )                 ( !!! )  ",
+    "  '-=-'._               _.'-=-'   ",
+    "        '._           _.'         ",
+    "           '=$$$$$$$=.'           ",
+    "          =$$$$$$$$$$$=           ",
+    "         $$$@@@@@@@@@@$$$         ",
+    "        $$$@@        @@$$$        ",
+    "        $$@    ?     @$$$         ",
+    "        $$$@   '-'   @$$$         ",
+    "        $$$@@        @@$$$        ",
+    "         $$$@@@@@@@@@@$$$         ",
+    "          =$$$$$$$$$$$=           ",
+    "           '=$$$$$$$=.'           ",
+    "        _.'           '._         ",
+    "  .-=-.'                 '.-=-.   ",
+    " ( !!! )                 ( !!! )  ",
+    "  '-=-'                   '-=-'   "
+  ];
+  EYE_FRAMES = ["@", "o", "."];
+  DRONE_WIDTH = DRONE_ART[0].length;
+  DRONE_HEIGHT = DRONE_ART.length;
+  MICRO_BLADES = ["---", "\\\\\\", "|||", "///"];
+  MICRO_DRONE_FRAMES = Array.from({ length: 12 }, (_, index) => microDroneFrame(index));
+});
+
+// packages/cli/src/commands/_async-ui.ts
+import pc from "picocolors";
+async function withSpinner(label, work, options = {}) {
+  if (options.outputMode === "json") {
+    return work(() => {});
+  }
+  if (activeUpdate) {
+    const outer = activeUpdate;
+    outer(label);
+    return work(outer);
+  }
+  const output = options.output ?? process.stderr;
+  const isTty = output.isTTY === true;
+  let lastLabel = label;
+  if (!isTty) {
+    output.write(`${label}
+`);
+    const update2 = (next) => {
+      lastLabel = next;
+    };
+    activeUpdate = update2;
+    const previousListener2 = setServerPhaseListener(update2);
+    try {
+      return await work(update2);
+    } finally {
+      activeUpdate = null;
+      setServerPhaseListener(previousListener2);
+    }
+  }
+  const spinner = createTtySpinner({
+    label,
+    output,
+    frames: MICRO_DRONE_FRAMES,
+    styleFrame: (frame) => renderMicroDroneFrame(Math.max(0, MICRO_DRONE_FRAMES.indexOf(frame)))
+  });
+  const update = (next) => {
+    lastLabel = next;
+    spinner.setLabel(next);
+  };
+  activeUpdate = update;
+  const previousListener = setServerPhaseListener(update);
+  try {
+    const result = await work(update);
+    spinner.stop(options.doneLabel ? `${DONE_SYMBOL} ${options.doneLabel}` : undefined);
+    return result;
+  } catch (error) {
+    spinner.stop(`${FAIL_SYMBOL} ${lastLabel}`);
+    throw error;
+  } finally {
+    activeUpdate = null;
+    setServerPhaseListener(previousListener);
+  }
+}
+var DONE_SYMBOL, FAIL_SYMBOL, activeUpdate = null;
+var init__async_ui = __esm(() => {
+  init__spinner();
+  init__server_client();
+  init_theme();
+  DONE_SYMBOL = pc.green("\u25C7");
+  FAIL_SYMBOL = pc.red("\u25A0");
+});
+
+// packages/cli/src/commands/_pi-frontend.ts
+var exports__pi_frontend = {};
+__export(exports__pi_frontend, {
+  shouldRequireOperatorTranscript: () => shouldRequireOperatorTranscript,
+  runWithProcessExitGuard: () => runWithProcessExitGuard,
+  missingOperatorTranscriptMessage: () => missingOperatorTranscriptMessage,
+  buildOperatorPiEnv: () => buildOperatorPiEnv,
+  attachRunBundledPiFrontend: () => attachRunBundledPiFrontend
+});
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, mkdtempSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir2, tmpdir } from "os";
+import { join } from "path";
+import { main as runPiMain } from "@earendil-works/pi-coding-agent";
+import createPiRigExtension from "@rig/pi-rig";
+function setTemporaryEnv(updates) {
+  const previous = new Map;
+  for (const [key, value] of Object.entries(updates)) {
+    previous.set(key, process.env[key]);
+    process.env[key] = value;
+  }
+  return () => {
+    for (const [key, value] of previous) {
+      if (value === undefined)
+        delete process.env[key];
+      else
+        process.env[key] = value;
+    }
+  };
+}
+function buildOperatorPiEnv(input) {
+  return {
+    PI_CODING_AGENT_SESSION_DIR: input.sessionDir,
+    PI_SKIP_VERSION_CHECK: "1",
+    PI_HIDDEN_COMMANDS: "import,fork,clone,tree,new,resume,trust",
+    RIG_PI_OPERATOR_SESSION: "1",
+    RIG_RUN_ID: input.runId,
+    RIG_SERVER_URL: input.serverUrl,
+    ...input.authToken ? { RIG_AUTH_TOKEN: input.authToken } : {},
+    ...input.serverProjectRoot ? { RIG_PROJECT_ROOT: input.serverProjectRoot } : {}
+  };
+}
+function shouldRequireOperatorTranscript(status) {
+  return typeof status === "string" && TERMINAL_RUN_STATUSES.has(status.trim().toLowerCase());
+}
+function missingOperatorTranscriptMessage(runId, status) {
+  const shortRun = runId.trim().slice(0, 8) || "unknown";
+  const statusText = typeof status === "string" && status.trim() ? status.trim() : "terminal";
+  return `Run ${shortRun} is ${statusText}, but no worker Pi session transcript is recorded for this run. It likely failed before Pi started or predates full-session capture. Use \`rig run show ${runId}\` and \`rig run logs ${runId}\` for the lifecycle details.`;
+}
+function statusFromRunDetails(run) {
+  if (!run || typeof run !== "object" || Array.isArray(run))
+    return;
+  const record = run;
+  if (typeof record.status === "string")
+    return record.status;
+  const nested = record.run;
+  return nested && typeof nested === "object" && !Array.isArray(nested) ? nested.status : undefined;
+}
+async function prepareOperatorConsole(context, runId, tempSessionDir) {
+  const server = await ensureServerForCli(context.projectRoot);
+  const localCwd = join(homedir2(), ".rig", "drones", runId.slice(0, 8));
+  mkdirSync3(localCwd, { recursive: true });
+  trustDroneCwd(localCwd);
+  installRigPiTheme();
+  let sessionFileArg = [];
+  try {
+    const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/session-file`);
+    if (payload?.ok && typeof payload.content === "string" && payload.content.trim()) {
+      const fileName = typeof payload.fileName === "string" && payload.fileName.trim() ? payload.fileName.replace(/[^A-Za-z0-9._-]/g, "_") : `rig-run-${runId}.jsonl`;
+      const localSessionPath = join(tempSessionDir, fileName);
+      const content = payload.content.split(`
+`).map((line, index) => {
+        if (index > 0 || !line.trim())
+          return line;
+        try {
+          const header = JSON.parse(line);
+          if (header.type === "session" && typeof header.cwd === "string") {
+            return JSON.stringify({ ...header, cwd: localCwd });
+          }
+        } catch {}
+        return line;
+      }).join(`
+`);
+      writeFileSync3(localSessionPath, content);
+      sessionFileArg = ["--session", localSessionPath];
+    }
+  } catch {}
+  if (sessionFileArg.length === 0) {
+    const run = await getRunDetailsViaServer(context, runId).catch(() => null);
+    const status = statusFromRunDetails(run);
+    if (shouldRequireOperatorTranscript(status)) {
+      throw new OperatorTranscriptUnavailableError(missingOperatorTranscriptMessage(runId, status));
+    }
+  }
+  return { server, sessionFileArg };
+}
+function trustDroneCwd(localCwd) {
+  try {
+    const agentDir = join(homedir2(), ".pi", "agent");
+    mkdirSync3(agentDir, { recursive: true });
+    const trustPath = join(agentDir, "trust.json");
+    const store = existsSync3(trustPath) ? JSON.parse(readFileSync3(trustPath, "utf8")) : {};
+    if (store[localCwd] !== true) {
+      store[localCwd] = true;
+      writeFileSync3(trustPath, `${JSON.stringify(store, null, "\t")}
+`);
+    }
+  } catch {}
+}
+function installRigPiTheme() {
+  try {
+    const themesDir = join(homedir2(), ".pi", "agent", "themes");
+    mkdirSync3(themesDir, { recursive: true });
+    const themePath = join(themesDir, "rig.json");
+    const next = `${JSON.stringify(RIG_PI_THEME, null, "\t")}
+`;
+    if (!existsSync3(themePath) || readFileSync3(themePath, "utf8") !== next) {
+      writeFileSync3(themePath, next);
+    }
+  } catch {}
+}
+async function runWithProcessExitGuard(body) {
+  const realExit = process.exit;
+  let exitCode = 0;
+  let signalQuit = () => {};
+  const quit = new Promise((resolve3) => {
+    signalQuit = resolve3;
+  });
+  const guardedExit = (code) => {
+    exitCode = typeof code === "number" ? code : 0;
+    signalQuit();
+    return;
+  };
+  process.exit = guardedExit;
+  try {
+    await Promise.race([Promise.resolve().then(body), quit]);
+  } finally {
+    process.exit = realExit;
+  }
+  return exitCode;
+}
+function runPiMainReturningOnQuit(args, options) {
+  return runWithProcessExitGuard(() => runPiMain(args, options));
+}
+async function attachRunBundledPiFrontend(context, input) {
+  const tempSessionDir = mkdtempSync(join(tmpdir(), "rig-pi-frontend-sessions-"));
+  const { server, sessionFileArg } = await withSpinner(`Opening Pi console for run ${input.runId}\u2026`, () => prepareOperatorConsole(context, input.runId, tempSessionDir), { outputMode: context.outputMode });
+  const restoreEnv = setTemporaryEnv(buildOperatorPiEnv({
+    runId: input.runId,
+    serverUrl: server.baseUrl,
+    authToken: server.authToken,
+    serverProjectRoot: server.serverProjectRoot,
+    sessionDir: tempSessionDir
+  }));
+  const piRigExtensionFactory = (pi) => {
+    createPiRigExtension(pi);
+  };
+  let detached = false;
+  try {
+    const piArgs = [
+      "--offline",
+      "--no-extensions",
+      "--no-skills",
+      "--no-prompt-templates",
+      "--no-context-files",
+      ...sessionFileArg
+    ];
+    const piOptions = { extensionFactories: [piRigExtensionFactory] };
+    if (input.returnOnQuit) {
+      await runPiMainReturningOnQuit(piArgs, piOptions);
+    } else {
+      await runPiMain(piArgs, piOptions);
+    }
+    detached = true;
+  } finally {
+    restoreEnv();
+    rmSync(tempSessionDir, { recursive: true, force: true });
+  }
+  let run = { runId: input.runId, status: "unknown" };
+  try {
+    run = await getRunDetailsViaServer(context, input.runId);
+  } catch {}
+  return {
+    run,
+    logs: [],
+    timeline: [],
+    timelineCursor: null,
+    steered: input.steered === true,
+    detached,
+    rendered: "stock Pi operator console with the pi-rig extension"
+  };
+}
+var TERMINAL_RUN_STATUSES, OperatorTranscriptUnavailableError, RIG_PI_THEME;
+var init__pi_frontend = __esm(() => {
+  init__server_client();
+  init__async_ui();
+  TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
+  OperatorTranscriptUnavailableError = class OperatorTranscriptUnavailableError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "OperatorTranscriptUnavailableError";
+    }
+  };
+  RIG_PI_THEME = {
+    $schema: "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+    name: "rig",
+    vars: {
+      acid: "#ccff4d",
+      acidDim: "#a9d63f",
+      cyan: "#56d8ff",
+      red: "#ff5d5d",
+      yellow: "#ffd24d",
+      ink: "#f2f3f6",
+      ink2: "#aeb0ba",
+      ink3: "#6c6e79",
+      ink4: "#44464f",
+      panel: "#101115",
+      panelUser: "#14161b",
+      toolPending: "#0e1013",
+      toolSuccess: "#10150c",
+      toolError: "#1a0f0f",
+      customMsg: "#0f1410"
+    },
+    colors: {
+      accent: "acid",
+      border: "ink4",
+      borderAccent: "acid",
+      borderMuted: "ink4",
+      success: "acid",
+      error: "red",
+      warning: "yellow",
+      muted: "ink3",
+      dim: "ink4",
+      text: "ink",
+      thinkingText: "ink3",
+      selectedBg: "panel",
+      userMessageBg: "panelUser",
+      userMessageText: "ink",
+      customMessageBg: "customMsg",
+      customMessageText: "ink2",
+      customMessageLabel: "acidDim",
+      toolPendingBg: "toolPending",
+      toolSuccessBg: "toolSuccess",
+      toolErrorBg: "toolError",
+      toolTitle: "ink",
+      toolOutput: "ink3",
+      mdHeading: "acid",
+      mdLink: "cyan",
+      mdLinkUrl: "ink4",
+      mdCode: "acidDim",
+      mdCodeBlock: "ink2",
+      mdCodeBlockBorder: "ink4",
+      mdQuote: "ink3",
+      mdQuoteBorder: "ink4",
+      mdHr: "ink4",
+      mdListBullet: "acid",
+      toolDiffAdded: "acid",
+      toolDiffRemoved: "red",
+      toolDiffContext: "ink3",
+      syntaxComment: "ink3",
+      syntaxKeyword: "cyan",
+      syntaxFunction: "acid",
+      syntaxVariable: "ink",
+      syntaxString: "acidDim",
+      syntaxNumber: "yellow",
+      syntaxType: "cyan",
+      syntaxOperator: "ink2",
+      syntaxPunctuation: "ink3",
+      thinkingOff: "ink4",
+      thinkingMinimal: "ink3",
+      thinkingLow: "ink2",
+      thinkingMedium: "cyan",
+      thinkingHigh: "acidDim",
+      thinkingXhigh: "acid",
+      bashMode: "cyan"
+    }
+  };
+});
+
 // packages/cli/src/app-opentui/adapters/inspect.ts
 var exports_inspect = {};
 __export(exports_inspect, {
@@ -838,7 +1764,7 @@ __export(exports_inspect, {
   INSPECT_VIEWS: () => INSPECT_VIEWS
 });
 import { execFile } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync, statSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync, statSync } from "fs";
 import { resolve as resolve3 } from "path";
 import { promisify } from "util";
 import { resolveTaskArtifactDirs } from "@rig/runtime/control-plane/authority-files";
@@ -860,7 +1786,7 @@ function listArtifacts(projectRoot, taskId) {
   if (!taskId)
     return { artifacts: [], error: "run has no task id \u2014 artifacts are resolved per task" };
   try {
-    const dirs = resolveTaskArtifactDirs(projectRoot, taskId).filter((dir) => existsSync3(dir));
+    const dirs = resolveTaskArtifactDirs(projectRoot, taskId).filter((dir) => existsSync4(dir));
     const out = [];
     const seen = new Set;
     for (const dir of dirs) {
@@ -906,9 +1832,9 @@ function loadGraph(projectRoot) {
 function loadAudit(projectRoot) {
   try {
     const auditPath = resolve3(resolveHarnessPaths(projectRoot).logsDir, "audit.jsonl");
-    if (!existsSync3(auditPath))
+    if (!existsSync4(auditPath))
       return [];
-    return readFileSync3(auditPath, "utf-8").split(/\r?\n/).filter(Boolean).slice(-50).flatMap((raw) => {
+    return readFileSync4(auditPath, "utf-8").split(/\r?\n/).filter(Boolean).slice(-50).flatMap((raw) => {
       try {
         const parsed = JSON.parse(raw);
         return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? [parsed] : [{ detail: raw }];
@@ -1027,396 +1953,6 @@ var init_inspect = __esm(() => {
     "audit"
   ];
 });
-// packages/cli/src/app-opentui/pi-pty-host.ts
-import { fileURLToPath } from "url";
-import { basename } from "path";
-import { RGBA, StyledText, TextAttributes } from "@opentui/core";
-import { Terminal as XtermTerminal } from "@xterm/headless";
-var MIN_COLS = 40;
-var MIN_ROWS = 12;
-var MAX_ROWS = 300;
-var MAX_SNAPSHOT_LINES = 360;
-var STYLED_SNAPSHOT_MARGIN = 6;
-var SNAPSHOT_DELAY_MS = 120;
-var fallbackChildScriptPath = fileURLToPath(new URL("./pi-host-child.ts", import.meta.url));
-var activeHost = null;
-function clampCols(cols) {
-  return Math.max(MIN_COLS, Math.trunc(cols || 100));
-}
-function clampRows(rows) {
-  return Math.max(MIN_ROWS, Math.min(MAX_ROWS, Math.trunc(rows || 35)));
-}
-var XTERM_COLOR_MODE_INDEXED_16 = 16777216;
-var XTERM_COLOR_MODE_INDEXED_256 = 33554432;
-var XTERM_COLOR_MODE_RGB = 50331648;
-function rgbaFromXtermColor(mode, value) {
-  if (mode === 1 || mode === 2 || mode === XTERM_COLOR_MODE_INDEXED_16 || mode === XTERM_COLOR_MODE_INDEXED_256) {
-    return RGBA.fromIndex(value);
-  }
-  if (mode === 3 || mode === XTERM_COLOR_MODE_RGB) {
-    return RGBA.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255);
-  }
-  return;
-}
-function textAttributesFromCell(cell) {
-  let attributes = TextAttributes.NONE;
-  if (cell.isBold())
-    attributes |= TextAttributes.BOLD;
-  if (cell.isDim())
-    attributes |= TextAttributes.DIM;
-  if (cell.isItalic())
-    attributes |= TextAttributes.ITALIC;
-  if (cell.isUnderline())
-    attributes |= TextAttributes.UNDERLINE;
-  if (cell.isBlink())
-    attributes |= TextAttributes.BLINK;
-  if (cell.isInverse())
-    attributes |= TextAttributes.INVERSE;
-  if (cell.isInvisible())
-    attributes |= TextAttributes.HIDDEN;
-  if (cell.isStrikethrough())
-    attributes |= TextAttributes.STRIKETHROUGH;
-  return attributes;
-}
-function sameRgba(a, b) {
-  if (!a && !b)
-    return true;
-  return Boolean(a && b && a.equals(b));
-}
-function sameStyle(a, b) {
-  return sameRgba(a.fg, b.fg) && sameRgba(a.bg, b.bg) && (a.attributes ?? 0) === (b.attributes ?? 0);
-}
-function styleFromCell(cell) {
-  return {
-    fg: rgbaFromXtermColor(cell.getFgColorMode(), cell.getFgColor()),
-    bg: rgbaFromXtermColor(cell.getBgColorMode(), cell.getBgColor()),
-    attributes: textAttributesFromCell(cell)
-  };
-}
-function lineToStyledText(line, cols) {
-  if (!line)
-    return new StyledText([{ __isChunk: true, text: "" }]);
-  const chunks = [];
-  let run = "";
-  let runStyle = null;
-  const flush = () => {
-    if (!run)
-      return;
-    chunks.push({
-      __isChunk: true,
-      text: run,
-      ...runStyle?.fg ? { fg: runStyle.fg } : {},
-      ...runStyle?.bg ? { bg: runStyle.bg } : {},
-      ...(runStyle?.attributes ?? 0) !== 0 ? { attributes: runStyle.attributes } : {}
-    });
-    run = "";
-  };
-  for (let index = 0;index < cols; index += 1) {
-    const cell = line.getCell(index);
-    if (!cell) {
-      if (runStyle !== null)
-        flush();
-      runStyle = null;
-      run += " ";
-      continue;
-    }
-    if (cell.getWidth() === 0)
-      continue;
-    const style = styleFromCell(cell);
-    if (!runStyle || !sameStyle(runStyle, style)) {
-      flush();
-      runStyle = style;
-    }
-    run += cell.getChars() || " ";
-  }
-  flush();
-  return new StyledText(chunks.length > 0 ? chunks : [{ __isChunk: true, text: "" }]);
-}
-function childCommandPrefix() {
-  const execName = basename(process.execPath).toLowerCase();
-  const currentEntry = process.argv[1];
-  if (execName === "bun" || execName === "bun.exe") {
-    return currentEntry ? [process.execPath, currentEntry, "__opentui-pi-host"] : [process.execPath, fallbackChildScriptPath];
-  }
-  return [process.execPath, "__opentui-pi-host"];
-}
-function withEnv(base) {
-  const env = {};
-  for (const [key, value] of Object.entries(base ?? process.env)) {
-    if (key === "RIG_PLAIN" || key === "RIG_CLI_PLAIN_HELP" || key === "NO_COLOR")
-      continue;
-    if (typeof value === "string")
-      env[key] = value;
-  }
-  return {
-    ...env,
-    TERM: "xterm-256color",
-    COLORTERM: "truecolor",
-    FORCE_COLOR: env.FORCE_COLOR ?? "1",
-    RIG_OPENTUI_PI_HOST: "1"
-  };
-}
-async function startPiPtyHost(options) {
-  activeHost?.dispose("replace");
-  const host = new PiPtyHost(options);
-  activeHost = host;
-  await host.start();
-  return host;
-}
-class PiPtyHost {
-  runId;
-  projectRoot;
-  onSnapshot;
-  onExit;
-  onError;
-  terminal;
-  disposables = [];
-  decoder = new TextDecoder("utf-8");
-  proc = null;
-  pty = null;
-  status = "starting";
-  cols;
-  rows;
-  message = "starting bundled Pi";
-  lastResizeError = null;
-  exitCode;
-  signal;
-  notifyTimer = null;
-  lastStreamKey = "";
-  _disposed = false;
-  constructor(options) {
-    this.runId = options.runId;
-    this.projectRoot = options.projectRoot;
-    this.cols = clampCols(options.cols);
-    this.rows = clampRows(options.rows);
-    this.onSnapshot = options.onSnapshot;
-    this.onExit = options.onExit;
-    this.onError = options.onError;
-    this.terminal = new XtermTerminal({
-      allowProposedApi: true,
-      cols: this.cols,
-      rows: this.rows,
-      scrollback: 1000
-    });
-    this.registerTerminalResponders();
-    this.disposables.push(this.terminal.onWriteParsed(() => {
-      if (this._disposed)
-        return;
-      const snapshot = this.createSnapshot();
-      const key = snapshot.lines.join(`
-`);
-      if (key === this.lastStreamKey)
-        return;
-      this.lastStreamKey = key;
-      this.onSnapshot?.(snapshot);
-    }));
-  }
-  get disposed() {
-    return this._disposed;
-  }
-  get snapshot() {
-    return this.createSnapshot();
-  }
-  async start() {
-    if (this._disposed)
-      throw new Error("Pi PTY host is disposed.");
-    if (typeof Bun.Terminal !== "function") {
-      throw new Error("Bun native PTY is unavailable in this runtime. Pi host requires Bun.Terminal.");
-    }
-    const spawnOptions = {
-      cwd: this.projectRoot,
-      env: withEnv(process.env),
-      terminal: {
-        cols: this.cols,
-        rows: this.rows,
-        name: "xterm-256color",
-        data: (_terminal, data) => this.handlePtyData(data)
-      }
-    };
-    const proc = Bun.spawn([
-      ...childCommandPrefix(),
-      "--run-id",
-      this.runId,
-      "--project-root",
-      this.projectRoot
-    ], spawnOptions);
-    if (!proc.terminal)
-      throw new Error("Bun did not attach a terminal to the bundled Pi child process.");
-    this.proc = proc;
-    this.pty = proc.terminal;
-    this.status = "running";
-    this.message = "bundled Pi running inside this app";
-    this.emitSnapshotSoon(0);
-    proc.exited.then((exitCode) => {
-      if (this._disposed)
-        return;
-      this.status = exitCode === 0 ? "exited" : "failed";
-      this.exitCode = exitCode;
-      this.signal = null;
-      this.message = exitCode === 0 ? "bundled Pi exited" : `bundled Pi exited with code ${exitCode}`;
-      const snapshot = this.createSnapshot();
-      this.onSnapshot?.(snapshot);
-      this.onExit?.(snapshot);
-      if (activeHost === this)
-        activeHost = null;
-      this.dispose("exit", { kill: false, notify: false });
-    }).catch((error) => {
-      if (this._disposed)
-        return;
-      this.status = "failed";
-      this.message = error instanceof Error ? error.message : String(error);
-      const snapshot = this.createSnapshot();
-      this.onSnapshot?.(snapshot);
-      this.onError?.(error, snapshot);
-      if (activeHost === this)
-        activeHost = null;
-      this.dispose("error", { kill: false, notify: false });
-    });
-  }
-  write(data) {
-    if (this._disposed || !this.pty)
-      return;
-    try {
-      this.pty.write(data);
-    } catch (error) {
-      this.status = "failed";
-      this.message = error instanceof Error ? error.message : String(error);
-      const snapshot = this.createSnapshot();
-      this.onSnapshot?.(snapshot);
-      this.onError?.(error, snapshot);
-    }
-  }
-  resize(cols, rows) {
-    const nextCols = clampCols(cols);
-    const nextRows = clampRows(rows);
-    if (nextCols === this.cols && nextRows === this.rows)
-      return;
-    this.cols = nextCols;
-    this.rows = nextRows;
-    this.terminal.resize(nextCols, nextRows);
-    try {
-      this.pty?.resize(nextCols, nextRows);
-      this.lastResizeError = null;
-    } catch (error) {
-      this.lastResizeError = error instanceof Error ? error.message : String(error);
-    }
-    this.emitSnapshotSoon(0);
-  }
-  detach() {
-    this.dispose("detach");
-    return this.createSnapshot("detached from bundled Pi");
-  }
-  dispose(reason = "dispose", options = {}) {
-    if (this._disposed)
-      return;
-    this._disposed = true;
-    if (this.notifyTimer)
-      clearTimeout(this.notifyTimer);
-    this.notifyTimer = null;
-    for (const disposable of this.disposables.splice(0)) {
-      try {
-        disposable.dispose();
-      } catch {}
-    }
-    if (options.kill !== false) {
-      try {
-        this.proc?.kill("SIGTERM");
-      } catch {}
-    }
-    try {
-      this.pty?.close();
-    } catch {}
-    try {
-      this.terminal.dispose();
-    } catch {}
-    if (activeHost === this)
-      activeHost = null;
-    if (options.notify) {
-      this.message = reason;
-      this.onSnapshot?.(this.createSnapshot(reason));
-    }
-  }
-  handlePtyData(data) {
-    if (this._disposed)
-      return;
-    const text = this.decoder.decode(data, { stream: true });
-    this.respondToRawTerminalQueries(text);
-    this.terminal.write(data);
-  }
-  emitSnapshotSoon(delayMs = SNAPSHOT_DELAY_MS) {
-    if (this._disposed || this.notifyTimer)
-      return;
-    this.notifyTimer = setTimeout(() => {
-      this.notifyTimer = null;
-      if (this._disposed)
-        return;
-      this.onSnapshot?.(this.createSnapshot());
-    }, delayMs);
-  }
-  createSnapshot(message = this.message) {
-    const buffer = this.terminal.buffer.active;
-    const end = buffer.length;
-    const start = Math.max(0, end - MAX_SNAPSHOT_LINES);
-    const styledStart = Math.max(start, end - this.rows - STYLED_SNAPSHOT_MARGIN);
-    const lines = [];
-    const styledLines = [];
-    for (let row = start;row < end; row += 1) {
-      const line = buffer.getLine(row);
-      lines.push((line?.translateToString(false) ?? "").slice(0, this.cols));
-      if (row >= styledStart)
-        styledLines[lines.length - 1] = lineToStyledText(line, this.cols);
-    }
-    while (lines.length < this.rows) {
-      lines.push("");
-      styledLines[lines.length - 1] = new StyledText([{ __isChunk: true, text: "" }]);
-    }
-    const resolvedMessage = this.lastResizeError ? `resize degraded: ${this.lastResizeError}` : message;
-    return {
-      runId: this.runId,
-      status: this.status,
-      cols: this.cols,
-      rows: this.rows,
-      lines,
-      styledLines,
-      message: resolvedMessage,
-      ...this.lastResizeError ? { resizeError: this.lastResizeError } : {},
-      ...this.exitCode !== undefined ? { exitCode: this.exitCode } : {},
-      ...this.signal !== undefined ? { signal: this.signal } : {}
-    };
-  }
-  registerTerminalResponders() {
-    this.disposables.push(this.terminal.parser.registerCsiHandler({ final: "c" }, (params) => {
-      if (params.length === 0 || params[0] === 0)
-        this.write("\x1B[?62;22c");
-      return false;
-    }));
-    this.disposables.push(this.terminal.parser.registerCsiHandler({ prefix: ">", final: "c" }, (params) => {
-      if (params.length === 0 || params[0] === 0)
-        this.write("\x1B[>0;0;0c");
-      return false;
-    }));
-    this.disposables.push(this.terminal.parser.registerCsiHandler({ final: "n" }, (params) => {
-      if (params[0] === 5) {
-        this.write("\x1B[0n");
-      } else if (params[0] === 6) {
-        const row = this.terminal.buffer.active.cursorY + 1;
-        const col = this.terminal.buffer.active.cursorX + 1;
-        this.write(`\x1B[${row};${col}R`);
-      }
-      return false;
-    }));
-  }
-  respondToRawTerminalQueries(text) {
-    if (!text)
-      return;
-    const decrqm = /\x1b\[\?(\d+)\$p/g;
-    let match;
-    while ((match = decrqm.exec(text)) !== null) {
-      this.write(`\x1B[?${match[1]};2$y`);
-    }
-  }
-}
-
 // packages/cli/src/app-opentui/adapters/fleet.ts
 function normalizeRunRecord(record) {
   const runId = stringField(record, ["runId", "id"]);
@@ -1478,14 +2014,6 @@ function recordStep(ctx, runId, label, emitLabel) {
   });
   emitProgress(ctx, emitLabel, label);
 }
-function settleSteps(ctx, runId) {
-  const now = Date.now();
-  const previous = currentAttachState(ctx, runId);
-  if (!previous?.steps)
-    return;
-  const steps = previous.steps.map((step) => step.status === "running" ? { ...step, status: "done", endedAtMs: step.endedAtMs ?? now } : step);
-  patchData(ctx, { piAttach: { ...previous, steps } });
-}
 async function preparePiAttachHandoff(ctx, runId) {
   const cleanRunId = runId.trim();
   const label = `Preparing Pi ${cleanRunId.slice(0, 8)}`;
@@ -1533,82 +2061,39 @@ async function attachRunWithBundledPi(ctx, runId) {
     throw error;
   }
   emitStarted(ctx, label, { piAttach: { runId: cleanRunId, status: "entering-pi" } });
-  patchData(ctx, { piAttach: { runId: cleanRunId, status: "entering-pi", message: "starting bundled Pi", steps: [] } });
+  patchData(ctx, { piAttach: { runId: cleanRunId, status: "entering-pi", message: "handing the terminal to worker Pi\u2026" } });
+  const projectRoot = projectRootOf(ctx);
+  const outputMode = ctx.rig?.outputMode ?? "text";
+  await releaseRendererForExternalTui(ctx);
+  let outcome = null;
+  let attachError = null;
   try {
-    recordStep(ctx, cleanRunId, "connecting to server and fetching run transcript", label);
-    await preparePiAttachHandoff(ctx, cleanRunId).catch((error) => {
-      patchData(ctx, { lastRefreshError: normalizeAppError(error).message });
-      return null;
-    });
-    recordStep(ctx, cleanRunId, "spawning Bun PTY host for bundled Pi", label);
-    const projectRoot = projectRootOf(ctx);
-    const cols = typeof process.stdout.columns === "number" ? process.stdout.columns : 100;
-    const rows = Math.max(1, (typeof process.stdout.rows === "number" ? process.stdout.rows : 35) - 1);
-    const patchTerminal = (snapshot) => {
-      const previousSteps = currentAttachState(ctx, cleanRunId)?.steps;
-      const failed = snapshot.status === "failed";
-      const reason = failed ? snapshot.message ?? `bundled Pi exited with code ${snapshot.exitCode ?? "unknown"}` : undefined;
-      patchData(ctx, {
-        piTerminal: snapshot,
-        piAttach: {
-          runId: cleanRunId,
-          status: failed ? "failed" : snapshot.status === "exited" ? "returned" : "entering-pi",
-          message: snapshot.message ?? "bundled Pi running",
-          result: { runId: cleanRunId, status: snapshot.status, exitCode: snapshot.exitCode },
-          ...previousSteps ? { steps: previousSteps } : {},
-          ...reason ? { failureReason: reason } : {}
-        }
-      });
-    };
-    recordStep(ctx, cleanRunId, "starting bundled Pi", label);
-    await startPiPtyHost({
-      runId: cleanRunId,
-      projectRoot,
-      cols,
-      rows,
-      onSnapshot: (snapshot) => {
-        if (snapshot.status === "running" && snapshot.lines.some((entry) => entry.trim().length > 0)) {
-          settleSteps(ctx, cleanRunId);
-        }
-        patchTerminal(snapshot);
-      },
-      onExit: (snapshot) => {
-        patchTerminal(snapshot);
-        if (snapshot.status === "failed") {
-          Promise.resolve().then(() => (init_inspect(), exports_inspect)).then(({ loadInspect: loadInspect2 }) => loadInspect2(ctx, cleanRunId)).catch(() => null);
-          emitFailed(ctx, label, new Error(snapshot.message ?? `bundled Pi exited with code ${snapshot.exitCode ?? "unknown"}`), { runId: cleanRunId, result: { status: snapshot.status, exitCode: snapshot.exitCode } });
-          return;
-        }
-        emitCompleted(ctx, label, { runId: cleanRunId, result: { status: snapshot.status, exitCode: snapshot.exitCode } });
-        ctx.emit({ type: "scene.change", scene: "fleet", intent: { scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } } });
-        refreshFleet(ctx).catch((error) => emitFailed(ctx, "Refresh runs", error));
-      },
-      onError: (error, snapshot) => {
-        patchTerminal(snapshot);
-        emitFailed(ctx, label, error, { runId: cleanRunId });
-      }
-    });
-    const record = {
-      runId: cleanRunId,
-      status: "running",
-      rendered: "bundled Pi embedded via Bun.Terminal + @xterm/headless"
-    };
-    emitProgress(ctx, label, "bundled Pi is running", { piAttach: { runId: cleanRunId, status: "entering-pi", message: "bundled Pi running", result: record } });
-    return record;
+    const { attachRunBundledPiFrontend: attachRunBundledPiFrontend2 } = await Promise.resolve().then(() => (init__pi_frontend(), exports__pi_frontend));
+    outcome = await attachRunBundledPiFrontend2({ projectRoot, outputMode }, { runId: cleanRunId, returnOnQuit: true });
   } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
+    attachError = error;
+  } finally {
+    await resumeRendererAfterExternalTui(ctx);
+  }
+  if (attachError) {
+    const reason = normalizeAppError(attachError).message;
     patchData(ctx, {
-      piAttach: {
-        runId: cleanRunId,
-        status: "failed",
-        message: reason,
-        failureReason: reason,
-        ...currentAttachState(ctx, cleanRunId)?.steps ? { steps: currentAttachState(ctx, cleanRunId).steps } : {}
-      }
+      piTerminal: undefined,
+      piAttach: { runId: cleanRunId, status: "failed", message: reason, failureReason: reason }
     });
-    emitFailed(ctx, label, error, { runId: cleanRunId });
-    throw error;
+    Promise.resolve().then(() => (init_inspect(), exports_inspect)).then(({ loadInspect: loadInspect2 }) => loadInspect2(ctx, cleanRunId)).catch(() => null);
+    emitFailed(ctx, label, attachError, { runId: cleanRunId });
+    throw attachError;
   }
+  const detached = outcome?.detached === true;
+  patchData(ctx, {
+    piTerminal: undefined,
+    piAttach: { runId: cleanRunId, status: "returned", message: detached ? "detached from worker Pi" : "returned from worker Pi" }
+  });
+  emitCompleted(ctx, label, { runId: cleanRunId, result: { runId: cleanRunId, detached } });
+  ctx.emit({ type: "scene.change", scene: "fleet", intent: { scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } } });
+  refreshFleet(ctx).catch((error) => emitFailed(ctx, "Refresh runs", error));
+  return { runId: cleanRunId, status: "returned", detached };
 }
 export {
   preparePiAttachHandoff,