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

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

@@ -1,2818 +0,0 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// packages/cli/src/runner.ts
-import { EventBus } from "@rig/runtime/control-plane/runtime/events";
-import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
-import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
-import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
-function takeFlag(args, flag) {
-  const rest = [];
-  let value = false;
-  for (const arg of args) {
-    if (arg === flag) {
-      value = true;
-      continue;
-    }
-    rest.push(arg);
-  }
-  return { value, rest };
-}
-function takeOption(args, option) {
-  const rest = [];
-  let value;
-  for (let index = 0;index < args.length; index += 1) {
-    const current = args[index];
-    if (current === option) {
-      const next = args[index + 1];
-      if (!next || next.startsWith("-")) {
-        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
-      }
-      value = next;
-      index += 1;
-      continue;
-    }
-    if (current !== undefined) {
-      rest.push(current);
-    }
-  }
-  return { value, rest };
-}
-var CliError;
-var init_runner = __esm(() => {
-  CliError = class CliError extends RuntimeCliError {
-    hint;
-    constructor(message, exitCode = 1, options = {}) {
-      super(message, exitCode);
-      if (options.hint?.trim()) {
-        this.hint = options.hint.trim();
-      }
-    }
-  };
-});
-
-// packages/cli/src/commands/_connection-state.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, resolve } from "path";
-function resolveGlobalConnectionsPath(env = process.env) {
-  const explicit = env.RIG_CONNECTIONS_FILE?.trim();
-  if (explicit)
-    return resolve(explicit);
-  const stateDir = env.RIG_GLOBAL_STATE_DIR?.trim();
-  if (stateDir)
-    return resolve(stateDir, "connections.json");
-  return resolve(homedir(), ".rig", "connections.json");
-}
-function resolveRepoConnectionPath(projectRoot) {
-  return resolve(projectRoot, ".rig", "state", "connection.json");
-}
-function readJsonFile(path) {
-  if (!existsSync(path))
-    return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch (error) {
-    throw new CliError(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1, { hint: "Fix or delete that file, then re-select a server with `rig server use <alias|local>`." });
-  }
-}
-function writeJsonFile(path, value) {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-function normalizeConnection(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const record = value;
-  if (record.kind === "local")
-    return { kind: "local", mode: "auto" };
-  if (record.kind === "remote" && typeof record.baseUrl === "string" && record.baseUrl.trim()) {
-    const baseUrl = record.baseUrl.trim().replace(/\/+$/, "");
-    return { kind: "remote", baseUrl };
-  }
-  return null;
-}
-function readGlobalConnections(options = {}) {
-  const path = resolveGlobalConnectionsPath(options.env ?? process.env);
-  const payload = readJsonFile(path);
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    return { connections: {} };
-  }
-  const rawConnections = payload.connections;
-  const connections = {};
-  if (rawConnections && typeof rawConnections === "object" && !Array.isArray(rawConnections)) {
-    for (const [alias, raw] of Object.entries(rawConnections)) {
-      const connection = normalizeConnection(raw);
-      if (connection)
-        connections[alias] = connection;
-    }
-  }
-  return { connections };
-}
-function writeGlobalConnections(state, options = {}) {
-  writeJsonFile(resolveGlobalConnectionsPath(options.env ?? process.env), state);
-}
-function upsertGlobalConnection(alias, connection, options = {}) {
-  const cleanAlias = alias.trim();
-  if (!cleanAlias)
-    throw new CliError("Connection alias is required.", 1, { hint: "Save a server with `rig server add <alias> <url>`." });
-  const state = readGlobalConnections(options);
-  state.connections[cleanAlias] = connection;
-  writeGlobalConnections(state, options);
-  return state;
-}
-function readRepoConnection(projectRoot) {
-  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const record = payload;
-  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
-  if (!selected)
-    return null;
-  return {
-    selected,
-    project: typeof record.project === "string" ? record.project : undefined,
-    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
-    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined,
-    serverProjectRootAlias: typeof record.serverProjectRootAlias === "string" && record.serverProjectRootAlias.trim() ? record.serverProjectRootAlias.trim() : undefined,
-    serverProjectRootBaseUrl: typeof record.serverProjectRootBaseUrl === "string" && record.serverProjectRootBaseUrl.trim() ? record.serverProjectRootBaseUrl.trim().replace(/\/+$/, "") : undefined
-  };
-}
-function writeRepoConnection(projectRoot, state) {
-  writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
-}
-function rootAllowedForSelection(repo, connection) {
-  const root = repo.serverProjectRoot?.trim();
-  if (!root)
-    return;
-  if (connection.kind === "remote") {
-    if (repo.serverProjectRootAlias !== repo.selected)
-      return;
-    if (repo.serverProjectRootBaseUrl !== connection.baseUrl)
-      return;
-  } else if (repo.serverProjectRootAlias && repo.serverProjectRootAlias !== repo.selected) {
-    return;
-  }
-  return root;
-}
-function resolveSelectedConnection(projectRoot, options = {}) {
-  const repo = readRepoConnection(projectRoot);
-  if (!repo)
-    return null;
-  if (repo.selected === "local")
-    return { alias: "local", connection: { kind: "local", mode: "auto" }, serverProjectRoot: repo.serverProjectRoot };
-  const global = readGlobalConnections(options);
-  const connection = global.connections[repo.selected];
-  if (!connection) {
-    throw new CliError(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
-  }
-  return { alias: repo.selected, connection, serverProjectRoot: rootAllowedForSelection(repo, connection) };
-}
-function writeRepoServerProjectRoot(projectRoot, serverProjectRoot, metadata = {}) {
-  const repo = readRepoConnection(projectRoot);
-  if (!repo)
-    return;
-  let inferred = metadata;
-  if (!inferred.alias || !inferred.baseUrl) {
-    try {
-      const selected = resolveSelectedConnection(projectRoot);
-      if (selected?.connection.kind === "remote") {
-        inferred = {
-          alias: inferred.alias ?? selected.alias,
-          baseUrl: inferred.baseUrl ?? selected.connection.baseUrl
-        };
-      }
-    } catch {}
-  }
-  writeRepoConnection(projectRoot, {
-    ...repo,
-    ...metadata.project ? { project: metadata.project } : {},
-    serverProjectRoot,
-    ...inferred.alias ? { serverProjectRootAlias: inferred.alias } : {},
-    ...inferred.baseUrl ? { serverProjectRootBaseUrl: inferred.baseUrl.replace(/\/+$/, "") } : {}
-  });
-}
-function clearRepoServerProjectRoot(projectRoot) {
-  const repo = readRepoConnection(projectRoot);
-  if (!repo)
-    return;
-  writeRepoConnection(projectRoot, {
-    selected: repo.selected,
-    ...repo.project ? { project: repo.project } : {},
-    ...repo.linkedAt ? { linkedAt: repo.linkedAt } : {}
-  });
-}
-var init__connection_state = __esm(() => {
-  init_runner();
-});
-
-// packages/cli/src/commands/_server-client.ts
-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 reportServerPhase(label) {
-  serverPhaseListener?.(label);
-}
-function cleanToken(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : null;
-}
-function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
-  const scopedKey = resolve2(projectRoot ?? process.cwd());
-  scopedGitHubBearerTokens.set(scopedKey, cleanToken(token ?? undefined));
-}
-function readRemoteAuthState(projectRoot) {
-  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
-  if (!existsSync2(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function readPrivateRemoteSessionToken(projectRoot) {
-  const parsed = readRemoteAuthState(projectRoot);
-  return parsed ? cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined) : null;
-}
-function readGitHubBearerTokenForRemote(projectRoot) {
-  const scopedKey = resolve2(projectRoot);
-  if (scopedGitHubBearerTokens.has(scopedKey))
-    return scopedGitHubBearerTokens.get(scopedKey) ?? null;
-  const privateSession = readPrivateRemoteSessionToken(projectRoot);
-  if (privateSession)
-    return privateSession;
-  return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
-}
-function readStoredGitHubAuthToken(projectRoot) {
-  const parsed = readRemoteAuthState(projectRoot);
-  return parsed ? cleanToken(typeof parsed.token === "string" ? parsed.token : undefined) : null;
-}
-function inferRemoteServerProjectRootCandidateFromAuthState(projectRoot, repoSlug) {
-  if (!/^[^/]+\/[^/]+$/.test(repoSlug))
-    return null;
-  const repo = readRepoConnection(projectRoot);
-  const auth = readRemoteAuthState(projectRoot);
-  const authUpdatedAt = typeof auth?.updatedAt === "string" ? Date.parse(auth.updatedAt) : Number.NaN;
-  const repoLinkedAt = typeof repo?.linkedAt === "string" ? Date.parse(repo.linkedAt) : Number.NaN;
-  if (Number.isFinite(authUpdatedAt) && Number.isFinite(repoLinkedAt) && authUpdatedAt + 1000 < repoLinkedAt)
-    return null;
-  const checkoutBaseDir = typeof auth?.checkoutBaseDir === "string" && auth.checkoutBaseDir.trim() ? auth.checkoutBaseDir.trim() : null;
-  if (!checkoutBaseDir)
-    return null;
-  return `${checkoutBaseDir.replace(/\/+$/, "")}/${repoSlug}`;
-}
-function readLocalConnectionFallbackToken(projectRoot) {
-  return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
-}
-function normalizeRepoSlug(value) {
-  const slug = value?.trim();
-  return slug && /^[^/\s]+\/[^/\s]+$/.test(slug) ? slug : null;
-}
-function readProjectLinkSlug(projectRoot) {
-  const path = resolve2(projectRoot, ".rig", "state", "project-link.json");
-  if (!existsSync2(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-      return null;
-    return normalizeRepoSlug(typeof parsed.repoSlug === "string" ? String(parsed.repoSlug) : null);
-  } catch {
-    return null;
-  }
-}
-function writeProjectLinkConnection(projectRoot, repoSlug, alias) {
-  const path = resolve2(projectRoot, ".rig", "state", "project-link.json");
-  mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync2(path, `${JSON.stringify({ repoSlug, connection: alias, linkedAt: new Date().toISOString() }, null, 2)}
-`, "utf8");
-}
-function remoteLinkRepairCommand(repoSlug) {
-  return repoSlug ? `rig server repair-link --repo ${repoSlug}` : "rig server repair-link --repo owner/repo";
-}
-function 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 ensureServerForCli(projectRoot) {
-  try {
-    const selected = resolveSelectedConnection(projectRoot);
-    if (selected?.connection.kind === "remote") {
-      reportServerPhase(`Connecting to ${selected.alias}\u2026`);
-      const authToken = readGitHubBearerTokenForRemote(projectRoot);
-      const link = await ensureRemoteProjectRootLink(projectRoot, { mode: "backfill-only", authToken });
-      return {
-        baseUrl: selected.connection.baseUrl,
-        authToken,
-        connectionKind: "remote",
-        serverProjectRoot: link.ok ? link.serverProjectRoot ?? null : null
-      };
-    }
-    reportServerPhase("Starting local Rig server\u2026");
-    const connection = await ensureLocalRigServerConnection(projectRoot);
-    return {
-      baseUrl: connection.baseUrl,
-      authToken: connection.authToken ?? readLocalConnectionFallbackToken(projectRoot),
-      connectionKind: "local",
-      serverProjectRoot: resolve2(projectRoot)
-    };
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new CliError(error.message, 1);
-    }
-    throw error;
-  }
-}
-function mergeCookie(existing, name, value) {
-  const encoded = `${name}=${encodeURIComponent(value)}`;
-  if (!existing?.trim())
-    return encoded;
-  const parts = existing.split(";").map((part) => part.trim()).filter((part) => part && !part.startsWith(`${name}=`));
-  return [...parts, encoded].join("; ");
-}
-function queryAuthFallbackEnabled(env = process.env) {
-  return env.RIG_ENABLE_QUERY_AUTH_FALLBACK === "1" || env.RIG_QUERY_AUTH_FALLBACK === "1";
-}
-function mergeHeaders(headers, authToken) {
-  const merged = new Headers(headers);
-  if (authToken) {
-    const bearer = `Bearer ${authToken}`;
-    merged.set("authorization", bearer);
-    merged.set("x-auth", bearer);
-    merged.set("cookie", mergeCookie(merged.get("cookie"), "rig_auth", authToken));
-  }
-  return merged;
-}
-function diagnosticMessage(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const record = payload;
-  const diagnostics = Array.isArray(record.diagnostics) ? record.diagnostics : [];
-  const messages = diagnostics.flatMap((entry) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry))
-      return [];
-    const diagnostic = entry;
-    const kind = typeof diagnostic.kind === "string" ? diagnostic.kind : "task-source";
-    const message = typeof diagnostic.message === "string" ? diagnostic.message : null;
-    return message ? [`${kind}: ${message}`] : [];
-  });
-  return messages.length > 0 ? messages.join("; ") : null;
-}
-async function probeServerReachability(baseUrl, authToken) {
-  try {
-    const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/api/server/status`, {
-      headers: mergeHeaders(undefined, authToken),
-      signal: AbortSignal.timeout(1500)
-    });
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
-function cachedServerReachability(projectRoot, baseUrl, authToken) {
-  const key = resolve2(projectRoot);
-  const cached = serverReachabilityCache.get(key);
-  if (cached)
-    return cached;
-  const probe = probeServerReachability(baseUrl, authToken);
-  serverReachabilityCache.set(key, probe);
-  return probe;
-}
-function describeSelectedServer(projectRoot, server) {
-  try {
-    const selected = resolveSelectedConnection(projectRoot);
-    if (selected) {
-      return {
-        alias: selected.alias,
-        target: selected.connection.kind === "remote" ? selected.connection.baseUrl : server.baseUrl
-      };
-    }
-  } catch {}
-  return { alias: server.connectionKind === "remote" ? "remote" : "local", target: server.baseUrl };
-}
-async function buildServerFailureContext(projectRoot, server) {
-  const { alias, target } = describeSelectedServer(projectRoot, server);
-  const reachable = await cachedServerReachability(projectRoot, server.baseUrl, server.authToken);
-  const reachability = reachable ? "server is reachable" : "server is unreachable";
-  return {
-    contextLine: `Currently connected to: ${alias} at ${target} (${reachability}).`,
-    hint: "Check the selected server with `rig server status`, or switch with `rig server use <alias|local>`."
-  };
-}
-function isLoopbackRemoteBaseUrl(baseUrl) {
-  try {
-    const host = new URL(baseUrl).hostname.toLowerCase();
-    return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
-  } catch {
-    return false;
-  }
-}
-function canUseRemoteWithoutProjectRoot(pathname) {
-  return pathname === "/health" || pathname === "/api/health" || pathname === "/api/server/status" || pathname === "/api/server/project-root" || pathname.startsWith("/api/github/auth/") || pathname === "/api/projects" || pathname.startsWith("/api/projects/");
-}
-async function requestServerJson(context, pathname, init = {}) {
-  const server = await ensureServerForCli(context.projectRoot);
-  const requestUrl = new URL(`${server.baseUrl}${pathname}`);
-  let scopedServerProjectRoot = server.serverProjectRoot;
-  if (server.connectionKind === "remote" && !scopedServerProjectRoot && !canUseRemoteWithoutProjectRoot(requestUrl.pathname) && (server.authToken || !isLoopbackRemoteBaseUrl(server.baseUrl))) {
-    const link = await ensureRemoteProjectRootLink(context.projectRoot, { mode: "backfill-only", authToken: server.authToken });
-    if (link.ok && link.serverProjectRoot) {
-      scopedServerProjectRoot = link.serverProjectRoot;
-    } else {
-      const repo = readRepoConnection(context.projectRoot);
-      const target = link.alias && link.baseUrl ? `${link.alias} (${link.baseUrl})` : server.baseUrl;
-      throw new CliError(`Remote server ${target} is selected for ${link.repoSlug ?? repo?.project ?? "this repo"}, but this checkout has no server-host project root link. ${link.message}`, 1, { hint: link.hint });
-    }
-  }
-  const headers = mergeHeaders(init.headers, server.authToken);
-  if (scopedServerProjectRoot)
-    headers.set("x-rig-project-root", scopedServerProjectRoot);
-  if (server.connectionKind === "remote" && server.authToken && queryAuthFallbackEnabled()) {
-    requestUrl.searchParams.set("rt", server.authToken);
-  }
-  reportServerPhase(`${(init.method ?? "GET").toUpperCase()} ${pathname.split("?")[0]}\u2026`);
-  let response;
-  try {
-    response = await fetch(requestUrl, {
-      ...init,
-      headers
-    });
-  } catch (error) {
-    const failure = await buildServerFailureContext(context.projectRoot, server);
-    throw new CliError(`Rig server request failed: ${error instanceof Error ? error.message : String(error)}
-${failure.contextLine}`, 1, { hint: failure.hint });
-  }
-  const text = await response.text();
-  const payload = text.trim().length > 0 ? (() => {
-    try {
-      return JSON.parse(text);
-    } catch {
-      return null;
-    }
-  })() : null;
-  if (!response.ok) {
-    const diagnostics = diagnosticMessage(payload);
-    const rawDetail = diagnostics ?? (text || response.statusText);
-    const detail = diagnostics ? rawDetail : rawDetail.split(`
-`).map((line) => line.trim()).find((line) => line.length > 0)?.slice(0, 200) ?? response.statusText;
-    const failure = await buildServerFailureContext(context.projectRoot, server);
-    throw new CliError(`Rig server request failed (${response.status}): ${detail}
-${failure.contextLine}`, 1, { hint: failure.hint });
-  }
-  return payload;
-}
-async function postGitHubTokenViaServer(context, token, options = {}) {
-  const server = await ensureServerForCli(context.projectRoot);
-  const requestUrl = new URL(`${server.baseUrl}/api/github/auth/token`);
-  reportServerPhase("POST /api/github/auth/token\u2026");
-  let response;
-  try {
-    response = await fetch(requestUrl, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ token, selectedRepo: options.selectedRepo, projectRoot: options.projectRoot ?? server.serverProjectRoot ?? undefined })
-    });
-  } catch (error) {
-    const failure = await buildServerFailureContext(context.projectRoot, server);
-    throw new CliError(`Rig server auth bootstrap failed: ${error instanceof Error ? error.message : String(error)}
-${failure.contextLine}`, 1, { hint: failure.hint });
-  }
-  const payload = await response.json().catch(() => null);
-  if (!response.ok) {
-    const detail = payload && typeof payload === "object" && !Array.isArray(payload) ? String(payload.error ?? JSON.stringify(payload)) : `HTTP ${response.status}`;
-    throw new CliError(`Rig server auth bootstrap failed (${response.status}): ${detail}`, 1, { hint: "Re-run `rig github auth import-gh`, or check the selected server with `rig server status`." });
-  }
-  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-}
-async function prepareRemoteCheckoutViaServer(context, input) {
-  const payload = await requestServerJson(context, `/api/projects/${encodeURIComponent(input.repoSlug)}/prepare-checkout`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ checkout: input.checkout, repoUrl: input.repoUrl, baseDir: input.baseDir })
-  });
-  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-}
-async function registerProjectViaServer(context, input) {
-  const payload = await requestServerJson(context, "/api/projects", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(input)
-  });
-  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-}
-function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
-}
-function isRetryableProjectRootSwitchError(error) {
-  if (!(error instanceof Error))
-    return false;
-  const message = error.message.toLowerCase();
-  return message.includes("rig server request failed (401): auth-required") || message.includes("rig server request failed (401): github-token-required") || message.includes("rig server request failed (502)") || message.includes("rig server request failed (503)") || message.includes("bad gateway") || message.includes("fetch failed") || message.includes("econnrefused") || message.includes("connection refused");
-}
-async function switchServerProjectRootViaServer(context, projectRoot, options = {}) {
-  const timeoutMs = options.timeoutMs ?? 30000;
-  const pollMs = options.pollMs ?? 1000;
-  const deadline = Date.now() + timeoutMs;
-  let lastError;
-  let switched = null;
-  while (Date.now() < deadline) {
-    try {
-      switched = await requestServerJson(context, "/api/server/project-root", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ projectRoot })
-      });
-      break;
-    } catch (error) {
-      lastError = error;
-      if (!isRetryableProjectRootSwitchError(error))
-        throw error;
-      await sleep(pollMs);
-    }
-  }
-  if (!switched) {
-    throw new CliError(`Rig server did not accept project-root switch to ${projectRoot} before timeout (${lastError instanceof Error ? lastError.message : String(lastError ?? "no response")}).`, 1);
-  }
-  const record = switched && typeof switched === "object" && !Array.isArray(switched) ? switched : {};
-  if (record.ok === true) {
-    writeRepoServerProjectRoot(context.projectRoot, projectRoot);
-    return { ok: true, switched: record };
-  }
-  throw new CliError(`Rig server rejected project-root scope ${projectRoot}: ${String(record.message ?? record.error ?? "unknown error")}`, 1);
-}
-async function ensureTaskLabelsViaServer(context) {
-  const payload = await requestServerJson(context, "/api/workspace/task-labels", { method: "POST" });
-  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-}
-async function listGitHubProjectsViaServer(context, owner) {
-  const url = new URL("http://rig.local/api/github/projects");
-  url.searchParams.set("owner", owner);
-  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
-  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { projects: [] };
-}
-async function getGitHubProjectStatusFieldViaServer(context, projectId) {
-  const payload = await requestServerJson(context, `/api/github/projects/${encodeURIComponent(projectId)}/status-field`);
-  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-}
-var scopedGitHubBearerTokens, serverPhaseListener = null, serverReachabilityCache, RESUMABLE_RUN_STATUSES;
-var init__server_client = __esm(() => {
-  init_runner();
-  init__connection_state();
-  scopedGitHubBearerTokens = new Map;
-  serverReachabilityCache = new Map;
-  RESUMABLE_RUN_STATUSES = new Set([
-    "created",
-    "preparing",
-    "running",
-    "validating",
-    "reviewing",
-    "stopped",
-    "failed",
-    "needs-attention",
-    "needs_attention"
-  ]);
-});
-
-// packages/cli/src/commands/_pi-install.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, rmSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { resolve as resolve3 } from "path";
-async function defaultCommandRunner(command, options = {}) {
-  const proc = Bun.spawn(command, { cwd: options.cwd, stdout: "pipe", stderr: "pipe" });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited
-  ]);
-  return { exitCode, stdout, stderr };
-}
-function resolvePiRigExtensionPath(homeDir) {
-  return resolve3(homeDir, ".pi", "agent", "extensions", "pi-rig");
-}
-function resolvePiRigPackageSource(projectRoot, exists = existsSync3) {
-  const localPackage = resolve3(projectRoot, "packages", "pi-rig");
-  if (exists(resolve3(localPackage, "package.json")))
-    return localPackage;
-  return `npm:${PI_RIG_PACKAGE_NAME}`;
-}
-function resolvePiHomeDir(inputHomeDir) {
-  return inputHomeDir ?? process.env.RIG_PI_HOME_DIR?.trim() ?? homedir2();
-}
-function piListContainsPiRig(output) {
-  return output.split(/\r?\n/).some((line) => {
-    const normalized = line.trim();
-    return normalized.includes(PI_RIG_PACKAGE_NAME) || normalized.includes(LEGACY_PI_RIG_PACKAGE_NAME) || /(?:^|[\\/])packages[\\/]pi-rig(?:$|\s)/.test(normalized);
-  });
-}
-async function safeRun(runner, command, options) {
-  try {
-    return await runner(command, options);
-  } catch (error) {
-    return { exitCode: 1, stdout: "", stderr: error instanceof Error ? error.message : String(error) };
-  }
-}
-function splitInstallCommand(value) {
-  return value.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => part.replace(/^['"]|['"]$/g, "")) ?? [];
-}
-async function ensurePiBinaryAvailable(input) {
-  const current = await safeRun(input.runner, ["pi", "--version"]);
-  if (current.exitCode === 0) {
-    const updateCommand = process.env.RIG_PI_UPDATE_COMMAND?.trim();
-    if (updateCommand) {
-      const parts2 = splitInstallCommand(updateCommand);
-      if (parts2.length > 0)
-        await safeRun(input.runner, parts2, input.projectRoot ? { cwd: input.projectRoot } : undefined);
-    }
-    return { ok: true, detail: (current.stdout || current.stderr).trim() || undefined };
-  }
-  const installCommand = process.env.RIG_PI_INSTALL_COMMAND?.trim() || "bunx @earendil-works/pi-coding-agent@latest install";
-  const parts = splitInstallCommand(installCommand);
-  if (parts.length === 0) {
-    return { ok: false, error: (current.stderr || current.stdout).trim() || "pi --version failed" };
-  }
-  const install = await safeRun(input.runner, parts, input.projectRoot ? { cwd: input.projectRoot } : undefined);
-  if (install.exitCode !== 0) {
-    return { ok: false, installedOrUpdated: true, error: (install.stderr || install.stdout).trim() || `Pi install command failed (${install.exitCode})` };
-  }
-  const next = await safeRun(input.runner, ["pi", "--version"]);
-  return {
-    ok: next.exitCode === 0,
-    installedOrUpdated: true,
-    detail: (next.stdout || next.stderr).trim() || undefined,
-    ...next.exitCode === 0 ? {} : { error: (next.stderr || next.stdout).trim() || "pi --version failed after install" }
-  };
-}
-function removeManagedLegacyPiRigBridge(homeDir, exists = existsSync3) {
-  const extensionPath = resolvePiRigExtensionPath(homeDir);
-  const indexPath = resolve3(extensionPath, "index.ts");
-  if (!exists(indexPath))
-    return;
-  try {
-    const content = readFileSync3(indexPath, "utf8");
-    if (content === LEGACY_PI_RIG_MARKER || content.includes("Managed by Rig. Source package: @rig/pi-rig")) {
-      rmSync(extensionPath, { recursive: true, force: true });
-    }
-  } catch {}
-}
-async function checkPiRigInstall(input = {}) {
-  const home = resolvePiHomeDir(input.homeDir);
-  const extensionPath = resolvePiRigExtensionPath(home);
-  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1") {
-    return {
-      extensionPath,
-      pi: { ok: true, label: "pi", detail: "fake-pi" },
-      piRig: { ok: true, label: "pi-rig global extension", detail: extensionPath }
-    };
-  }
-  const exists = input.exists ?? existsSync3;
-  const runner = input.commandRunner ?? defaultCommandRunner;
-  const piResult = await safeRun(runner, ["pi", "--version"]);
-  const piListResult = piResult.exitCode === 0 ? await safeRun(runner, ["pi", "list"]) : { exitCode: 1, stdout: "", stderr: "" };
-  const listedPiRig = piListResult.exitCode === 0 && piListContainsPiRig(`${piListResult.stdout}
-${piListResult.stderr}`);
-  const legacyBridge = exists(resolve3(extensionPath, "index.ts"));
-  const hasPiRig = listedPiRig;
-  return {
-    extensionPath,
-    pi: {
-      ok: piResult.exitCode === 0,
-      label: "pi",
-      detail: (piResult.stdout || piResult.stderr).trim() || undefined,
-      hint: piResult.exitCode === 0 ? undefined : "Install Pi or run `rig init --yes` to install/update the Pi runtime."
-    },
-    piRig: {
-      ok: hasPiRig,
-      label: "pi-rig global extension",
-      detail: hasPiRig ? piListResult.stdout.trim() || PI_RIG_PACKAGE_NAME : legacyBridge ? `${extensionPath} (legacy bridge; reinstall required)` : undefined,
-      hint: hasPiRig ? undefined : "Run `rig init --yes` to install/enable the global pi-rig package with `pi install`."
-    }
-  };
-}
-async function ensurePiRigInstalled(input) {
-  const home = resolvePiHomeDir(input.homeDir);
-  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1") {
-    const status2 = await checkPiRigInstall({ homeDir: home, commandRunner: input.commandRunner });
-    return { ...status2, installedPath: status2.extensionPath };
-  }
-  const runner = input.commandRunner ?? defaultCommandRunner;
-  const piAvailable = await ensurePiBinaryAvailable({ runner, projectRoot: input.projectRoot });
-  const status = piAvailable.ok ? await checkPiRigInstall({ homeDir: home, commandRunner: runner }) : {
-    extensionPath: resolvePiRigExtensionPath(home),
-    pi: { ok: false, label: "pi", detail: piAvailable.error, hint: "Install/update Pi with RIG_PI_INSTALL_COMMAND or install Pi manually." },
-    piRig: { ok: false, label: "pi-rig global extension", hint: "Pi is required before pi-rig can be installed." }
-  };
-  if (!piAvailable.ok) {
-    throw new Error(`Pi install/update failed: ${piAvailable.error ?? "pi unavailable"}`);
-  }
-  const packageSource = resolvePiRigPackageSource(input.projectRoot);
-  removeManagedLegacyPiRigBridge(home);
-  const install = await runner(["pi", "install", packageSource], { cwd: input.projectRoot });
-  if (install.exitCode !== 0) {
-    throw new Error(`pi-rig install failed: ${(install.stderr || install.stdout).trim() || `exit ${install.exitCode}`}`);
-  }
-  const next = await checkPiRigInstall({ homeDir: home, commandRunner: runner });
-  return { ...next, installedPath: packageSource };
-}
-async function ensureRemotePiRigInstalled(input) {
-  const payload = await input.requestJson("/api/pi-rig/install", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ package: PI_RIG_PACKAGE_NAME, scope: "global" })
-  });
-  const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-  const piOk = record.piOk === true || record.ok === true;
-  const piRigOk = record.piRigOk === true || record.installed === true || record.ok === true;
-  const extensionPath = typeof record.extensionPath === "string" ? record.extensionPath : "remote:~/.pi/agent/extensions/pi-rig";
-  return {
-    remote: true,
-    extensionPath,
-    pi: {
-      ok: piOk,
-      label: "pi",
-      detail: typeof record.piVersion === "string" ? record.piVersion : undefined,
-      hint: piOk ? undefined : "Install/update Pi on the selected remote Rig server."
-    },
-    piRig: {
-      ok: piRigOk,
-      label: "pi-rig global extension",
-      detail: extensionPath,
-      hint: piRigOk ? undefined : "Install/enable pi-rig on the selected remote Rig server."
-    }
-  };
-}
-async function buildPiSetupChecks(input = {}) {
-  const status = await checkPiRigInstall(input);
-  return [status.pi, status.piRig];
-}
-var PI_RIG_PACKAGE_NAME = "@h-rig/pi-rig", LEGACY_PI_RIG_PACKAGE_NAME = "@rig/pi-rig", LEGACY_PI_RIG_MARKER = `// Managed by Rig. Source package: @rig/pi-rig.
-export { default } from '@rig/pi-rig';
-`;
-var init__pi_install = () => {};
-
-// packages/cli/src/commands/_snapshot-upload.ts
-import { mkdir, readdir, readFile, writeFile } from "fs/promises";
-import { dirname as dirname3, resolve as resolve4, relative, sep } from "path";
-function toPosixPath(path) {
-  return path.split(sep).join("/");
-}
-function assertManifestPath(root, relativePath) {
-  if (!relativePath || relativePath.startsWith("/") || relativePath.includes("\x00")) {
-    throw new Error(`Invalid snapshot path: ${relativePath}`);
-  }
-  const resolved = resolve4(root, relativePath);
-  const relativeToRoot = relative(root, resolved);
-  if (relativeToRoot.startsWith("..") || relativeToRoot === ".." || resolve4(relativeToRoot) === resolved) {
-    throw new Error(`Snapshot path escapes project root: ${relativePath}`);
-  }
-  return resolved;
-}
-async function buildSnapshotUploadManifest(projectRoot, options = {}) {
-  const root = resolve4(projectRoot);
-  const excludedDirectories = [...new Set([
-    ...DEFAULT_EXCLUDED_DIRECTORIES,
-    ...options.excludedDirectories ?? []
-  ])];
-  const excludedSet = new Set(excludedDirectories);
-  const files = [];
-  async function visit(dir) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory() && excludedSet.has(entry.name))
-        continue;
-      const fullPath = resolve4(dir, entry.name);
-      if (entry.isDirectory()) {
-        await visit(fullPath);
-        continue;
-      }
-      if (!entry.isFile())
-        continue;
-      files.push(toPosixPath(relative(root, fullPath)));
-    }
-  }
-  await visit(root);
-  files.sort();
-  return { root, files, excludedDirectories };
-}
-async function createSnapshotUploadArchive(projectRoot, options = {}) {
-  const manifest = await buildSnapshotUploadManifest(projectRoot, options);
-  const files = await Promise.all(manifest.files.map(async (path) => {
-    const fullPath = assertManifestPath(manifest.root, path);
-    return {
-      path,
-      contentBase64: (await readFile(fullPath)).toString("base64")
-    };
-  }));
-  return {
-    version: SNAPSHOT_ARCHIVE_VERSION,
-    root: manifest.root,
-    files,
-    excludedDirectories: manifest.excludedDirectories,
-    createdAt: (options.now?.() ?? new Date).toISOString()
-  };
-}
-function encodeSnapshotUploadArchive(archive) {
-  return Buffer.from(JSON.stringify(archive), "utf8").toString("base64");
-}
-async function uploadSnapshotArchiveViaServer(context, input) {
-  const payload = await requestServerJson(context, `/api/projects/${encodeURIComponent(input.repoSlug)}/upload-snapshot`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({
-      archiveContentBase64: encodeSnapshotUploadArchive(input.archive),
-      contentType: SNAPSHOT_ARCHIVE_CONTENT_TYPE,
-      baseDir: input.baseDir
-    })
-  });
-  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-}
-var SNAPSHOT_ARCHIVE_VERSION = 1, SNAPSHOT_ARCHIVE_CONTENT_TYPE = "application/vnd.rig.snapshot+json", DEFAULT_EXCLUDED_DIRECTORIES;
-var init__snapshot_upload = __esm(() => {
-  init__server_client();
-  DEFAULT_EXCLUDED_DIRECTORIES = new Set([
-    ".git",
-    ".rig",
-    "node_modules",
-    ".turbo",
-    ".next",
-    ".cache",
-    "coverage",
-    "dist",
-    "build",
-    "out"
-  ]);
-});
-
-// packages/cli/src/commands/_parsers.ts
-async function loadRigConfigOrNull(projectRoot) {
-  try {
-    const { loadConfig } = await import("@rig/core/load-config");
-    return await loadConfig(projectRoot);
-  } catch {
-    return null;
-  }
-}
-var init__parsers = __esm(() => {
-  init_runner();
-});
-
-// packages/cli/src/commands/_doctor-checks.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve5 } from "path";
-import { isSupportedBunVersion, MIN_SUPPORTED_BUN_VERSION } from "@rig/runtime/control-plane/setup-version";
-function check(id, label, status, detail, remediation) {
-  return {
-    id,
-    label,
-    status,
-    ...detail ? { detail } : {},
-    ...remediation ? { remediation } : {}
-  };
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function isAuthenticated(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return false;
-  const record = payload;
-  return record.signedIn === true || record.authenticated === true || record.status === "authenticated" || record.ok === true && typeof record.login === "string" && record.login.trim().length > 0;
-}
-function repoSlugFromConfig(config) {
-  const project = config?.project;
-  if (project && typeof project === "object" && !Array.isArray(project)) {
-    const record = project;
-    if (typeof record.repo === "string" && /^([^/\s]+)\/([^/\s]+)$/.test(record.repo))
-      return record.repo;
-    if (typeof record.name === "string" && /^([^/\s]+)\/([^/\s]+)$/.test(record.name))
-      return record.name;
-  }
-  const taskSource = config?.taskSource;
-  if (taskSource && typeof taskSource === "object" && !Array.isArray(taskSource)) {
-    const source = taskSource;
-    if (typeof source.owner === "string" && typeof source.repo === "string")
-      return `${source.owner}/${source.repo}`;
-  }
-  return null;
-}
-function loadFallbackConfig(projectRoot) {
-  const candidates = ["rig.config.ts", "rig.config.mts", "rig.config.json"];
-  for (const name of candidates) {
-    const path = resolve5(projectRoot, name);
-    if (!existsSync4(path))
-      continue;
-    try {
-      const source = readFileSync4(path, "utf8");
-      if (name.endsWith(".json"))
-        return JSON.parse(source);
-      const owner = source.match(/owner\s*:\s*["']([^"']+)["']/)?.[1];
-      const repo = source.match(/repo\s*:\s*["']([^"']+)["']/)?.[1];
-      const projectRepo = source.match(/project\s*:\s*\{[^}]*repo\s*:\s*["']([^"']+)["']/s)?.[1] ?? (owner && repo ? `${owner}/${repo}` : undefined);
-      const taskKind = source.match(/taskSource\s*:\s*\{[^}]*kind\s*:\s*["']([^"']+)["']/s)?.[1];
-      if (projectRepo || taskKind) {
-        return {
-          ...projectRepo ? { project: { name: projectRepo, repo: projectRepo } } : {},
-          ...taskKind ? { taskSource: { kind: taskKind, ...owner ? { owner } : {}, ...repo ? { repo } : {} } } : {}
-        };
-      }
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-function projectStatusSlug(projectRoot, config) {
-  return readRepoConnection(projectRoot)?.project ?? repoSlugFromConfig(config);
-}
-function githubProjectsCheck(config) {
-  const github = config?.github;
-  const projects = github?.projects;
-  if (!projects?.enabled) {
-    return check("github-projects", "GitHub Projects status sync", "warn", "disabled or not configured", "Run `rig init --github-project <project>` or configure github.projects when Project status sync should be authoritative.");
-  }
-  if (projects.projectId && projects.statusFieldId) {
-    return check("github-projects", "GitHub Projects status sync", "pass", `project ${projects.projectId}`);
-  }
-  return check("github-projects", "GitHub Projects status sync", "fail", "enabled but projectId/statusFieldId is incomplete", "Configure github.projects.projectId and github.projects.statusFieldId, or disable github.projects.enabled.");
-}
-function permissionAllowsPr(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const record = payload;
-  if (record.canOpenPullRequest === true || record.pullRequests === true || record.push === true || record.maintain === true || record.admin === true)
-    return true;
-  if (record.canOpenPullRequest === false || record.pullRequests === false || record.push === false)
-    return false;
-  const permissions = record.permissions;
-  if (permissions && typeof permissions === "object" && !Array.isArray(permissions)) {
-    const p = permissions;
-    if (p.push === true || p.maintain === true || p.admin === true)
-      return true;
-    if (p.push === false && p.maintain !== true && p.admin !== true)
-      return false;
-  }
-  return null;
-}
-function labelsReady(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const record = payload;
-  if (record.ok === true || record.ready === true || record.labelsReady === true)
-    return true;
-  if (record.ok === false || record.ready === false || record.labelsReady === false)
-    return false;
-  return null;
-}
-function prMergeCheck(config) {
-  const pr = config?.pr;
-  const merge = config?.merge;
-  if (pr?.mode === "off" || merge?.mode === "off") {
-    return check("pr-merge", "PR/merge automation", "warn", "automatic PR or merge is disabled", "Set pr.mode and merge.mode to auto for autonomous YOLO runs.");
-  }
-  return check("pr-merge", "PR/merge automation", "pass", `pr=${pr?.mode ?? "auto"}, merge=${merge?.mode ?? "auto"}, method=${merge?.method ?? "repo-default"}`);
-}
-async function runRigDoctorChecks(options) {
-  const projectRoot = options.projectRoot;
-  const checks = [];
-  const which = options.which ?? ((binary) => Bun.which(binary));
-  const bunVersion = options.bunVersion ?? Bun.version;
-  const request = options.requestJson ?? ((pathname, init) => requestServerJson({ projectRoot }, pathname, init));
-  const loadConfig = options.loadConfig ?? loadRigConfigOrNull;
-  const progress = options.onProgress ?? (() => {});
-  progress("Checking local toolchain\u2026");
-  checks.push(check("bun", `bun >= ${MIN_SUPPORTED_BUN_VERSION}`, isSupportedBunVersion(bunVersion) ? "pass" : "fail", `found ${bunVersion}`, `Install Bun ${MIN_SUPPORTED_BUN_VERSION} or newer.`), check("git", "git", which("git") ? "pass" : "fail", which("git") ?? undefined, "Install git and ensure it is on PATH."), check("jq", "jq", which("jq") ? "pass" : "warn", which("jq") ?? undefined, "Install jq (for example `brew install jq`)."));
-  progress("Loading rig.config\u2026");
-  const loadedConfig = await loadConfig(projectRoot).catch(() => null);
-  const config = loadedConfig ?? loadFallbackConfig(projectRoot);
-  const hasConfigFile = ["rig.config.ts", "rig.config.mts", "rig.config.json"].some((name) => existsSync4(resolve5(projectRoot, name)));
-  checks.push(config ? check("config", "rig.config loadable", "pass") : check("config", "rig.config loadable", hasConfigFile ? "fail" : "fail", hasConfigFile ? "config file exists but failed to load" : "missing rig.config.ts/json", "Run `rig init` or fix the config error."));
-  const taskSourceKind = config?.taskSource?.kind;
-  checks.push(taskSourceKind ? check("task-source", "task source configured", "pass", taskSourceKind) : check("task-source", "task source configured", "fail", "missing taskSource", "Configure taskSource in rig.config.ts."));
-  const repo = readRepoConnection(projectRoot);
-  checks.push(repo ? check("project-link", "repo selected Rig server", repo.project ? "pass" : "warn", `${repo.selected}${repo.project ? ` -> ${repo.project}` : ""}`, "Run `rig init --yes --repo owner/repo` to link this checkout to a GitHub repo slug.") : check("project-link", "repo selected Rig server", "fail", "missing .rig/state/connection.json", "Run `rig init` or `rig server use <alias|local>`."));
-  const selected = (() => {
-    try {
-      return resolveSelectedConnection(projectRoot);
-    } catch {
-      return null;
-    }
-  })();
-  checks.push(selected ? check("connection", "selected server connection", "pass", selected.connection.kind === "remote" ? selected.connection.baseUrl : "local auto") : check("connection", "selected server", repo ? "fail" : "warn", repo ? "selected alias is missing" : "will auto-start local server", repo ? "Run `rig server list` and `rig server use <alias|local>`." : undefined));
-  let server = null;
-  try {
-    progress("Connecting to the selected Rig server\u2026");
-    server = await (options.resolveServer ?? ensureServerForCli)(projectRoot);
-    checks.push(check("server", "Rig server reachable", "pass", `${server.connectionKind} ${server.baseUrl}`));
-  } catch (error) {
-    checks.push(check("server", "Rig server reachable", "fail", errorMessage(error), "Start the local Rig server or fix the selected remote connection."));
-  }
-  if (server || options.requestJson) {
-    try {
-      progress("Checking server status\u2026");
-      const status = await request("/api/server/status");
-      checks.push(check("server-status", "server project status", "pass", JSON.stringify(status).slice(0, 180)));
-    } catch (error) {
-      checks.push(check("server-status", "server project status", "fail", errorMessage(error), "Run `rig doctor` after the selected server is reachable."));
-    }
-    try {
-      progress("Checking GitHub auth\u2026");
-      const auth = await request("/api/github/auth/status");
-      checks.push(isAuthenticated(auth) ? check("github-auth", "GitHub auth", "pass") : check("github-auth", "GitHub auth", "fail", "not authenticated", "Run `rig github auth import-gh` or `rig github auth token --token <token>`."));
-    } catch (error) {
-      checks.push(check("github-auth", "GitHub auth", "fail", errorMessage(error), "Authenticate GitHub through Rig and ensure the server exposes auth status."));
-    }
-    try {
-      progress("Checking GitHub repo permissions\u2026");
-      const permissions = await request("/api/github/repo/permissions");
-      const allowed = permissionAllowsPr(permissions);
-      checks.push(allowed === true ? check("github-repo-permissions", "GitHub repo PR permissions", "pass", JSON.stringify(permissions).slice(0, 180)) : allowed === false ? check("github-repo-permissions", "GitHub repo PR permissions", "fail", JSON.stringify(permissions).slice(0, 180), "Grant the selected GitHub token permission to push branches, open PRs, and merge according to repo rules.") : check("github-repo-permissions", "GitHub repo PR permissions", "warn", JSON.stringify(permissions).slice(0, 180), "Confirm the selected token can push branches and open PRs."));
-    } catch (error) {
-      checks.push(check("github-repo-permissions", "GitHub repo PR permissions", "warn", errorMessage(error), "Ensure the server exposes repo permission checks and the token can open PRs."));
-    }
-    try {
-      progress("Checking GitHub issue labels\u2026");
-      const labels = await request("/api/workspace/task-labels");
-      const ready = labelsReady(labels);
-      checks.push(ready === false ? check("task-labels", "GitHub issue labels", "fail", JSON.stringify(labels).slice(0, 180), "Let Rig create required labels or create the configured lifecycle labels manually.") : check("task-labels", "GitHub issue labels", ready === true ? "pass" : "warn", JSON.stringify(labels).slice(0, 180), "Confirm required Rig lifecycle labels exist."));
-    } catch (error) {
-      checks.push(check("task-labels", "GitHub issue labels", "warn", errorMessage(error), "Run `rig init`/`rig doctor` after label setup is wired on the server."));
-    }
-    try {
-      progress("Checking task projection\u2026");
-      const projection = await request("/api/workspace/task-projection");
-      checks.push(check("task-projection", "task projection", "pass", JSON.stringify(projection).slice(0, 180)));
-    } catch (error) {
-      checks.push(check("task-projection", "task projection", "warn", errorMessage(error), "Refresh task projection with `rig task list` or fix the task source."));
-    }
-    const slug = projectStatusSlug(projectRoot, config);
-    if (slug) {
-      try {
-        progress("Checking server project checkout\u2026");
-        const project = await request(`/api/projects/${encodeURIComponent(slug)}`);
-        checks.push(check("remote-checkout", "server project checkout", "pass", JSON.stringify(project).slice(0, 180)));
-      } catch (error) {
-        checks.push(check("remote-checkout", "server project checkout", "warn", errorMessage(error), "Run `rig init --yes --repo owner/repo` to register/link the server project checkout."));
-      }
-    } else {
-      checks.push(check("remote-checkout", "server project checkout", "warn", "repo slug unknown", "Set project.repo or run `rig init --repo owner/repo`."));
-    }
-  }
-  if (taskSourceKind === "github-issues") {
-    checks.push(check("gh", "gh CLI fallback", which("gh") ? "pass" : "warn", which("gh") ?? undefined, "Install gh for local/dev GitHub fallback operations."));
-  }
-  checks.push(githubProjectsCheck(config));
-  checks.push(prMergeCheck(config));
-  progress("Checking Pi installation\u2026");
-  const piChecks = await (options.piChecks ?? (() => buildPiSetupChecks()))().catch((error) => [{
-    ok: false,
-    label: "pi/pi-rig checks",
-    hint: errorMessage(error)
-  }]);
-  for (const pi of piChecks) {
-    checks.push(check(pi.label === "pi" ? "pi" : "pi-rig", pi.label, pi.ok ? "pass" : "warn", pi.detail, pi.hint ?? (pi.ok ? undefined : "Run `rig init --yes` to install/update Pi and enable pi-rig.")));
-  }
-  return checks;
-}
-function countDoctorFailures(checks) {
-  return checks.filter((entry) => entry.status === "fail").length;
-}
-var init__doctor_checks = __esm(() => {
-  init_runner();
-  init__connection_state();
-  init__server_client();
-  init__parsers();
-  init__pi_install();
-});
-
-// packages/cli/src/app/theme.ts
-function hexToRgb(hex) {
-  const value = hex.replace("#", "");
-  return [
-    Number.parseInt(value.slice(0, 2), 16),
-    Number.parseInt(value.slice(2, 4), 16),
-    Number.parseInt(value.slice(4, 6), 16)
-  ];
-}
-function fg(hex) {
-  const [r, g, b] = hexToRgb(hex);
-  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[39m`;
-}
-function bold(text) {
-  return `\x1B[1m${text}\x1B[22m`;
-}
-function microDroneFrame(tick) {
-  const blade = MICRO_BLADES[tick % MICRO_BLADES.length];
-  const eye = EYE_FRAMES[Math.floor(tick / 2) % EYE_FRAMES.length];
-  return `(${blade})${eye}(${blade})`;
-}
-function renderMicroDroneFrame(tick) {
-  const blade = MICRO_BLADES[tick % MICRO_BLADES.length];
-  const eye = EYE_FRAMES[Math.floor(tick / 2) % EYE_FRAMES.length];
-  return `${ink4("(")}${cyan(blade)}${ink4(")")}${bold(accent(eye))}${ink4("(")}${cyan(blade)}${ink4(")")}`;
-}
-var RIG_PALETTE, ink, ink2, ink3, ink4, accent, accentDim, cyan, red, yellow, DRONE_ART, EYE_FRAMES, DRONE_WIDTH, DRONE_HEIGHT, MICRO_BLADES, MICRO_DRONE_FRAMES;
-var init_theme = __esm(() => {
-  RIG_PALETTE = {
-    ink: "#f2f3f6",
-    ink2: "#aeb0ba",
-    ink3: "#6c6e79",
-    ink4: "#44464f",
-    accent: "#ccff4d",
-    accentDim: "#a9d63f",
-    cyan: "#56d8ff",
-    red: "#ff5d5d",
-    yellow: "#ffd24d"
-  };
-  ink = fg(RIG_PALETTE.ink);
-  ink2 = fg(RIG_PALETTE.ink2);
-  ink3 = fg(RIG_PALETTE.ink3);
-  ink4 = fg(RIG_PALETTE.ink4);
-  accent = fg(RIG_PALETTE.accent);
-  accentDim = fg(RIG_PALETTE.accentDim);
-  cyan = fg(RIG_PALETTE.cyan);
-  red = fg(RIG_PALETTE.red);
-  yellow = fg(RIG_PALETTE.yellow);
-  DRONE_ART = [
-    "  .-=-.                   .-=-.   ",
-    " ( !!! )                 ( !!! )  ",
-    "  '-=-'._               _.'-=-'   ",
-    "        '._           _.'         ",
-    "           '=$$$$$$$=.'           ",
-    "          =$$$$$$$$$$$=           ",
-    "         $$$@@@@@@@@@@$$$         ",
-    "        $$$@@        @@$$$        ",
-    "        $$@    ?     @$$$         ",
-    "        $$$@   '-'   @$$$         ",
-    "        $$$@@        @@$$$        ",
-    "         $$$@@@@@@@@@@$$$         ",
-    "          =$$$$$$$$$$$=           ",
-    "           '=$$$$$$$=.'           ",
-    "        _.'           '._         ",
-    "  .-=-.'                 '.-=-.   ",
-    " ( !!! )                 ( !!! )  ",
-    "  '-=-'                   '-=-'   "
-  ];
-  EYE_FRAMES = ["@", "o", "."];
-  DRONE_WIDTH = DRONE_ART[0].length;
-  DRONE_HEIGHT = DRONE_ART.length;
-  MICRO_BLADES = ["---", "\\\\\\", "|||", "///"];
-  MICRO_DRONE_FRAMES = Array.from({ length: 12 }, (_, index) => microDroneFrame(index));
-});
-
-// packages/cli/src/commands/_spinner.ts
-function createTtySpinner(input) {
-  const output = input.output ?? process.stdout;
-  const isTty = output.isTTY === true;
-  const frames = input.frames && input.frames.length > 0 ? input.frames : SPINNER_FRAMES;
-  let label = input.label;
-  let frame = 0;
-  let paused = false;
-  let stopped = false;
-  let lastPrintedLabel = "";
-  const render = () => {
-    if (stopped || paused)
-      return;
-    if (!isTty) {
-      if (label !== lastPrintedLabel) {
-        output.write(`${label}
-`);
-        lastPrintedLabel = label;
-      }
-      return;
-    }
-    frame = (frame + 1) % frames.length;
-    const glyph = frames[frame] ?? frames[0] ?? "";
-    output.write(`\r\x1B[2K${input.styleFrame ? input.styleFrame(glyph) : glyph} ${label}`);
-  };
-  const clearLine = () => {
-    if (isTty)
-      output.write("\r\x1B[2K");
-  };
-  render();
-  const timer = isTty ? setInterval(render, input.intervalMs ?? 16) : null;
-  return {
-    setLabel(next) {
-      label = next;
-      render();
-    },
-    pause() {
-      paused = true;
-      clearLine();
-    },
-    resume() {
-      if (stopped)
-        return;
-      paused = false;
-      render();
-    },
-    stop(finalLine) {
-      if (stopped)
-        return;
-      stopped = true;
-      if (timer)
-        clearInterval(timer);
-      clearLine();
-      if (finalLine)
-        output.write(`${finalLine}
-`);
-    }
-  };
-}
-var SPINNER_FRAMES;
-var init__spinner = __esm(() => {
-  SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-});
-
-// packages/cli/src/app/drone-ui.ts
-var exports_drone_ui = {};
-__export(exports_drone_ui, {
-  droneWarn: () => droneWarn,
-  droneText: () => droneText,
-  droneStep: () => droneStep,
-  droneSpinner: () => droneSpinner,
-  droneSelect: () => droneSelect,
-  droneOutro: () => droneOutro,
-  droneNote: () => droneNote,
-  droneIntro: () => droneIntro,
-  droneInfo: () => droneInfo,
-  droneError: () => droneError,
-  droneConfirm: () => droneConfirm,
-  droneCancel: () => droneCancel
-});
-import { ProcessTerminal, TUI, Text, Input, SelectList, matchesKey } from "@earendil-works/pi-tui";
-function hairline(width = Math.min(process.stdout.columns ?? 80, 100)) {
-  return ink4("\u2500".repeat(Math.max(10, width)));
-}
-function droneIntro(title, subtitle) {
-  console.log("");
-  console.log(` ${accent("\u258D")}${bold(ink(title))}${subtitle ? ink3(` \u2014 ${subtitle}`) : ""}`);
-  console.log(hairline());
-}
-function droneOutro(text) {
-  console.log(hairline());
-  console.log(` ${accent("\u25C6")} ${ink2(text)}`);
-  console.log("");
-}
-function droneNote(message, title) {
-  if (title)
-    console.log(` ${accentDim("\u25C7")} ${bold(ink2(title))}`);
-  for (const line of message.split(`
-`)) {
-    console.log(` ${ink4("\u2502")} ${line}`);
-  }
-}
-function droneStep(text) {
-  console.log(` ${accent("\u203A")} ${ink(text)}`);
-}
-function droneInfo(text) {
-  console.log(` ${cyan("\xB7")} ${ink2(text)}`);
-}
-function droneWarn(text) {
-  console.log(` ${yellow("\u25B2")} ${ink2(text)}`);
-}
-function droneError(text) {
-  console.log(` ${red("\u2716")} ${ink2(text)}`);
-}
-function droneCancel(text) {
-  console.log(` ${red("\u2716")} ${ink3(text)}`);
-}
-function droneSpinner() {
-  let active = null;
-  return {
-    start(message) {
-      active = createTtySpinner({
-        label: message,
-        frames: MICRO_DRONE_FRAMES,
-        styleFrame: (frame) => renderMicroDroneFrame(Math.max(0, MICRO_DRONE_FRAMES.indexOf(frame)))
-      });
-    },
-    stop(message) {
-      active?.stop(message ? ` ${accent("\u25C6")} ${ink2(message)}` : undefined);
-      active = null;
-    },
-    error(message) {
-      active?.stop(message ? ` ${red("\u2716")} ${ink2(message)}` : undefined);
-      active = null;
-    }
-  };
-}
-async function runMiniTui(build) {
-  const terminal = new ProcessTerminal;
-  const tui = new TUI(terminal);
-  let settled = false;
-  return await new Promise((resolve6) => {
-    const finish = (result) => {
-      if (settled)
-        return;
-      settled = true;
-      tui.stop();
-      resolve6(result);
-    };
-    build(tui, finish);
-    tui.start();
-  });
-}
-async function droneSelect(input) {
-  if (!isTty() || input.options.length === 0) {
-    return input.initialValue ?? input.options[0]?.value ?? null;
-  }
-  return runMiniTui((tui, finish) => {
-    tui.addChild(new Text(` ${accent("\u258D")}${bold(ink(input.message))}`));
-    const items = input.options.map((option) => ({
-      value: option.value,
-      label: option.label,
-      ...option.hint ? { description: option.hint } : {}
-    }));
-    const list = new SelectList(items, Math.min(items.length, 12), SELECT_THEME);
-    const initialIndex = input.initialValue ? items.findIndex((item) => item.value === input.initialValue) : -1;
-    if (initialIndex > 0)
-      list.setSelectedIndex(initialIndex);
-    list.onSelect = (item) => finish(item.value);
-    list.onCancel = () => finish(null);
-    tui.addChild(list);
-    tui.addChild(new Text(ink4(" \u2191\u2193 navigate \xB7 enter select \xB7 esc cancel")));
-    tui.setFocus(list);
-    tui.addInputListener((data) => {
-      if (matchesKey(data, "ctrl+c") || matchesKey(data, "escape")) {
-        finish(null);
-        return { consume: true };
-      }
-      return;
-    });
-  });
-}
-async function droneText(input) {
-  if (!isTty())
-    return input.initialValue ?? null;
-  return runMiniTui((tui, finish) => {
-    tui.addChild(new Text(` ${accent("\u258D")}${bold(ink(input.message))}${input.placeholder ? ink4(`  (${input.placeholder})`) : ""}`));
-    const field = new Input;
-    if (input.initialValue)
-      field.setValue(input.initialValue);
-    field.onSubmit = (value) => finish(value);
-    field.onEscape = () => finish(null);
-    tui.addChild(field);
-    tui.addChild(new Text(ink4(" enter submit \xB7 esc cancel")));
-    tui.setFocus(field);
-    tui.addInputListener((data) => {
-      if (matchesKey(data, "ctrl+c")) {
-        finish(null);
-        return { consume: true };
-      }
-      return;
-    });
-  });
-}
-async function droneConfirm(input) {
-  const answer = await droneSelect({
-    message: input.message,
-    options: [
-      { value: "yes", label: "Yes" },
-      { value: "no", label: "No" }
-    ],
-    initialValue: input.initialValue === false ? "no" : "yes"
-  });
-  return answer === null ? null : answer === "yes";
-}
-var isTty = () => Boolean(process.stdout.isTTY), SELECT_THEME;
-var init_drone_ui = __esm(() => {
-  init_theme();
-  init__spinner();
-  SELECT_THEME = {
-    selectedPrefix: (text) => accent(text),
-    selectedText: (text) => bold(ink(text)),
-    description: (text) => ink3(text),
-    scrollInfo: (text) => ink4(text),
-    noMatch: (text) => ink3(text)
-  };
-});
-
-// packages/cli/src/commands/init.ts
-var exports_init = {};
-__export(exports_init, {
-  runInteractiveControlPlaneInit: () => runInteractiveControlPlaneInit,
-  runDemoInit: () => runDemoInit,
-  executeInit: () => executeInit,
-  buildRigInitConfigSource: () => buildRigInitConfigSource,
-  DEMO_TASKS_RELATIVE_DIR: () => DEMO_TASKS_RELATIVE_DIR,
-  DEMO_TASKS: () => DEMO_TASKS
-});
-import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { spawnSync } from "child_process";
-import { basename, resolve as resolve6 } from "path";
-import { buildRigInitConfigSource } from "@rig/core";
-import { listGitHubProjects as listGitHubProjectsDirect, resolveProjectStatusField as resolveProjectStatusFieldDirect } from "@rig/server";
-function parseRepoSlugFromRemote(remoteUrl) {
-  const trimmed = remoteUrl.trim();
-  const gitHubMatch = trimmed.match(/github\.com[:/]([^/]+)\/([^/.]+)(?:\.git)?$/i);
-  return gitHubMatch ? `${gitHubMatch[1]}/${gitHubMatch[2]}` : null;
-}
-function detectOriginRepoSlug(projectRoot) {
-  const result = spawnSync("git", ["-C", projectRoot, "remote", "get-url", "origin"], { encoding: "utf8" });
-  if (result.status !== 0)
-    return null;
-  return parseRepoSlugFromRemote(result.stdout.trim());
-}
-function parseRepoSlug(value) {
-  const match = value.trim().match(/^([^/\s]+)\/([^/\s]+)$/);
-  if (!match)
-    throw new CliError(`Invalid GitHub repo slug: ${value}. Expected owner/repo.`, 1, { hint: "Pass the slug as owner/repo, e.g. `rig init --repo acme/widgets`." });
-  return { owner: match[1], repo: match[2], slug: `${match[1]}/${match[2]}` };
-}
-function ensureRigPrivateDirs(projectRoot) {
-  const rigDir = resolve6(projectRoot, ".rig");
-  mkdirSync3(resolve6(rigDir, "state"), { recursive: true });
-  mkdirSync3(resolve6(rigDir, "logs"), { recursive: true });
-  mkdirSync3(resolve6(rigDir, "runs"), { recursive: true });
-  mkdirSync3(resolve6(rigDir, "tmp"), { recursive: true });
-  mkdirSync3(resolve6(projectRoot, "artifacts"), { recursive: true });
-  const taskConfigPath = resolve6(rigDir, "task-config.json");
-  if (!existsSync5(taskConfigPath))
-    writeFileSync3(taskConfigPath, `{}
-`, "utf-8");
-}
-function ensureGitignoreEntries(projectRoot) {
-  const path = resolve6(projectRoot, ".gitignore");
-  const existing = existsSync5(path) ? readFileSync5(path, "utf8") : "";
-  const entries = [".rig/state/", ".rig/logs/", ".rig/runs/", ".rig/tmp/"];
-  const missing = entries.filter((entry) => !existing.split(/\r?\n/).includes(entry));
-  if (missing.length === 0)
-    return;
-  const prefix = existing.length > 0 && !existing.endsWith(`
-`) ? `
-` : "";
-  appendFileSync(path, `${prefix}${missing.join(`
-`)}
-`, "utf8");
-}
-function ensureRigConfigPackageDependencies(projectRoot) {
-  const path = resolve6(projectRoot, "package.json");
-  const existing = existsSync5(path) ? JSON.parse(readFileSync5(path, "utf8")) : {};
-  const devDependencies = existing.devDependencies && typeof existing.devDependencies === "object" && !Array.isArray(existing.devDependencies) ? { ...existing.devDependencies } : {};
-  for (const [name, spec] of Object.entries(RIG_CONFIG_DEV_DEPENDENCIES)) {
-    devDependencies[name] = spec;
-  }
-  const next = {
-    ...existsSync5(path) ? existing : { name: "rig-project", private: true },
-    devDependencies
-  };
-  writeFileSync3(path, `${JSON.stringify(next, null, 2)}
-`, "utf8");
-}
-function applyGitHubProjectConfig(source, options) {
-  if (!options.githubProject || options.githubProject === "off")
-    return source;
-  const projectId = JSON.stringify(options.githubProject);
-  const statusFieldId = JSON.stringify(options.githubProjectStatusField ?? "Status");
-  const statuses = options.githubProjectStatuses && Object.keys(options.githubProjectStatuses).length > 0 ? `
-      statuses: ${JSON.stringify(options.githubProjectStatuses, null, 8).replace(/\n/g, `
-      `)},` : "";
-  return source.replace(`    projects: { enabled: false },`, [
-    `    projects: {`,
-    `      enabled: true,`,
-    `      projectId: ${projectId},`,
-    `      statusFieldId: ${statusFieldId},${statuses}`,
-    `    },`
-  ].join(`
-`));
-}
-function checkoutForInit(projectRoot, serverKind, strategy) {
-  if (serverKind === "local")
-    return { kind: "local", path: projectRoot };
-  const selected = strategy ?? { kind: "managed-clone" };
-  switch (selected.kind) {
-    case "managed-clone":
-      return { kind: "managed-clone" };
-    case "current-ref":
-      return { kind: "current-ref", ...selected.ref ? { ref: selected.ref } : {} };
-    case "uploaded-snapshot":
-      return { kind: "uploaded-snapshot", path: projectRoot, source: "local-working-tree" };
-    case "existing-path":
-      return { kind: "existing-path", path: selected.path };
-  }
-}
-function detectGhLogin() {
-  const result = spawnSync("gh", ["api", "user", "--jq", ".login"], { encoding: "utf8", timeout: 5000, stdio: ["ignore", "pipe", "ignore"] });
-  return result.status === 0 && result.stdout.trim() ? result.stdout.trim() : null;
-}
-function readGhAuthToken() {
-  const result = spawnSync("gh", ["auth", "token"], { encoding: "utf8" });
-  if (result.status !== 0 || !result.stdout.trim()) {
-    throw new CliError(result.stderr.trim() || "Could not read GitHub token from `gh auth token`.", result.status || 1, { hint: "Sign in with `gh auth login`, or pass a token directly: `rig init --github-auth token --github-token <token>`." });
-  }
-  return result.stdout.trim();
-}
-function refreshGhProjectScopesAndReadToken() {
-  const result = spawnSync("gh", ["auth", "refresh", "--scopes", "read:project"], {
-    encoding: "utf8",
-    stdio: ["inherit", "pipe", "pipe"]
-  });
-  if (result.status !== 0)
-    return null;
-  try {
-    return readGhAuthToken();
-  } catch {
-    return null;
-  }
-}
-async function loadClackPrompts() {
-  const drone = await Promise.resolve().then(() => (init_drone_ui(), exports_drone_ui));
-  return {
-    intro: (message) => drone.droneIntro(message),
-    outro: (message) => drone.droneOutro(message),
-    cancel: (message) => drone.droneCancel(message),
-    isCancel: (value) => value === DRONE_CANCEL,
-    text: async (options) => {
-      const value = await drone.droneText({
-        message: options.message,
-        ...options.placeholder ? { placeholder: options.placeholder } : {},
-        ...(options.initialValue ?? options.defaultValue)?.trim() ? { initialValue: (options.initialValue ?? options.defaultValue).trim() } : {}
-      });
-      return value === null ? DRONE_CANCEL : value;
-    },
-    select: async (options) => {
-      const value = await drone.droneSelect({
-        message: options.message,
-        options: options.options,
-        ...options.initialValue ? { initialValue: options.initialValue } : {}
-      });
-      return value === null ? DRONE_CANCEL : value;
-    },
-    confirm: async (options) => {
-      const value = await drone.droneConfirm(options);
-      return value === null ? DRONE_CANCEL : value;
-    }
-  };
-}
-async function promptRequiredText(prompts, options) {
-  const value = await prompts.text(options);
-  if (prompts.isCancel(value))
-    throw new CliError("Init cancelled.", 1);
-  const text = String(value ?? "").trim();
-  if (!text)
-    throw new CliError(`${options.message} is required.`, 1);
-  return text;
-}
-async function promptOptionalText(prompts, options) {
-  const value = await prompts.text(options);
-  if (prompts.isCancel(value))
-    throw new CliError("Init cancelled.", 1);
-  return String(value ?? "").trim();
-}
-async function promptSelect(prompts, options) {
-  const value = await prompts.select(options);
-  if (prompts.isCancel(value))
-    throw new CliError("Init cancelled.", 1);
-  return String(value);
-}
-function repoOwnerFromSlug(repoSlug) {
-  return repoSlug.trim().match(/^([^/]+)\/[^/]+$/)?.[1] ?? null;
-}
-function recordArray(value, key) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return [];
-  const raw = value[key];
-  return Array.isArray(raw) ? raw.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
-}
-async function listGitHubProjectsForInit(context, owner, token) {
-  if (token?.trim()) {
-    try {
-      return { ok: true, projects: await listGitHubProjectsDirect({ owner, token: token.trim() }) };
-    } catch (directError) {
-      const serverPayload = await listGitHubProjectsViaServer(context, owner).catch(() => null);
-      if (recordArray(serverPayload, "projects").length > 0)
-        return serverPayload;
-      return { ok: false, error: directError instanceof Error ? directError.message : String(directError), projects: [] };
-    }
-  }
-  return listGitHubProjectsViaServer(context, owner);
-}
-async function getGitHubProjectStatusFieldForInit(context, projectId, token) {
-  if (token?.trim()) {
-    try {
-      return { ok: true, field: await resolveProjectStatusFieldDirect({ projectId, token: token.trim() }) };
-    } catch (directError) {
-      const serverPayload = await getGitHubProjectStatusFieldViaServer(context, projectId).catch(() => null);
-      if (serverPayload && typeof serverPayload === "object" && !Array.isArray(serverPayload) && "field" in serverPayload) {
-        return serverPayload;
-      }
-      return { ok: false, error: directError instanceof Error ? directError.message : String(directError) };
-    }
-  }
-  return getGitHubProjectStatusFieldViaServer(context, projectId);
-}
-async function promptManualProjectStatusMapping(prompts) {
-  const statuses = {};
-  for (const [key, label] of Object.entries(PROJECT_STATUS_PROMPTS)) {
-    const defaultLabel = DEFAULT_PROJECT_STATUS_OPTIONS[key] ?? label;
-    const value = await promptOptionalText(prompts, {
-      message: `Project status option id/name for ${label} (blank for ${defaultLabel})`,
-      placeholder: defaultLabel
-    });
-    statuses[key] = value || defaultLabel;
-  }
-  return statuses;
-}
-function projectScopeError(value) {
-  const text = typeof value === "string" ? value : JSON.stringify(value ?? "");
-  return /INSUFFICIENT_SCOPES|read:project|required scopes/i.test(text);
-}
-function optionName(option) {
-  return String(option.name ?? option.label ?? option.id ?? "").trim();
-}
-function autoProjectStatusValue(options, key, label) {
-  const candidates = [DEFAULT_PROJECT_STATUS_OPTIONS[key], label].filter((value) => Boolean(value)).map((value) => value.trim().toLowerCase());
-  const match = options.find((option) => candidates.includes(optionName(option).toLowerCase()));
-  if (!match)
-    return null;
-  return String(match.id ?? match.name);
-}
-async function promptGitHubProjectConfig(context, prompts, repoSlug, githubToken, refreshProjectToken) {
-  const projectChoice = await promptSelect(prompts, {
-    message: "GitHub Projects status sync",
-    initialValue: "select",
-    options: [
-      { value: "select", label: "Select accessible ProjectV2" },
-      { value: "off", label: "Off" },
-      { value: "manual", label: "Enter ProjectV2 ids manually" }
-    ]
-  });
-  if (projectChoice === "off")
-    return { githubProject: "off" };
-  if (projectChoice === "manual") {
-    return {
-      githubProject: await promptRequiredText(prompts, { message: "GitHub ProjectV2 id", placeholder: "PVT_..." }),
-      githubProjectStatusField: await promptRequiredText(prompts, { message: "Project Status field id", placeholder: "field_status" }),
-      githubProjectStatuses: await promptManualProjectStatusMapping(prompts)
-    };
-  }
-  const owner = repoOwnerFromSlug(repoSlug);
-  if (!owner)
-    throw new CliError(`Cannot derive GitHub owner from repo slug ${repoSlug}.`, 1, { hint: "Pass the slug as owner/repo, e.g. `rig init --repo acme/widgets`." });
-  let activeToken = githubToken?.trim() || null;
-  let projectsPayload = await listGitHubProjectsForInit(context, owner, activeToken).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error), projects: [] }));
-  let projects = recordArray(projectsPayload, "projects");
-  if (projects.length === 0 && projectScopeError(projectsPayload.error) && refreshProjectToken) {
-    prompts.outro?.("GitHub token is missing read:project; refreshing gh auth scopes and retrying Projects.");
-    const refreshedToken = refreshProjectToken();
-    if (refreshedToken) {
-      activeToken = refreshedToken;
-      projectsPayload = await listGitHubProjectsForInit(context, owner, activeToken).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error), projects: [] }));
-      projects = recordArray(projectsPayload, "projects");
-    }
-  }
-  if (projects.length === 0) {
-    const error = typeof projectsPayload.error === "string" ? ` (${String(projectsPayload.error).replace(/\s+/g, " ").slice(0, 240)})` : "";
-    prompts.outro?.(`No accessible GitHub Projects were returned${error}; continuing with GitHub Projects status sync off.`);
-    return { githubProject: "off", ...activeToken ? { githubToken: activeToken } : {} };
-  }
-  const selectedProjectId = await promptSelect(prompts, {
-    message: "GitHub ProjectV2 project",
-    options: [
-      ...projects.map((project) => ({
-        value: String(project.id),
-        label: `${String(project.title ?? "Untitled project")} (#${String(project.number ?? "?")})`,
-        hint: typeof project.url === "string" ? project.url : undefined
-      })),
-      { value: "manual", label: "Enter ProjectV2 id manually" }
-    ]
-  });
-  const projectId = selectedProjectId === "manual" ? await promptRequiredText(prompts, { message: "GitHub ProjectV2 id", placeholder: "PVT_..." }) : selectedProjectId;
-  const fieldPayload = await getGitHubProjectStatusFieldForInit(context, projectId, activeToken).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error) }));
-  const fieldPayloadRecord = fieldPayload && typeof fieldPayload === "object" && !Array.isArray(fieldPayload) ? fieldPayload : {};
-  const rawField = fieldPayloadRecord.field;
-  const field = rawField && typeof rawField === "object" && !Array.isArray(rawField) ? rawField : null;
-  const fieldId = typeof field?.id === "string" && field.id.trim() ? field.id : await promptRequiredText(prompts, { message: "Project Status field id", placeholder: "field_status" });
-  const options = Array.isArray(field?.options) ? field.options.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
-  if (options.length === 0) {
-    return {
-      githubProject: projectId,
-      githubProjectStatusField: fieldId,
-      githubProjectStatuses: await promptManualProjectStatusMapping(prompts),
-      ...activeToken ? { githubToken: activeToken } : {}
-    };
-  }
-  const statuses = {};
-  for (const [key, label] of Object.entries(PROJECT_STATUS_PROMPTS)) {
-    const auto = autoProjectStatusValue(options, key, label);
-    statuses[key] = auto ?? await promptSelect(prompts, {
-      message: `Project status option for ${label}`,
-      options: options.map((option) => ({ value: String(option.id ?? option.name), label: optionName(option) }))
-    });
-  }
-  return {
-    githubProject: projectId,
-    githubProjectStatusField: fieldId,
-    githubProjectStatuses: Object.keys(statuses).length > 0 ? statuses : undefined,
-    ...activeToken ? { githubToken: activeToken } : {}
-  };
-}
-function sleep2(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
-}
-function positiveIntFromEnv(name, fallback) {
-  const value = Number.parseInt(process.env[name] ?? "", 10);
-  return Number.isFinite(value) && value >= 0 ? value : fallback;
-}
-function apiSessionTokenFrom(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 cleanPayloadString(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function remoteGitHubAuthMetadata(payload) {
-  if (!payload)
-    return {};
-  const userNamespace = payload.userNamespace && typeof payload.userNamespace === "object" && !Array.isArray(payload.userNamespace) ? payload.userNamespace : null;
-  return {
-    ...cleanPayloadString(payload.login) ? { login: cleanPayloadString(payload.login) } : {},
-    ...cleanPayloadString(payload.userId) ? { userId: cleanPayloadString(payload.userId) } : {},
-    ...cleanPayloadString(userNamespace?.key) ? { userNamespaceKey: cleanPayloadString(userNamespace?.key) } : {},
-    ...cleanPayloadString(userNamespace?.root) ? { userNamespaceRoot: cleanPayloadString(userNamespace?.root) } : {},
-    ...cleanPayloadString(userNamespace?.checkoutBaseDir) ? { checkoutBaseDir: cleanPayloadString(userNamespace?.checkoutBaseDir) } : {},
-    ...cleanPayloadString(userNamespace?.snapshotBaseDir) ? { snapshotBaseDir: cleanPayloadString(userNamespace?.snapshotBaseDir) } : {}
-  };
-}
-function writeRemoteGitHubAuthState(projectRoot, input) {
-  writeFileSync3(resolve6(projectRoot, ".rig", "state", "github-auth.json"), `${JSON.stringify({
-    authenticated: true,
-    source: input.source,
-    storedOnServer: true,
-    selectedRepo: input.selectedRepo,
-    ...remoteGitHubAuthMetadata(input.authPayload ?? null),
-    ...input.apiSessionToken ? { apiSessionToken: input.apiSessionToken } : {},
-    updatedAt: new Date().toISOString()
-  }, null, 2)}
-`, "utf8");
-}
-async function pollDeviceAuthUntilComplete(context, pollId, firstPayload) {
-  if (typeof pollId !== "string" || !pollId.trim())
-    return null;
-  const intervalSeconds = typeof firstPayload.interval === "number" && Number.isFinite(firstPayload.interval) && firstPayload.interval > 0 ? firstPayload.interval : 5;
-  const timeoutMs = positiveIntFromEnv("RIG_DEVICE_AUTH_POLL_TIMEOUT_MS", 300000);
-  const intervalMs = positiveIntFromEnv("RIG_DEVICE_AUTH_POLL_INTERVAL_MS", Math.max(1000, intervalSeconds * 1000));
-  const deadline = Date.now() + timeoutMs;
-  let last = null;
-  do {
-    const payload = await requestServerJson(context, "/api/github/auth/device/poll", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ pollId })
-    }).catch(() => null);
-    last = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
-    const status = typeof last?.status === "string" ? last.status : null;
-    if (status === "signed-in" || status === "expired" || status === "cancelled" || status === "failed") {
-      return last;
-    }
-    if (timeoutMs <= 0)
-      return last;
-    await sleep2(intervalMs);
-  } while (Date.now() < deadline);
-  return last;
-}
-function runLocalFilesInit(context, options) {
-  const projectRoot = context.projectRoot;
-  ensureRigPrivateDirs(projectRoot);
-  ensureGitignoreEntries(projectRoot);
-  writeRepoConnection(projectRoot, { selected: "local", linkedAt: new Date().toISOString() });
-  const configTsPath = resolve6(projectRoot, "rig.config.ts");
-  const configExists = existsSync5(configTsPath) || existsSync5(resolve6(projectRoot, "rig.config.json"));
-  if (configExists && !options.repair) {
-    if (context.outputMode !== "json")
-      console.log("rig.config already exists; leaving it unchanged. Pass --repair to rewrite it.");
-  } else {
-    const projectName = basename(projectRoot) || "rig-project";
-    writeFileSync3(configTsPath, buildRigInitConfigSource({
-      projectName,
-      taskSource: { kind: "files", path: "tasks" },
-      useStandardPlugin: true
-    }), "utf-8");
-  }
-  ensureRigConfigPackageDependencies(projectRoot);
-  const tasksDir = resolve6(projectRoot, "tasks");
-  if (!existsSync5(tasksDir)) {
-    mkdirSync3(tasksDir, { recursive: true });
-    writeFileSync3(resolve6(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") {
-    console.log("Initialized a local files-source Rig project (no GitHub).");
-    console.log("  tasks live in tasks/*.json \xB7 server: local");
-    console.log("Next: `rig task list`, then `rig task run T-1`.");
-    console.log("To wire GitHub later: `rig init --repair --repo owner/repo --github-auth gh`.");
-  }
-  return { ok: true, group: "init", command: "init", details: { mode: "local-files", projectRoot, taskSourcePath: "tasks" } };
-}
-function runDemoInit(context, options) {
-  const projectRoot = context.projectRoot;
-  ensureRigPrivateDirs(projectRoot);
-  ensureGitignoreEntries(projectRoot);
-  writeRepoConnection(projectRoot, { selected: "local", linkedAt: new Date().toISOString() });
-  const configTsPath = resolve6(projectRoot, "rig.config.ts");
-  const configExists = existsSync5(configTsPath) || existsSync5(resolve6(projectRoot, "rig.config.json"));
-  let configWritten = false;
-  if (configExists && !options.repair) {
-    if (context.outputMode !== "json") {
-      console.log("rig.config already exists; leaving it unchanged. Pass --repair to rewrite it for the demo.");
-    }
-  } else {
-    writeFileSync3(configTsPath, buildRigInitConfigSource({
-      projectName: basename(projectRoot) || "rig-demo",
-      taskSource: { kind: "files", path: DEMO_TASKS_RELATIVE_DIR },
-      useStandardPlugin: true
-    }), "utf-8");
-    configWritten = true;
-  }
-  ensureRigConfigPackageDependencies(projectRoot);
-  const demoTasksDir = resolve6(projectRoot, DEMO_TASKS_RELATIVE_DIR);
-  mkdirSync3(demoTasksDir, { recursive: true });
-  const taskIds = [];
-  for (const task of DEMO_TASKS) {
-    const id = String(task.id);
-    taskIds.push(id);
-    const taskPath = resolve6(demoTasksDir, `${id}.json`);
-    if (!existsSync5(taskPath)) {
-      writeFileSync3(taskPath, `${JSON.stringify(task, null, 2)}
-`, "utf-8");
-    }
-  }
-  if (context.outputMode !== "json") {
-    console.log(`Demo Rig project ready (offline, no GitHub).`);
-    console.log(`  config: rig.config.ts (files task source -> ${DEMO_TASKS_RELATIVE_DIR}/)`);
-    console.log(`  tasks:  ${taskIds.join(", ")}`);
-    console.log("Next steps:");
-    console.log("  1. rig task list");
-    console.log("  2. rig task run --next");
-  }
-  return {
-    ok: true,
-    group: "init",
-    command: "init",
-    details: {
-      mode: "demo",
-      projectRoot,
-      taskSourcePath: DEMO_TASKS_RELATIVE_DIR,
-      demoTasksDir,
-      tasks: taskIds,
-      configWritten
-    }
-  };
-}
-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");
-  if (!detectedSlug) {
-    const authMethod2 = options.githubAuthMethod ?? (options.githubToken ? "token" : "skip");
-    if (serverKind === "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;
-  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 });
-  }
-  writeRepoConnection(projectRoot, {
-    selected: connectionAlias,
-    project: repo.slug,
-    linkedAt: new Date().toISOString()
-  });
-  ensureRigPrivateDirs(projectRoot);
-  ensureGitignoreEntries(projectRoot);
-  const configTsPath = resolve6(projectRoot, "rig.config.ts");
-  const configJsonPath = resolve6(projectRoot, "rig.config.json");
-  const configExists = existsSync5(configTsPath) || existsSync5(configJsonPath);
-  if (!options.privateStateOnly) {
-    if (configExists && !options.repair) {
-      if (context.outputMode !== "json")
-        console.log("rig.config already exists; leaving it unchanged. Pass --repair to rewrite it.");
-    } else {
-      const source = applyGitHubProjectConfig(buildRigInitConfigSource({
-        projectName: repo.slug,
-        projectRepo: repo.slug,
-        taskSource: { kind: "github-issues", owner: repo.owner, repo: repo.repo },
-        useStandardPlugin: true
-      }), options);
-      writeFileSync3(configTsPath, source, "utf-8");
-    }
-    ensureRigConfigPackageDependencies(projectRoot);
-  }
-  writeFileSync3(resolve6(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;
-  if (serverKind === "remote" && options.remoteCheckout?.kind === "uploaded-snapshot") {
-    const archive = await createSnapshotUploadArchive(projectRoot);
-    uploadedSnapshot = await uploadSnapshotArchiveViaServer(context, { repoSlug: repo.slug, archive });
-    const uploadedCheckout = uploadedSnapshot.checkout;
-    if (uploadedCheckout && typeof uploadedCheckout === "object" && !Array.isArray(uploadedCheckout)) {
-      Object.assign(checkout, uploadedCheckout);
-    }
-  }
-  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;
-  if (remoteGhTokenWarning && !options.yes) {
-    throw new CliError(`${remoteGhTokenWarning} Re-run with --yes to confirm this explicit token transfer.`, 1);
-  }
-  const token = authMethod === "gh" && !options.githubToken ? readGhAuthToken() : options.githubToken?.trim();
-  if (token) {
-    githubAuth = await postGitHubTokenViaServer(context, token, { selectedRepo: repo.slug });
-    const apiSessionToken = apiSessionTokenFrom(githubAuth);
-    setGitHubBearerTokenForCurrentProcess(apiSessionToken ?? token, projectRoot);
-    if (serverKind === "remote") {
-      writeRemoteGitHubAuthState(projectRoot, {
-        source: authMethod === "gh" ? "gh" : "init-token",
-        selectedRepo: repo.slug,
-        apiSessionToken,
-        authPayload: githubAuth
-      });
-    }
-  } else if (authMethod === "device") {
-    const payload = await requestServerJson(context, "/api/github/auth/device/start", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ repoSlug: repo.slug })
-    });
-    deviceAuth = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-    if (context.outputMode !== "json") {
-      const verificationUri = String(deviceAuth.verificationUri ?? deviceAuth.verification_uri ?? deviceAuth.verification_uri_complete ?? "the verification URL returned by the server");
-      const userCode = String(deviceAuth.userCode ?? deviceAuth.user_code ?? "the returned user code");
-      console.log(`GitHub device flow: open ${verificationUri} and enter ${userCode}. Waiting for authorization...`);
-    }
-    const completed = await pollDeviceAuthUntilComplete(context, deviceAuth.pollId, deviceAuth);
-    if (completed) {
-      const apiSessionToken = apiSessionTokenFrom(completed);
-      if (apiSessionToken) {
-        setGitHubBearerTokenForCurrentProcess(apiSessionToken, projectRoot);
-        if (serverKind === "remote") {
-          writeRemoteGitHubAuthState(projectRoot, { source: "device", selectedRepo: repo.slug, apiSessionToken, authPayload: completed });
-        }
-      }
-      deviceAuth = { ...deviceAuth, poll: completed, completed: completed.status === "signed-in" };
-    }
-  }
-  let remoteCheckoutPreparation = null;
-  if (serverKind === "remote" && options.remoteCheckout?.kind !== "uploaded-snapshot") {
-    remoteCheckoutPreparation = await prepareRemoteCheckoutViaServer(context, {
-      repoSlug: repo.slug,
-      checkout,
-      repoUrl: `https://github.com/${repo.slug}.git`
-    });
-    const preparedCheckout = remoteCheckoutPreparation.checkout;
-    if (preparedCheckout && typeof preparedCheckout === "object" && !Array.isArray(preparedCheckout)) {
-      Object.assign(checkout, preparedCheckout);
-    }
-  }
-  const checkoutPath = typeof checkout.path === "string" ? checkout.path : null;
-  if (serverKind === "remote" && checkoutPath && token) {
-    githubAuth = await postGitHubTokenViaServer(context, token, { selectedRepo: repo.slug, projectRoot: checkoutPath });
-    const apiSessionToken = apiSessionTokenFrom(githubAuth);
-    setGitHubBearerTokenForCurrentProcess(apiSessionToken ?? token, projectRoot);
-    writeRemoteGitHubAuthState(projectRoot, { source: authMethod === "gh" ? "gh" : "init-token", selectedRepo: repo.slug, apiSessionToken, authPayload: githubAuth });
-  }
-  const registered = await registerProjectViaServer(context, {
-    repoSlug: repo.slug,
-    checkout
-  });
-  const serverRootSwitch = serverKind === "remote" && checkoutPath ? await switchServerProjectRootViaServer(context, checkoutPath) : null;
-  const activeProjectRegistration = serverRootSwitch ? await registerProjectViaServer(context, { repoSlug: repo.slug, checkout }) : null;
-  const labelSetup = await ensureTaskLabelsViaServer(context).catch((error) => ({
-    ok: false,
-    ready: false,
-    labelsReady: false,
-    error: error instanceof Error ? error.message : String(error)
-  }));
-  const pi = serverKind === "remote" ? await ensureRemotePiRigInstalled({ requestJson: (pathname, init) => requestServerJson(context, pathname, init) }).catch((error) => ({
-    remote: true,
-    pi: { ok: false, label: "pi", hint: error instanceof Error ? error.message : String(error) },
-    piRig: { ok: false, label: "pi-rig global extension", hint: "Remote server did not complete pi-rig installation." },
-    extensionPath: "remote:~/.pi/agent/extensions/pi-rig"
-  })) : await ensurePiRigInstalled({ projectRoot, homeDir: process.env.RIG_PI_HOME_DIR }).catch((error) => ({
-    pi: { ok: false, label: "pi", hint: error instanceof Error ? error.message : String(error) },
-    piRig: { ok: false, label: "pi-rig global extension", hint: "Local pi-rig installation failed." },
-    extensionPath: null,
-    installedPath: null
-  }));
-  const doctor = await runRigDoctorChecks({ projectRoot }).then((checks) => ({
-    ok: countDoctorFailures(checks) === 0,
-    failures: countDoctorFailures(checks),
-    checks
-  }));
-  const details = {
-    repoSlug: repo.slug,
-    server: serverKind,
-    connection: connectionAlias,
-    githubProject: options.githubProject ?? "off",
-    checkout,
-    remoteCheckoutPreparation,
-    uploadedSnapshot,
-    projectRegistration: registered,
-    activeProjectRegistration,
-    serverRootSwitch,
-    githubAuth,
-    deviceAuth,
-    githubAuthWarning: remoteGhTokenWarning,
-    labelSetup,
-    pi,
-    doctor
-  };
-  if (context.outputMode === "json")
-    console.log(JSON.stringify(details, null, 2));
-  else
-    console.log(`Initialized Rig control-plane project ${repo.slug}. Next: rig doctor && rig task list`);
-  return { ok: true, group: "init", command: "init", details };
-}
-function parseInitOptions(args) {
-  let rest = [...args];
-  const demo = takeFlag(rest, "--demo");
-  rest = demo.rest;
-  const yes = takeFlag(rest, "--yes");
-  rest = yes.rest;
-  const repair = takeFlag(rest, "--repair");
-  rest = repair.rest;
-  const privateStateOnly = takeFlag(rest, "--private-state-only");
-  rest = privateStateOnly.rest;
-  const server = takeOption(rest, "--server");
-  rest = server.rest;
-  const remoteUrl = takeOption(rest, "--remote-url");
-  rest = remoteUrl.rest;
-  const connectionAlias = takeOption(rest, "--connection");
-  rest = connectionAlias.rest;
-  const repoSlug = takeOption(rest, "--repo");
-  rest = repoSlug.rest;
-  const githubToken = takeOption(rest, "--github-token");
-  rest = githubToken.rest;
-  const githubProject = takeOption(rest, "--github-project");
-  rest = githubProject.rest;
-  const githubProjectStatusField = takeOption(rest, "--github-project-status-field");
-  rest = githubProjectStatusField.rest;
-  const githubAuth = takeOption(rest, "--github-auth");
-  rest = githubAuth.rest;
-  const remoteCheckout = takeOption(rest, "--remote-checkout");
-  rest = remoteCheckout.rest;
-  const existingPath = takeOption(rest, "--existing-path");
-  rest = existingPath.rest;
-  const ref = takeOption(rest, "--ref");
-  rest = ref.rest;
-  const options = {
-    demo: demo.value,
-    yes: yes.value,
-    repair: repair.value,
-    privateStateOnly: privateStateOnly.value,
-    server: server.value === "remote" ? "remote" : server.value === "local" ? "local" : undefined,
-    remoteUrl: remoteUrl.value,
-    connectionAlias: connectionAlias.value,
-    repoSlug: repoSlug.value,
-    githubToken: githubToken.value,
-    githubAuthMethod: githubAuth.value,
-    githubProject: githubProject.value,
-    githubProjectStatusField: githubProjectStatusField.value
-  };
-  if (server.value && options.server === undefined) {
-    throw new CliError("--server must be local or remote.", 1);
-  }
-  if (githubAuth.value && !["gh", "token", "device", "skip"].includes(githubAuth.value)) {
-    throw new CliError("--github-auth must be gh, token, device, or skip.", 1);
-  }
-  if (remoteCheckout.value) {
-    if (remoteCheckout.value === "managed-clone")
-      options.remoteCheckout = { kind: "managed-clone" };
-    else if (remoteCheckout.value === "current-ref")
-      options.remoteCheckout = { kind: "current-ref", ref: ref.value };
-    else if (remoteCheckout.value === "uploaded-snapshot")
-      options.remoteCheckout = { kind: "uploaded-snapshot" };
-    else if (remoteCheckout.value === "existing-path") {
-      if (!existingPath.value)
-        throw new CliError("--remote-checkout existing-path requires --existing-path <path>.", 1);
-      options.remoteCheckout = { kind: "existing-path", path: existingPath.value };
-    } else {
-      throw new CliError("--remote-checkout must be managed-clone, current-ref, uploaded-snapshot, or existing-path.", 1);
-    }
-  }
-  return { options, rest };
-}
-async function runInteractiveControlPlaneInit(context, prompts) {
-  prompts.intro?.("Initialize a Rig control-plane project");
-  const projectRoot = context.projectRoot;
-  const existingConfig = existsSync5(resolve6(projectRoot, "rig.config.ts")) || existsSync5(resolve6(projectRoot, "rig.config.json"));
-  let repair = false;
-  let privateStateOnly = false;
-  if (existingConfig) {
-    const action = await promptSelect(prompts, {
-      message: "rig.config already exists. What should rig init do?",
-      options: [
-        { value: "repair", label: "Verify/repair generated config" },
-        { value: "reconfigure", label: "Reconfigure project and rewrite config" },
-        { value: "private-state-only", label: "Leave config unchanged; update private connection/auth state only" },
-        { value: "cancel", label: "Cancel" }
-      ]
-    });
-    if (action === "cancel") {
-      prompts.cancel?.("Init cancelled.");
-      return { ok: false, group: "init", command: "init", details: { cancelled: true } };
-    }
-    repair = action === "repair" || action === "reconfigure";
-    privateStateOnly = action === "private-state-only";
-  }
-  const detectedRepo = detectOriginRepoSlug(projectRoot) ?? undefined;
-  const repoSlug = await promptRequiredText(prompts, {
-    message: "GitHub repo slug",
-    placeholder: "owner/repo",
-    defaultValue: detectedRepo
-  });
-  const serverChoice = await promptSelect(prompts, {
-    message: "Rig server",
-    initialValue: "remote",
-    options: [
-      { value: "remote", label: "Remote server", hint: "connect to an HTTPS Rig server" },
-      { value: "local", label: "Local server", hint: "run on this machine" }
-    ]
-  });
-  const remoteUrl = serverChoice === "remote" ? await promptRequiredText(prompts, { message: "Remote Rig server URL", placeholder: DEFAULT_REMOTE_RIG_URL, initialValue: DEFAULT_REMOTE_RIG_URL }) : undefined;
-  let remoteCheckout;
-  if (serverChoice === "remote") {
-    const checkout = await promptSelect(prompts, {
-      message: "Remote checkout strategy",
-      options: [
-        { value: "managed-clone", label: "Server-managed clone (recommended)" },
-        { value: "current-ref", label: "Clone current branch/ref" },
-        { value: "uploaded-snapshot", label: "Upload current working-tree snapshot" },
-        { value: "existing-path", label: "Use existing server path" }
-      ]
-    });
-    if (checkout === "existing-path") {
-      remoteCheckout = { kind: "existing-path", path: await promptRequiredText(prompts, { message: "Existing server checkout path", placeholder: "/srv/rig/checkouts/repo" }) };
-    } else if (checkout === "current-ref") {
-      remoteCheckout = { kind: "current-ref", ref: await promptOptionalText(prompts, { message: "Branch/ref to clone (blank for current HEAD)", placeholder: "main" }) || undefined };
-    } else if (checkout === "uploaded-snapshot") {
-      remoteCheckout = { kind: "uploaded-snapshot" };
-    } else {
-      remoteCheckout = { kind: "managed-clone" };
-    }
-  }
-  const detectedGhLogin = detectGhLogin();
-  const authMethod = await promptSelect(prompts, {
-    message: `GitHub auth method${detectedGhLogin ? ` (detected gh login: ${detectedGhLogin})` : ""}`,
-    options: [
-      { value: "gh", label: "Import token from gh auth token", hint: serverChoice === "local" ? "recommended for local" : "sends this machine's token to the remote server" },
-      { value: "device", label: "Start server GitHub device flow", hint: serverChoice === "remote" ? "recommended for remote" : undefined },
-      { value: "token", label: "Paste token" },
-      { value: "skip", label: "Skip for now" }
-    ]
-  });
-  let remoteGhTokenConfirmed = false;
-  if (serverChoice === "remote" && authMethod === "gh") {
-    if (!prompts.confirm)
-      throw new CliError("Remote gh-token import requires explicit confirmation.", 1);
-    const confirmed = await prompts.confirm({
-      message: `This sends a GitHub token from this machine to ${remoteUrl}. Continue?`,
-      initialValue: true
-    });
-    if (prompts.isCancel(confirmed) || confirmed !== true) {
-      throw new CliError("Remote gh-token import cancelled.", 1);
-    }
-    remoteGhTokenConfirmed = true;
-  }
-  const githubToken = authMethod === "token" ? await promptRequiredText(prompts, { message: "GitHub token", placeholder: "ghp_..." }) : authMethod === "gh" ? readGhAuthToken() : undefined;
-  const projectConfig = await promptGitHubProjectConfig(context, prompts, repoSlug, githubToken, authMethod === "gh" ? refreshGhProjectScopesAndReadToken : undefined);
-  const effectiveGithubToken = projectConfig.githubToken ?? githubToken;
-  const result = await runControlPlaneInit(context, {
-    server: serverChoice,
-    remoteUrl,
-    repoSlug,
-    githubToken: effectiveGithubToken,
-    githubAuthMethod: authMethod,
-    githubProject: projectConfig.githubProject,
-    githubProjectStatusField: projectConfig.githubProjectStatusField,
-    githubProjectStatuses: projectConfig.githubProjectStatuses,
-    remoteCheckout,
-    repair,
-    privateStateOnly,
-    yes: remoteGhTokenConfirmed || undefined
-  });
-  const details = result.details && typeof result.details === "object" && !Array.isArray(result.details) ? result.details : {};
-  const deviceAuth = details.deviceAuth && typeof details.deviceAuth === "object" && !Array.isArray(details.deviceAuth) ? details.deviceAuth : null;
-  const deviceMessage = deviceAuth ? ` GitHub device flow: open ${String(deviceAuth.verificationUri ?? deviceAuth.verification_uri ?? deviceAuth.verification_uri_complete ?? "the verification URL returned by the server")} and enter ${String(deviceAuth.userCode ?? deviceAuth.user_code ?? "the returned user code")}.` : "";
-  prompts.outro?.(`Rig project initialized.${deviceMessage} Next: rig doctor && rig task list`);
-  return result;
-}
-async function executeInit(context, args) {
-  const parsed = parseInitOptions(args);
-  if (parsed.options.demo) {
-    if (parsed.rest.length > 0) {
-      throw new CliError(`Unexpected arguments: ${parsed.rest.join(" ")}
-Usage: rig init --demo [--yes] [--repair]`, 1, { hint: "Run `rig init --demo` (optionally with --repair to rewrite an existing rig.config)." });
-    }
-    return runDemoInit(context, parsed.options);
-  }
-  if (parsed.options.yes || parsed.options.server || parsed.options.repoSlug || parsed.options.githubToken || parsed.options.privateStateOnly || parsed.options.repair || parsed.options.githubAuthMethod || parsed.options.remoteCheckout) {
-    if (parsed.rest.length > 0)
-      throw new CliError(`Unexpected arguments: ${parsed.rest.join(" ")}
-Usage: rig init [--demo] [--server local|remote] [--remote-url <url>] [--repo owner/repo] [--github-auth gh|token|device|skip] [--github-token <token>] [--github-project off|<project-id>] [--remote-checkout managed-clone|current-ref|uploaded-snapshot|existing-path] [--yes]`, 1);
-    return runControlPlaneInit(context, parsed.options);
-  }
-  if (parsed.rest.length > 0)
-    throw new CliError(`Unexpected arguments: ${parsed.rest.join(" ")}
-Usage: rig init`, 1);
-  if (!process.stdin.isTTY) {
-    throw new CliError("rig init is interactive and needs a terminal. For scripts, pass flags: rig init --yes --server local --github-auth skip [--repo owner/repo].", 1);
-  }
-  return runInteractiveControlPlaneInit(context, await loadClackPrompts());
-}
-var RIG_CONFIG_PACKAGE_DIST_TAG = "latest", DEFAULT_REMOTE_RIG_URL = "https://where.rig-does.work", RIG_CONFIG_DEV_DEPENDENCIES, DRONE_CANCEL, PROJECT_STATUS_PROMPTS, DEFAULT_PROJECT_STATUS_OPTIONS, DEMO_TASKS_RELATIVE_DIR = ".rig/demo-tasks", DEMO_TASKS;
-var init_init = __esm(() => {
-  init_runner();
-  init__connection_state();
-  init__server_client();
-  init__pi_install();
-  init__snapshot_upload();
-  init__doctor_checks();
-  RIG_CONFIG_DEV_DEPENDENCIES = {
-    "@rig/core": `npm:@h-rig/core@${RIG_CONFIG_PACKAGE_DIST_TAG}`,
-    "@rig/standard-plugin": `npm:@h-rig/standard-plugin@${RIG_CONFIG_PACKAGE_DIST_TAG}`
-  };
-  DRONE_CANCEL = Symbol("drone-cancel");
-  PROJECT_STATUS_PROMPTS = {
-    running: "Running/In progress",
-    prOpen: "PR open/review",
-    ciFixing: "CI/review fixing",
-    merging: "Merging",
-    done: "Done",
-    needsAttention: "Needs attention"
-  };
-  DEFAULT_PROJECT_STATUS_OPTIONS = {
-    running: "In Progress",
-    prOpen: "In Review",
-    ciFixing: "In Review",
-    merging: "Merging",
-    done: "Done",
-    needsAttention: "Needs Attention"
-  };
-  DEMO_TASKS = [
-    {
-      id: "demo-1",
-      title: "Add a hello CLI script",
-      body: [
-        "Create `scripts/hello.ts` that prints `Hello from Rig!` plus the current date,",
-        "and add a `hello` script entry to package.json that runs it with bun.",
-        "Keep it dependency-free."
-      ].join(`
-`),
-      status: "ready",
-      labels: ["demo"]
-    },
-    {
-      id: "demo-2",
-      title: "Write a README section about this project",
-      body: [
-        "Add (or extend) README.md with a short `## What this is` section:",
-        "two or three sentences describing the repository and how to run it.",
-        "Plain prose, no badges."
-      ].join(`
-`),
-      status: "ready",
-      labels: ["demo"]
-    },
-    {
-      id: "demo-3",
-      title: "Add a unit test for the hello script",
-      body: [
-        "Add `scripts/hello.test.ts` with a bun test that imports the greeting",
-        "helper from the hello script and asserts it contains `Hello from Rig!`.",
-        "Refactor the script to export that helper if needed."
-      ].join(`
-`),
-      status: "ready",
-      labels: ["demo"]
-    }
-  ];
-});
-
-// packages/cli/src/app-opentui/adapters/init.ts
-import { existsSync as existsSync6 } from "fs";
-import { resolve as resolve7 } from "path";
-
-// packages/cli/src/app-opentui/adapters/common.ts
-function projectRootOf(ctx) {
-  const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
-  if (typeof root === "string" && root.trim())
-    return root;
-  throw new Error("App adapter requires a projectRoot.");
-}
-async function runtimeOf(ctx) {
-  if (ctx.rig && "runId" in ctx.rig && ctx.ensureRuntime === undefined) {
-    return ctx.rig;
-  }
-  if (ctx.ensureRuntime)
-    return ctx.ensureRuntime();
-  throw new Error("App adapter requires ensureRuntime() before this action can run.");
-}
-function normalizeAppError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  const rawHint = error instanceof Error ? error.hint : undefined;
-  return {
-    message,
-    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {}
-  };
-}
-function emitStarted(ctx, label, optimistic) {
-  ctx.emit({ type: "action.started", label, ...optimistic ? { optimistic } : {} });
-}
-function emitProgress(ctx, label, detail, data) {
-  ctx.emit({ type: "action.progress", label, ...detail ? { detail } : {}, ...data ? { data } : {} });
-}
-function emitCompleted(ctx, label, data) {
-  ctx.emit({ type: "action.completed", label, ...data ? { data } : {} });
-}
-function emitFailed(ctx, label, error, data) {
-  if (data)
-    patchData(ctx, data);
-  const normalized = normalizeAppError(error);
-  ctx.emit({
-    type: "action.failed",
-    label,
-    message: normalized.message,
-    ...normalized.hint ? { hint: normalized.hint } : {},
-    cause: error
-  });
-}
-function patchData(ctx, data) {
-  ctx.emit({ type: "data.patch", data });
-}
-async function captureConsole(fn) {
-  const output = [];
-  const original = {
-    log: console.log,
-    info: console.info,
-    warn: console.warn,
-    error: console.error
-  };
-  const capture = (...parts) => {
-    output.push(parts.map((part) => typeof part === "string" ? part : JSON.stringify(part)).join(" "));
-  };
-  console.log = capture;
-  console.info = capture;
-  console.warn = capture;
-  console.error = capture;
-  try {
-    const result = await fn();
-    return { result, output };
-  } finally {
-    console.log = original.log;
-    console.info = original.info;
-    console.warn = original.warn;
-    console.error = original.error;
-  }
-}
-
-// packages/cli/src/app-opentui/adapters/init.ts
-function readInitFacts(ctx) {
-  const projectRoot = projectRootOf(ctx);
-  const configNames = ["rig.config.ts", "rig.config.mts", "rig.config.json"];
-  const configPath = configNames.map((name) => resolve7(projectRoot, name)).find((path) => existsSync6(path));
-  return {
-    hasConfig: Boolean(configPath),
-    ...configPath ? { configPath } : {},
-    hasGit: existsSync6(resolve7(projectRoot, ".git")),
-    suggestedCommand: configPath ? "doctor" : "init"
-  };
-}
-async function loadInitFacts(ctx) {
-  const label = "Inspecting project";
-  emitStarted(ctx, label);
-  try {
-    const facts = readInitFacts(ctx);
-    patchData(ctx, { init: { facts } });
-    emitCompleted(ctx, label, facts);
-    return facts;
-  } catch (error) {
-    emitFailed(ctx, label, error);
-    throw error;
-  }
-}
-async function runInitYes(ctx, args = ["--yes"]) {
-  const label = "Initializing project";
-  emitStarted(ctx, label, { init: { status: "writing-config" } });
-  try {
-    const runtime = await runtimeOf(ctx);
-    emitProgress(ctx, label, "running existing init side effects without legacy output");
-    const { executeInit: executeInit2 } = await Promise.resolve().then(() => (init_init(), exports_init));
-    const { result, output } = await captureConsole(() => executeInit2({ ...runtime, outputMode: "json" }, [...args]));
-    const record = result && typeof result === "object" && !Array.isArray(result) ? result : { ok: true };
-    patchData(ctx, { init: { status: "done", result: record, capturedOutput: output } });
-    emitCompleted(ctx, label, { result: record });
-    return record;
-  } catch (error) {
-    patchData(ctx, { init: { status: "failed", error: error instanceof Error ? error.message : String(error) } });
-    emitFailed(ctx, label, error);
-    throw error;
-  }
-}
-function buildInitTypeBarSuggestions(facts) {
-  if (facts.hasConfig)
-    return ["doctor", "tasks", "server"];
-  return ["init --yes", "init --server remote", "help init"];
-}
-export {
-  runInitYes,
-  readInitFacts,
-  loadInitFacts,
-  buildInitTypeBarSuggestions
-};