@h-rig/cli 0.0.6-alpha.6 → 0.0.6-alpha.61

package/dist/src/commands/_authority-runs.js

@@ -5,8 +5,7 @@ import { resolve } from "path";
 import {
   readAuthorityRun,
   readJsonlFile,
-  resolveAuthorityRunDir,
-  writeJsonFile
+  writeAuthorityRunRecord
 } from "@rig/runtime/control-plane/authority-files";
 
 // packages/cli/src/commands/_paths.ts
@@ -100,7 +99,7 @@ function upsertAgentAuthorityRun(projectRoot, input) {
   } else if ("errorText" in next) {
     delete next.errorText;
   }
-  writeJsonFile(resolve(resolveAuthorityRunDir(projectRoot, input.runId), "run.json"), next);
+  writeAuthorityRunRecord(projectRoot, input.runId, next);
   return next;
 }
 export {

package/dist/src/commands/_cli-format.js

@@ -0,0 +1,369 @@
+// @bun
+// packages/cli/src/commands/_cli-format.ts
+import { log, note } from "@clack/prompts";
+import pc from "picocolors";
+function stringField(record, key, fallback = "") {
+  const value = record[key];
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function numberField(record, key) {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function arrayField(record, key) {
+  const value = record[key];
+  return Array.isArray(value) ? value.flatMap((entry) => typeof entry === "string" && entry.trim() ? [entry.trim()] : []) : [];
+}
+function rawObject(record) {
+  const raw = record.raw;
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+}
+function truncate(value, width) {
+  if (value.length <= width)
+    return value;
+  if (width <= 1)
+    return "\u2026";
+  return `${value.slice(0, width - 1)}\u2026`;
+}
+function pad(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+function statusColor(status) {
+  const normalized = status.toLowerCase();
+  if (["completed", "merged", "closed", "done", "accepted", "pass", "selected", "approved"].includes(normalized))
+    return pc.green;
+  if (["failed", "needs_attention", "needs-attention", "blocked", "error", "rejected"].includes(normalized))
+    return pc.red;
+  if (["running", "reviewing", "validating", "in_progress", "in-progress", "remote"].includes(normalized))
+    return pc.cyan;
+  if (["ready", "open", "queued", "created", "preparing", "local", "pending"].includes(normalized))
+    return pc.yellow;
+  return pc.dim;
+}
+function compactDate(value) {
+  if (!value.trim())
+    return "";
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed))
+    return value;
+  return new Date(parsed).toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "Z");
+}
+function compactValue(value) {
+  if (value === null || value === undefined)
+    return "";
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (Array.isArray(value))
+    return value.map(compactValue).filter(Boolean).join(", ");
+  return JSON.stringify(value);
+}
+function firstString(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = stringField(record, key);
+    if (value)
+      return value;
+  }
+  return fallback;
+}
+function runIdOf(run) {
+  return firstString(run, ["runId", "id"], "(unknown-run)");
+}
+function taskIdOf(run) {
+  return firstString(run, ["taskId", "task", "task_id"]);
+}
+function runTitleOf(run) {
+  return firstString(run, ["title", "summary", "name"], taskIdOf(run) || "(untitled)");
+}
+function requestIdOf(entry) {
+  return firstString(entry, ["requestId", "id", "approvalId", "inputId"], "(unknown-request)");
+}
+function shouldUseClackOutput() {
+  return Boolean(process.stdout.isTTY) && process.env.RIG_CLI_PLAIN_HELP !== "1";
+}
+function printFormattedOutput(message, options = {}) {
+  if (!shouldUseClackOutput()) {
+    console.log(message);
+    return;
+  }
+  if (options.title)
+    note(message, options.title);
+  else
+    log.message(message);
+}
+function formatStatusPill(status) {
+  const label = status || "unknown";
+  return statusColor(label)(`\u25CF ${label}`);
+}
+function formatSection(title, subtitle) {
+  return `${pc.bold(pc.cyan("\u25C6"))} ${pc.bold(title)}${subtitle ? pc.dim(` \u2014 ${subtitle}`) : ""}`;
+}
+function formatSuccessCard(title, rows = []) {
+  const body = rows.filter(([, value]) => value !== undefined && value !== null && String(value).length > 0).map(([key, value]) => `${pc.dim("\u2502")} ${pc.dim(key.padEnd(12))} ${value}`);
+  return [formatSection(title), ...body].join(`
+`);
+}
+function formatNextSteps(steps) {
+  if (steps.length === 0)
+    return [];
+  return [pc.bold("Next"), ...steps.map((step) => `${pc.dim("\u203A")} ${step}`)];
+}
+function formatTaskList(tasks, options = {}) {
+  if (options.raw)
+    return tasks.map((task) => JSON.stringify(task)).join(`
+`);
+  if (tasks.length === 0)
+    return [formatSection("Tasks", "none found"), ...formatNextSteps(["Try `rig server status` to confirm the selected server.", "Relax filters or run `rig task run --title ... --initial-prompt ...` for ad hoc work."])].join(`
+`);
+  const rows = tasks.map((task) => {
+    const raw = rawObject(task);
+    const id = stringField(task, "id", "<unknown>");
+    const status = stringField(task, "status", "unknown");
+    const title = stringField(task, "title", "Untitled task");
+    const source = stringField(task, "source", stringField(raw, "source", ""));
+    const labels = arrayField(task, "labels").length > 0 ? arrayField(task, "labels") : arrayField(raw, "labels");
+    return { id, status, title, source, labels };
+  });
+  const idWidth = Math.min(18, Math.max(4, ...rows.map((row) => row.id.length)));
+  const statusWidth = Math.min(16, Math.max(6, ...rows.map((row) => row.status.length)));
+  const header = `${pc.bold(pad("TASK", idWidth))}  ${pc.bold(pad("STATUS", statusWidth))}  ${pc.bold("TITLE")}`;
+  const body = rows.map((row) => {
+    const labels = row.labels.length > 0 ? pc.dim(`  ${row.labels.slice(0, 4).map((label) => `#${label}`).join(" ")}`) : "";
+    const source = row.source ? pc.dim(`  ${row.source}`) : "";
+    return [
+      pc.bold(pad(truncate(row.id, idWidth), idWidth)),
+      statusColor(row.status)(pad(truncate(row.status, statusWidth), statusWidth)),
+      `${row.title}${labels}${source}`
+    ].join("  ");
+  });
+  return [formatSection("Tasks", `${rows.length} shown`), header, ...body, "", ...formatNextSteps(["Run one: `rig task run <id>` or `rig task run --next`", "Attach later: `rig run attach <run-id> --follow`"])].join(`
+`);
+}
+function formatTaskCard(task, options = {}) {
+  const raw = rawObject(task);
+  const id = stringField(task, "id", stringField(raw, "id", "<unknown>"));
+  const status = stringField(task, "status", stringField(raw, "status", "unknown"));
+  const title = stringField(task, "title", stringField(raw, "title", "Untitled task"));
+  const source = stringField(task, "source", stringField(raw, "source", ""));
+  const url = stringField(task, "url", stringField(raw, "url", ""));
+  const number = numberField(task, "number") ?? numberField(raw, "number");
+  const labels = arrayField(task, "labels").length > 0 ? arrayField(task, "labels") : arrayField(raw, "labels");
+  const assignees = arrayField(task, "assignees").length > 0 ? arrayField(task, "assignees") : arrayField(raw, "assignees");
+  const readiness = compactValue(task.readiness ?? raw.readiness);
+  const validators = compactValue(task.validators ?? raw.validators ?? task.validation ?? raw.validation);
+  const rows = [
+    ["task", pc.bold(id)],
+    ["status", formatStatusPill(status)],
+    ["title", title],
+    ["source", source],
+    ["number", number],
+    ["labels", labels.length ? labels.map((label) => `#${label}`).join(" ") : ""],
+    ["assignees", assignees.join(", ")],
+    ["readiness", readiness],
+    ["validators", validators],
+    ["url", url]
+  ];
+  return [
+    formatSuccessCard(options.title ?? (options.selected ? "Selected task" : "Task"), rows),
+    "",
+    ...formatNextSteps([`Start: \`rig task run ${id}\``, `Details: \`rig task show ${id} --raw\``])
+  ].join(`
+`);
+}
+function formatTaskDetails(task) {
+  return formatTaskCard(task, { title: "Task details" });
+}
+function formatRunList(runs, options = {}) {
+  if (runs.length === 0) {
+    return [
+      formatSection("Runs", "none recorded"),
+      options.source === "server" ? pc.dim("No runs recorded on the selected Rig server.") : pc.dim("No runs recorded in .rig/runs."),
+      "",
+      ...formatNextSteps(["Start one: `rig task run --next`", "Check server: `rig server status`"])
+    ].join(`
+`);
+  }
+  const rows = runs.map((run) => {
+    const runId = stringField(run, "runId", stringField(run, "id", "(unknown-run)"));
+    const status = stringField(run, "status", "unknown");
+    const taskId = stringField(run, "taskId", "");
+    const title = stringField(run, "title", taskId || "(untitled)");
+    const runtime = stringField(run, "runtimeAdapter", "");
+    return { runId, status, title, runtime };
+  });
+  const idWidth = Math.min(36, Math.max(6, ...rows.map((row) => row.runId.length)));
+  const statusWidth = Math.min(16, Math.max(6, ...rows.map((row) => row.status.length)));
+  const header = `${pc.bold(pad("RUN", idWidth))}  ${pc.bold(pad("STATUS", statusWidth))}  ${pc.bold("TITLE")}`;
+  const body = rows.map((row) => [
+    pc.bold(pad(truncate(row.runId, idWidth), idWidth)),
+    statusColor(row.status)(pad(truncate(row.status, statusWidth), statusWidth)),
+    `${row.title}${row.runtime ? pc.dim(`  ${row.runtime}`) : ""}`
+  ].join("  "));
+  return [formatSection("Runs", options.source === "server" ? "selected server" : "local state"), header, ...body, "", ...formatNextSteps(["Follow live: `rig run attach <run-id> --follow`", "Details: `rig run show <run-id>`"])].join(`
+`);
+}
+function formatSubmittedRun(input) {
+  const rows = [["run", pc.bold(input.runId)]];
+  if (input.task) {
+    const id = stringField(input.task, "id", "<unknown>");
+    const status = stringField(input.task, "status", "unknown");
+    const title = stringField(input.task, "title", "Untitled task");
+    rows.push(["task", `${pc.bold(id)} ${formatStatusPill(status)} ${title}`]);
+  }
+  const runtime = [input.runtimeAdapter || "pi", input.runtimeMode || "full-access", input.interactionMode || "default"].filter(Boolean).join(" \xB7 ");
+  rows.push(["runtime", runtime]);
+  return [
+    formatSuccessCard("Run submitted", rows),
+    "",
+    ...formatNextSteps([
+      `Attach: \`rig run attach ${input.runId} --follow\``,
+      `Inspect: \`rig run show ${input.runId}\``,
+      input.detached ? "Submitted detached; attach when you are ready." : "Interactive mode opens the enriched bundled Pi (native UI + Rig layers, worker brain)."
+    ])
+  ].join(`
+`);
+}
+function formatRunCard(run, options = {}) {
+  const raw = rawObject(run);
+  const merged = { ...raw, ...run };
+  const runId = runIdOf(merged);
+  const status = firstString(merged, ["status"], "unknown");
+  const taskId = taskIdOf(merged);
+  const title = runTitleOf(merged);
+  const runtime = firstString(merged, ["runtimeAdapter", "runtime", "adapter"]);
+  const mode = firstString(merged, ["runtimeMode", "mode"]);
+  const interaction = firstString(merged, ["interactionMode"]);
+  const created = compactDate(firstString(merged, ["createdAt"]));
+  const started = compactDate(firstString(merged, ["startedAt"]));
+  const updated = compactDate(firstString(merged, ["updatedAt"]));
+  const completed = compactDate(firstString(merged, ["completedAt", "finishedAt"]));
+  const worktree = firstString(merged, ["worktreePath", "cwd", "projectRoot"]);
+  const piSession = merged.piSession && typeof merged.piSession === "object" && !Array.isArray(merged.piSession) ? firstString(merged.piSession, ["sessionId", "id"]) : "";
+  const timeline = Array.isArray(merged.timeline) ? merged.timeline.length : null;
+  const approvals = Array.isArray(merged.approvals) ? merged.approvals.length : null;
+  const inputs = Array.isArray(merged.userInputs) ? merged.userInputs.length : null;
+  const rows = [
+    ["run", pc.bold(runId)],
+    ["status", formatStatusPill(status)],
+    ["task", taskId],
+    ["title", title],
+    ["runtime", [runtime, mode, interaction].filter(Boolean).join(" \xB7 ")],
+    ["created", created],
+    ["started", started],
+    ["updated", updated],
+    ["completed", completed],
+    ["worktree", worktree],
+    ["pi", piSession],
+    ["timeline", timeline],
+    ["approvals", approvals],
+    ["inputs", inputs]
+  ];
+  return [
+    formatSuccessCard(options.title ?? "Run details", rows),
+    "",
+    ...formatNextSteps([`Follow live: \`rig run attach ${runId} --follow\``, `Raw payload: \`rig run show ${runId} --raw\``])
+  ].join(`
+`);
+}
+function formatRunStatus(summary, options = {}) {
+  const activeRuns = summary.activeRuns ?? [];
+  const recentRuns = summary.recentRuns ?? [];
+  const lines = [formatSection("Run status", options.source === "server" ? "selected server" : "local state")];
+  lines.push("", pc.bold(`Active runs (${activeRuns.length})`));
+  if (activeRuns.length === 0) {
+    lines.push(pc.dim("No active runs."));
+  } else {
+    for (const run of activeRuns) {
+      lines.push(formatRunSummaryLine(run));
+    }
+  }
+  lines.push("", pc.bold(`Recent runs (${recentRuns.length})`));
+  if (recentRuns.length === 0) {
+    lines.push(pc.dim("No recent terminal runs."));
+  } else {
+    for (const run of recentRuns.slice(0, 10)) {
+      lines.push(formatRunSummaryLine(run));
+    }
+  }
+  lines.push("", ...formatNextSteps(["Start work: `rig task run --next`", "Attach: `rig run attach <run-id> --follow`", "Details: `rig run show <run-id>`"]));
+  return lines.join(`
+`);
+}
+function formatRunSummaryLine(run) {
+  const record = run;
+  const runId = runIdOf(record);
+  const status = firstString(record, ["status"], "unknown");
+  const taskId = taskIdOf(record);
+  const title = runTitleOf(record);
+  const runtime = firstString(record, ["runtimeAdapter", "runtime", "adapter"]);
+  const descriptor = [taskId, title].filter(Boolean).join(" \xB7 ");
+  return `${pc.dim("\u2502")} ${pc.bold(runId)} ${formatStatusPill(status)} ${descriptor}${runtime ? pc.dim(`  ${runtime}`) : ""}`;
+}
+function formatInboxList(kind, entries) {
+  const title = kind === "approvals" ? "Approval inbox" : "Input inbox";
+  if (entries.length === 0) {
+    return [
+      formatSection(title, "empty"),
+      pc.dim(kind === "approvals" ? "No pending approvals." : "No pending user-input requests."),
+      "",
+      ...formatNextSteps(["Check runs: `rig run status`", "Start work: `rig task run --next`"])
+    ].join(`
+`);
+  }
+  const lines = [formatSection(title, `${entries.length} pending`)];
+  for (const entry of entries) {
+    const record = entry.record && typeof entry.record === "object" && !Array.isArray(entry.record) ? entry.record : entry;
+    const runId = firstString(entry, ["runId"], firstString(record, ["runId"]));
+    const taskId = firstString(entry, ["taskId"], firstString(record, ["taskId", "task"]));
+    const requestId = requestIdOf(record);
+    const status = firstString(record, ["status", "state"], "pending");
+    const prompt = firstString(record, ["prompt", "message", "reason", "title", "summary"], kind === "approvals" ? "Approval requested" : "Input requested");
+    lines.push(`${pc.dim("\u2502")} ${pc.bold(requestId)} ${formatStatusPill(status)} ${prompt}`);
+    lines.push(`${pc.dim("\u2502")} ${pc.dim("run      ")} ${runId || "(unknown-run)"}${taskId ? pc.dim(`  task ${taskId}`) : ""}`);
+  }
+  lines.push("", ...formatNextSteps(kind === "approvals" ? ["Resolve: `rig inbox approve --run <run-id> --request <request-id> --decision approve|reject`", "Rejoin: `rig run attach <run-id> --follow`"] : ["Respond: `rig inbox respond --run <run-id> --request <request-id> --answer key=value`", "Rejoin: `rig run attach <run-id> --follow`"]));
+  return lines.join(`
+`);
+}
+function formatConnectionList(connections) {
+  const rows = [["local", { kind: "local", mode: "auto" }], ...Object.entries(connections)];
+  const aliasWidth = Math.min(24, Math.max(5, ...rows.map(([alias]) => alias.length)));
+  const lines = rows.map(([alias, connection]) => [
+    pc.bold(pad(truncate(alias, aliasWidth), aliasWidth)),
+    formatStatusPill(connection.kind),
+    connection.kind === "remote" ? connection.baseUrl ?? "" : connection.mode ?? "local"
+  ].join("  "));
+  return [formatSection("Rig servers", `${rows.length} available`), `${pc.bold(pad("ALIAS", aliasWidth))}  ${pc.bold("KIND")}  ${pc.bold("TARGET")}`, ...lines, "", ...formatNextSteps(["Select one: `rig server use <alias|local>`"])].join(`
+`);
+}
+function formatConnectionStatus(selected, connections) {
+  const connection = selected === "local" ? { kind: "local", mode: "auto" } : connections[selected];
+  const target = !connection ? "not configured" : connection.kind === "remote" ? connection.baseUrl : "local";
+  return [
+    formatSection("Rig server", "selected for this repo"),
+    `${pc.dim("\u2502")} ${pc.dim("selected ")} ${pc.bold(selected)}`,
+    `${pc.dim("\u2502")} ${pc.dim("kind     ")} ${formatStatusPill(connection?.kind ?? "unknown")}`,
+    `${pc.dim("\u2502")} ${pc.dim("target   ")} ${target ?? "not configured"}`,
+    "",
+    ...formatNextSteps(["Change: `rig server use <alias|local>`", "List saved servers: `rig server list`"])
+  ].join(`
+`);
+}
+export {
+  printFormattedOutput,
+  formatTaskList,
+  formatTaskDetails,
+  formatTaskCard,
+  formatSuccessCard,
+  formatSubmittedRun,
+  formatStatusPill,
+  formatSection,
+  formatRunStatus,
+  formatRunList,
+  formatRunCard,
+  formatNextSteps,
+  formatInboxList,
+  formatConnectionStatus,
+  formatConnectionList
+};

package/dist/src/commands/_connection-state.js

@@ -8,8 +8,6 @@ import { dirname, resolve } from "path";
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
 import { CliError } from "@rig/runtime/control-plane/errors";
 import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
-import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
-import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
 import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
 import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
 
@@ -92,7 +90,8 @@ function readRepoConnection(projectRoot) {
   return {
     selected,
     project: typeof record.project === "string" ? record.project : undefined,
-    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined
+    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
+    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined
   };
 }
 function writeRepoConnection(projectRoot, state) {
@@ -103,15 +102,22 @@ function resolveSelectedConnection(projectRoot, options = {}) {
   if (!repo)
     return null;
   if (repo.selected === "local")
-    return { alias: "local", connection: { kind: "local", mode: "auto" } };
+    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 CliError2(`Selected Rig connection "${repo.selected}" was not found. Run \`rig connect list\` or \`rig connect use local\`.`, 1);
+    throw new CliError2(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
   }
-  return { alias: repo.selected, connection };
+  return { alias: repo.selected, connection, serverProjectRoot: repo.serverProjectRoot };
+}
+function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return;
+  writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
 }
 export {
+  writeRepoServerProjectRoot,
   writeRepoConnection,
   writeGlobalConnections,
   upsertGlobalConnection,

package/dist/src/commands/_doctor-checks.js

@@ -9,8 +9,6 @@ import { resolve as resolve4 } from "path";
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
 import { CliError } from "@rig/runtime/control-plane/errors";
 import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
-import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
-import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
 import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
 import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
 
@@ -42,6 +40,11 @@ function readJsonFile(path) {
     throw new CliError2(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1);
   }
 }
+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;
@@ -82,29 +85,38 @@ function readRepoConnection(projectRoot) {
   return {
     selected,
     project: typeof record.project === "string" ? record.project : undefined,
-    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined
+    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
+    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined
   };
 }
+function writeRepoConnection(projectRoot, state) {
+  writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
+}
 function resolveSelectedConnection(projectRoot, options = {}) {
   const repo = readRepoConnection(projectRoot);
   if (!repo)
     return null;
   if (repo.selected === "local")
-    return { alias: "local", connection: { kind: "local", mode: "auto" } };
+    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 CliError2(`Selected Rig connection "${repo.selected}" was not found. Run \`rig connect list\` or \`rig connect use local\`.`, 1);
+    throw new CliError2(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
   }
-  return { alias: repo.selected, connection };
+  return { alias: repo.selected, connection, serverProjectRoot: repo.serverProjectRoot };
+}
+function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return;
+  writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
 }
 
 // packages/cli/src/commands/_server-client.ts
-import { spawnSync } from "child_process";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { resolve as resolve2 } from "path";
 import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
-var cachedGitHubBearerToken;
+var scopedGitHubBearerTokens = new Map;
 function cleanToken(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
@@ -121,41 +133,47 @@ function readPrivateRemoteSessionToken(projectRoot) {
   }
 }
 function readGitHubBearerTokenForRemote(projectRoot) {
-  if (cachedGitHubBearerToken !== undefined)
-    return cachedGitHubBearerToken;
+  const scopedKey = resolve2(projectRoot);
+  if (scopedGitHubBearerTokens.has(scopedKey))
+    return scopedGitHubBearerTokens.get(scopedKey) ?? null;
   const privateSession = readPrivateRemoteSessionToken(projectRoot);
-  if (privateSession) {
-    cachedGitHubBearerToken = privateSession;
-    return cachedGitHubBearerToken;
-  }
-  const envToken = cleanToken(process.env.RIG_GITHUB_TOKEN) ?? cleanToken(process.env.GITHUB_TOKEN) ?? cleanToken(process.env.GH_TOKEN);
-  if (envToken) {
-    cachedGitHubBearerToken = envToken;
-    return cachedGitHubBearerToken;
+  if (privateSession)
+    return privateSession;
+  return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
+}
+function readStoredGitHubAuthToken(projectRoot) {
+  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
+  if (!existsSync2(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return cleanToken(typeof parsed.token === "string" ? parsed.token : undefined);
+  } catch {
+    return null;
   }
-  const result = spawnSync("gh", ["auth", "token"], {
-    encoding: "utf8",
-    timeout: 5000,
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  cachedGitHubBearerToken = result.status === 0 ? cleanToken(result.stdout) : null;
-  return cachedGitHubBearerToken;
+}
+function readLocalConnectionFallbackToken(projectRoot) {
+  return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
 }
 async function ensureServerForCli(projectRoot) {
   try {
     const selected = resolveSelectedConnection(projectRoot);
     if (selected?.connection.kind === "remote") {
+      const authToken = readGitHubBearerTokenForRemote(projectRoot);
+      const serverProjectRoot = selected.serverProjectRoot ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
       return {
         baseUrl: selected.connection.baseUrl,
-        authToken: readGitHubBearerTokenForRemote(projectRoot),
-        connectionKind: "remote"
+        authToken,
+        connectionKind: "remote",
+        serverProjectRoot
       };
     }
     const connection = await ensureLocalRigServerConnection(projectRoot);
     return {
       baseUrl: connection.baseUrl,
-      authToken: connection.authToken,
-      connectionKind: "local"
+      authToken: connection.authToken ?? readLocalConnectionFallbackToken(projectRoot),
+      connectionKind: "local",
+      serverProjectRoot: resolve2(projectRoot)
     };
   } catch (error) {
     if (error instanceof Error) {
@@ -164,6 +182,29 @@ async function ensureServerForCli(projectRoot) {
     throw error;
   }
 }
+async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken) {
+  const repo = readRepoConnection(projectRoot);
+  const slug = repo?.project?.trim();
+  if (!slug)
+    return null;
+  try {
+    const response = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`, {
+      headers: mergeHeaders(undefined, authToken)
+    });
+    if (!response.ok)
+      return null;
+    const payload = await response.json();
+    const project = payload.project && typeof payload.project === "object" && !Array.isArray(payload.project) ? payload.project : null;
+    const checkouts = Array.isArray(project?.checkouts) ? project.checkouts : [];
+    const latestCheckout = [...checkouts].reverse().find((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.path === "string"));
+    const path = typeof latestCheckout?.path === "string" && latestCheckout.path.trim() ? latestCheckout.path.trim() : null;
+    if (path)
+      writeRepoServerProjectRoot(projectRoot, path);
+    return path;
+  } catch {
+    return null;
+  }
+}
 function mergeHeaders(headers, authToken) {
   const merged = new Headers(headers);
   if (authToken) {
@@ -188,9 +229,12 @@ function diagnosticMessage(payload) {
 }
 async function requestServerJson(context, pathname, init = {}) {
   const server = await ensureServerForCli(context.projectRoot);
+  const headers = mergeHeaders(init.headers, server.authToken);
+  if (server.serverProjectRoot)
+    headers.set("x-rig-project-root", server.serverProjectRoot);
   const response = await fetch(`${server.baseUrl}${pathname}`, {
     ...init,
-    headers: mergeHeaders(init.headers, server.authToken)
+    headers
   });
   const text = await response.text();
   const payload = text.trim().length > 0 ? (() => {
@@ -222,7 +266,8 @@ async function loadRigConfigOrNull(projectRoot) {
 import { existsSync as existsSync3, readFileSync as readFileSync3, rmSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { resolve as resolve3 } from "path";
-var PI_RIG_PACKAGE_NAME = "@rig/pi-rig";
+var PI_RIG_PACKAGE_NAME = "@h-rig/pi-rig";
+var LEGACY_PI_RIG_PACKAGE_NAME = "@rig/pi-rig";
 async function defaultCommandRunner(command, options = {}) {
   const proc = Bun.spawn(command, { cwd: options.cwd, stdout: "pipe", stderr: "pipe" });
   const [stdout, stderr, exitCode] = await Promise.all([
@@ -241,7 +286,7 @@ function resolvePiHomeDir(inputHomeDir) {
 function piListContainsPiRig(output) {
   return output.split(/\r?\n/).some((line) => {
     const normalized = line.trim();
-    return normalized.includes(PI_RIG_PACKAGE_NAME) || /(?:^|[\\/])packages[\\/]pi-rig(?:$|\s)/.test(normalized);
+    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) {
@@ -417,7 +462,7 @@ async function runRigDoctorChecks(options) {
   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 connection", 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 connection", "fail", "missing .rig/state/connection.json", "Run `rig init` or `rig connect use <alias|local>`."));
+  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);
@@ -425,7 +470,7 @@ async function runRigDoctorChecks(options) {
       return null;
     }
   })();
-  checks.push(selected ? check("connection", "selected server connection", "pass", selected.connection.kind === "remote" ? selected.connection.baseUrl : "local auto") : check("connection", "selected server connection", repo ? "fail" : "warn", repo ? "selected alias is missing" : "will auto-start local server", repo ? "Run `rig connect list` and `rig connect use <alias|local>`." : undefined));
+  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 {
     server = await (options.resolveServer ?? ensureServerForCli)(projectRoot);