@h-rig/cli 0.0.6-alpha.27 → 0.0.6-alpha.28

package/dist/src/commands/doctor.js

@@ -98,7 +98,7 @@ function resolveSelectedConnection(projectRoot, options = {}) {
   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 };
 }
@@ -409,7 +409,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);
@@ -417,7 +417,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);

package/dist/src/commands/github.js

@@ -113,7 +113,7 @@ function resolveSelectedConnection(projectRoot, options = {}) {
   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 };
 }

package/dist/src/commands/inbox.js

@@ -1,7 +1,7 @@
 // @bun
 // packages/cli/src/commands/inbox.ts
-import { writeFileSync } from "fs";
-import { resolve } from "path";
+import { writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
 
 // packages/cli/src/runner.ts
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
@@ -44,6 +44,334 @@ import {
   readJsonlFile,
   resolveAuthorityRunDir
 } from "@rig/runtime/control-plane/authority-files";
+
+// 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 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 firstString(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = stringField(record, key);
+    if (value)
+      return value;
+  }
+  return fallback;
+}
+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 formatNextSteps(steps) {
+  if (steps.length === 0)
+    return [];
+  return [pc.bold("Next"), ...steps.map((step) => `${pc.dim("\u203A")} ${step}`)];
+}
+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(`
+`);
+}
+
+// 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 CliError2(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1);
+  }
+}
+function normalizeConnection(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = value;
+  if (record.kind === "local")
+    return { kind: "local", mode: "auto" };
+  if (record.kind === "remote" && typeof record.baseUrl === "string" && record.baseUrl.trim()) {
+    const baseUrl = record.baseUrl.trim().replace(/\/+$/, "");
+    return { kind: "remote", baseUrl };
+  }
+  return null;
+}
+function readGlobalConnections(options = {}) {
+  const path = resolveGlobalConnectionsPath(options.env ?? process.env);
+  const payload = readJsonFile(path);
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return { connections: {} };
+  }
+  const rawConnections = payload.connections;
+  const connections = {};
+  if (rawConnections && typeof rawConnections === "object" && !Array.isArray(rawConnections)) {
+    for (const [alias, raw] of Object.entries(rawConnections)) {
+      const connection = normalizeConnection(raw);
+      if (connection)
+        connections[alias] = connection;
+    }
+  }
+  return { connections };
+}
+function readRepoConnection(projectRoot) {
+  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
+  if (!selected)
+    return null;
+  return {
+    selected,
+    project: typeof record.project === "string" ? record.project : undefined,
+    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined
+  };
+}
+function resolveSelectedConnection(projectRoot, options = {}) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return null;
+  if (repo.selected === "local")
+    return { alias: "local", connection: { kind: "local", mode: "auto" } };
+  const global = readGlobalConnections(options);
+  const connection = global.connections[repo.selected];
+  if (!connection) {
+    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 };
+}
+
+// packages/cli/src/commands/_server-client.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+var scopedGitHubBearerTokens = new Map;
+function cleanToken(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function readPrivateRemoteSessionToken(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.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined);
+  } catch {
+    return 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);
+}
+async function ensureServerForCli(projectRoot) {
+  try {
+    const selected = resolveSelectedConnection(projectRoot);
+    if (selected?.connection.kind === "remote") {
+      return {
+        baseUrl: selected.connection.baseUrl,
+        authToken: readGitHubBearerTokenForRemote(projectRoot),
+        connectionKind: "remote"
+      };
+    }
+    const connection = await ensureLocalRigServerConnection(projectRoot);
+    return {
+      baseUrl: connection.baseUrl,
+      authToken: connection.authToken,
+      connectionKind: "local"
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new CliError2(error.message, 1);
+    }
+    throw error;
+  }
+}
+function mergeHeaders(headers, authToken) {
+  const merged = new Headers(headers);
+  if (authToken) {
+    merged.set("authorization", `Bearer ${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 requestServerJson(context, pathname, init = {}) {
+  const server = await ensureServerForCli(context.projectRoot);
+  const response = await fetch(`${server.baseUrl}${pathname}`, {
+    ...init,
+    headers: mergeHeaders(init.headers, server.authToken)
+  });
+  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 detail = diagnostics ?? (text || response.statusText);
+    throw new CliError2(`Rig server request failed (${response.status}): ${detail}`, 1);
+  }
+  return payload;
+}
+async function listRunsViaServer(context, options = {}) {
+  const url = new URL("http://rig.local/api/runs");
+  if (options.limit !== undefined)
+    url.searchParams.set("limit", String(options.limit));
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  const runs = Array.isArray(payload) ? payload : payload && typeof payload === "object" && !Array.isArray(payload) && Array.isArray(payload.runs) ? payload.runs : [];
+  return runs.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+}
+async function getRunDetailsViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+
+// packages/cli/src/commands/inbox.ts
+function isRemoteConnectionSelected(projectRoot) {
+  return resolveSelectedConnection(projectRoot)?.connection.kind === "remote";
+}
+function runMatches(entry, filters) {
+  const runId = typeof entry.runId === "string" ? entry.runId : typeof entry.id === "string" ? entry.id : "";
+  const taskId = typeof entry.taskId === "string" ? entry.taskId : "";
+  return (!filters.run || runId === filters.run) && (!filters.task || taskId === filters.task);
+}
+function normalizeRemoteRunDetails(payload) {
+  const run = payload.run;
+  if (run && typeof run === "object" && !Array.isArray(run)) {
+    return {
+      ...run,
+      ...Array.isArray(payload.timeline) ? { timeline: payload.timeline } : {},
+      ...Array.isArray(payload.approvals) ? { approvals: payload.approvals } : {},
+      ...Array.isArray(payload.userInputs) ? { userInputs: payload.userInputs } : {}
+    };
+  }
+  return payload;
+}
+function remoteRecordsFromRun(run, kind) {
+  const key = kind === "approvals" ? "approvals" : "userInputs";
+  const direct = run[key];
+  if (!Array.isArray(direct))
+    return [];
+  const runId = typeof run.runId === "string" ? run.runId : typeof run.id === "string" ? run.id : "";
+  const taskId = typeof run.taskId === "string" ? run.taskId : "";
+  return direct.filter((record) => Boolean(record && typeof record === "object" && !Array.isArray(record))).map((record) => ({ runId, taskId, record }));
+}
+async function listRemoteInboxRecords(context, kind, filters) {
+  const runs = (await listRunsViaServer(context, { limit: 100 })).filter((entry) => runMatches(entry, filters));
+  const records = [];
+  for (const run of runs) {
+    const runId = typeof run.runId === "string" ? run.runId : typeof run.id === "string" ? run.id : "";
+    const detailed = runId ? normalizeRemoteRunDetails(await getRunDetailsViaServer(context, runId).catch(() => run)) : run;
+    records.push(...remoteRecordsFromRun(detailed, kind));
+  }
+  return records;
+}
+function listLocalInboxRecords(context, kind, filters) {
+  const fileName = kind === "approvals" ? "approvals.jsonl" : "user-input.jsonl";
+  const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!filters.run || entry.runId === filters.run) && (!filters.task || entry.taskId === filters.task));
+  return runs.flatMap((entry) => readJsonlFile(resolve3(resolveAuthorityRunDir(context.projectRoot, entry.runId), fileName)).map((record) => ({
+    runId: entry.runId,
+    taskId: entry.taskId ?? undefined,
+    record
+  })));
+}
+async function listInboxRecords(context, kind, filters) {
+  if (isRemoteConnectionSelected(context.projectRoot)) {
+    return listRemoteInboxRecords(context, kind, filters);
+  }
+  return listLocalInboxRecords(context, kind, filters);
+}
 async function executeInbox(context, args) {
   const [command = "approvals", ...rest] = args;
   switch (command) {
@@ -53,16 +381,10 @@ async function executeInbox(context, args) {
       pending = run.rest;
       const task = takeOption(pending, "--task");
       pending = task.rest;
-      requireNoExtraArgs(pending, "bun run rig inbox approvals [--run <id>] [--task <id>]");
-      const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!run.value || entry.runId === run.value) && (!task.value || entry.taskId === task.value));
-      const approvals = runs.flatMap((entry) => readJsonlFile(resolve(resolveAuthorityRunDir(context.projectRoot, entry.runId), "approvals.jsonl")).map((record) => ({
-        runId: entry.runId,
-        record
-      })));
+      requireNoExtraArgs(pending, "rig inbox approvals [--run <id>] [--task <id>]");
+      const approvals = await listInboxRecords(context, "approvals", { run: run.value, task: task.value });
       if (context.outputMode === "text") {
-        for (const approval of approvals) {
-          console.log(JSON.stringify(approval));
-        }
+        printFormattedOutput(formatInboxList("approvals", approvals));
       }
       return { ok: true, group: "inbox", command, details: { approvals } };
     }
@@ -74,20 +396,23 @@ async function executeInbox(context, args) {
       pending = request.rest;
       const decision = takeOption(pending, "--decision");
       pending = decision.rest;
-      const note = takeOption(pending, "--note");
-      pending = note.rest;
-      requireNoExtraArgs(pending, "bun run rig inbox approve --run <id> --request <id> --decision approve|reject [--note <text>]");
+      const note2 = takeOption(pending, "--note");
+      pending = note2.rest;
+      requireNoExtraArgs(pending, "rig inbox approve --run <id> --request <id> --decision approve|reject [--note <text>]");
       if (!run.value || !request.value || !decision.value) {
         throw new CliError2("approve requires --run, --request, and --decision.");
       }
       if (decision.value !== "approve" && decision.value !== "reject") {
         throw new CliError2("decision must be approve or reject.");
       }
-      const approvalsPath = resolve(resolveAuthorityRunDir(context.projectRoot, run.value), "approvals.jsonl");
+      if (isRemoteConnectionSelected(context.projectRoot)) {
+        throw new CliError2("Remote approval resolution is not available from this CLI yet; use the server UI/API or switch to local state for direct JSONL edits.", 2);
+      }
+      const approvalsPath = resolve3(resolveAuthorityRunDir(context.projectRoot, run.value), "approvals.jsonl");
       const approvals = readJsonlFile(approvalsPath);
       const resolvedAt = new Date().toISOString();
-      const next = approvals.map((entry) => entry.requestId === request.value || entry.id === request.value ? { ...entry, status: "resolved", decision: decision.value, note: note.value ?? null, resolvedAt } : entry);
-      writeFileSync(approvalsPath, `${next.map((entry) => JSON.stringify(entry)).join(`
+      const next = approvals.map((entry) => entry.requestId === request.value || entry.id === request.value ? { ...entry, status: "resolved", decision: decision.value, note: note2.value ?? null, resolvedAt } : entry);
+      writeFileSync2(approvalsPath, `${next.map((entry) => JSON.stringify(entry)).join(`
 `)}
 `, "utf8");
       return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, decision: decision.value } };
@@ -98,16 +423,10 @@ async function executeInbox(context, args) {
       pending = run.rest;
       const task = takeOption(pending, "--task");
       pending = task.rest;
-      requireNoExtraArgs(pending, "bun run rig inbox inputs [--run <id>] [--task <id>]");
-      const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!run.value || entry.runId === run.value) && (!task.value || entry.taskId === task.value));
-      const requests = runs.flatMap((entry) => readJsonlFile(resolve(resolveAuthorityRunDir(context.projectRoot, entry.runId), "user-input.jsonl")).map((record) => ({
-        runId: entry.runId,
-        record
-      })));
+      requireNoExtraArgs(pending, "rig inbox inputs [--run <id>] [--task <id>]");
+      const requests = await listInboxRecords(context, "inputs", { run: run.value, task: task.value });
       if (context.outputMode === "text") {
-        for (const request of requests) {
-          console.log(JSON.stringify(request));
-        }
+        printFormattedOutput(formatInboxList("inputs", requests));
       }
       return { ok: true, group: "inbox", command, details: { requests } };
     }
@@ -134,19 +453,22 @@ async function executeInbox(context, args) {
           remaining.push(current);
         }
       }
-      requireNoExtraArgs(remaining, "bun run rig inbox respond --run <id> --request <id> --answer key=value [--answer key=value]");
+      requireNoExtraArgs(remaining, "rig inbox respond --run <id> --request <id> --answer key=value [--answer key=value]");
       if (!run.value || !request.value || answers.length === 0) {
         throw new CliError2("respond requires --run, --request, and at least one --answer.");
       }
+      if (isRemoteConnectionSelected(context.projectRoot)) {
+        throw new CliError2("Remote input responses are not available from this CLI yet; use the server UI/API or switch to local state for direct JSONL edits.", 2);
+      }
       const parsedAnswers = Object.fromEntries(answers.map((entry) => {
         const [key, ...restValue] = entry.split("=");
         return [key, restValue.join("=")];
       }));
-      const requestsPath = resolve(resolveAuthorityRunDir(context.projectRoot, run.value), "user-input.jsonl");
+      const requestsPath = resolve3(resolveAuthorityRunDir(context.projectRoot, run.value), "user-input.jsonl");
       const requests = readJsonlFile(requestsPath);
       const resolvedAt = new Date().toISOString();
       const next = requests.map((entry) => entry.requestId === request.value || entry.id === request.value ? { ...entry, status: "resolved", answers: parsedAnswers, respondedAt: resolvedAt, resolvedAt } : entry);
-      writeFileSync(requestsPath, `${next.map((entry) => JSON.stringify(entry)).join(`
+      writeFileSync2(requestsPath, `${next.map((entry) => JSON.stringify(entry)).join(`
 `)}
 `, "utf8");
       return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, answers: parsedAnswers } };

package/dist/src/commands/init.js

@@ -148,7 +148,7 @@ function resolveSelectedConnection(projectRoot, options = {}) {
   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 };
 }
@@ -751,7 +751,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);
@@ -759,7 +759,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);

package/dist/src/commands/inspect.js

@@ -60,8 +60,8 @@ async function executeInspect(context, args) {
   switch (command) {
     case "logs": {
       const { value: task, rest: remaining } = takeOption(rest, "--task");
-      requireNoExtraArgs(remaining, "bun run rig inspect logs --task <beads-id>");
-      const requiredTask = requireTask(task, "bun run rig inspect logs --task <beads-id>");
+      requireNoExtraArgs(remaining, "rig inspect logs --task <task-id>");
+      const requiredTask = requireTask(task, "rig inspect logs --task <task-id>");
       const latestRun = listAuthorityRuns(context.projectRoot).map((entry) => readAuthorityRun(context.projectRoot, entry.runId)).filter((run) => Boolean(run)).filter((run) => run.taskId === requiredTask).sort((left, right) => String(right.updatedAt ?? "").localeCompare(String(left.updatedAt ?? "")))[0];
       if (!latestRun) {
         throw new CliError2(`No runs found for ${requiredTask}.`);
@@ -75,8 +75,8 @@ async function executeInspect(context, args) {
     }
     case "artifacts": {
       const { value: task, rest: remaining } = takeOption(rest, "--task");
-      requireNoExtraArgs(remaining, "bun run rig inspect artifacts --task <beads-id>");
-      const requiredTask = requireTask(task, "bun run rig inspect artifacts --task <beads-id>");
+      requireNoExtraArgs(remaining, "rig inspect artifacts --task <task-id>");
+      const requiredTask = requireTask(task, "rig inspect artifacts --task <task-id>");
       const artifactRoot = resolveTaskArtifactDirs(context.projectRoot, requiredTask).find((path) => existsSync(path));
       if (!artifactRoot) {
         throw new CliError2(`No artifacts found for ${requiredTask}.`);
@@ -90,8 +90,8 @@ async function executeInspect(context, args) {
       previewPending = task.rest;
       const file = takeOption(previewPending, "--file");
       previewPending = file.rest;
-      requireNoExtraArgs(previewPending, "bun run rig inspect artifact --task <beads-id> --file <name>");
-      const requiredTask = requireTask(task.value, "bun run rig inspect artifact --task <beads-id> --file <name>");
+      requireNoExtraArgs(previewPending, "rig inspect artifact --task <task-id> --file <name>");
+      const requiredTask = requireTask(task.value, "rig inspect artifact --task <task-id> --file <name>");
       if (!file.value) {
         throw new CliError2("Missing --file for rig inspect artifact.");
       }
@@ -120,7 +120,7 @@ async function executeInspect(context, args) {
     }
     case "diff": {
       const { value: task, rest: remaining } = takeOption(rest, "--task");
-      requireNoExtraArgs(remaining, "bun run rig inspect diff [--task <beads-id>]");
+      requireNoExtraArgs(remaining, "rig inspect diff [--task <task-id>]");
       if (task) {
         const files = changedFilesForTask(context.projectRoot, task, false);
         for (const file of files) {
@@ -132,7 +132,7 @@ async function executeInspect(context, args) {
       return { ok: true, group: "inspect", command, details: { task: task || null } };
     }
     case "failures": {
-      requireNoExtraArgs(rest, "bun run rig inspect failures");
+      requireNoExtraArgs(rest, "rig inspect failures");
       const failed = resolveHarnessPaths(context.projectRoot).failedApproachesPath;
       if (!existsSync(failed)) {
         console.log("No failures recorded.");
@@ -142,7 +142,7 @@ async function executeInspect(context, args) {
       return { ok: true, group: "inspect", command };
     }
     case "graph":
-      requireNoExtraArgs(rest, "bun run rig inspect graph");
+      requireNoExtraArgs(rest, "rig inspect graph");
       {
         const monorepoRoot = resolveMonorepoRoot(context.projectRoot);
         const result = runCapture(["br", "--no-db", "list", "--pretty"], monorepoRoot);
@@ -153,7 +153,7 @@ async function executeInspect(context, args) {
       }
       return { ok: true, group: "inspect", command };
     case "audit": {
-      requireNoExtraArgs(rest, "bun run rig inspect audit");
+      requireNoExtraArgs(rest, "rig inspect audit");
       const auditPath = resolve(resolveHarnessPaths(context.projectRoot).logsDir, "audit.jsonl");
       if (!existsSync(auditPath)) {
         console.log("No audit log found.");

package/dist/src/commands/inspector.js

@@ -104,7 +104,7 @@ async function executeInspector(context, args) {
       pending = secondsResult.rest;
       const pollMsResult = takeOption(pending, "--poll-ms");
       pending = pollMsResult.rest;
-      requireNoExtraArgs(pending, "bun run rig inspector stream [--once] [--seconds <n>] [--poll-ms <n>]");
+      requireNoExtraArgs(pending, "rig inspector stream [--once] [--seconds <n>] [--poll-ms <n>]");
       const seconds = secondsResult.value ? parseRequiredPositiveInt(secondsResult.value, "--seconds") : null;
       const pollMs = pollMsResult.value ? parseRequiredPositiveInt(pollMsResult.value, "--poll-ms") : null;
       if (context.outputMode === "json" && !onceResult.value && !seconds) {
@@ -198,7 +198,7 @@ async function executeInspector(context, args) {
       let pending = rest;
       const scanIdResult = takeOption(pending, "--scan-id");
       pending = scanIdResult.rest;
-      requireNoExtraArgs(pending, "bun run rig inspector scan-upstream-drift [--scan-id <id>]");
+      requireNoExtraArgs(pending, "rig inspector scan-upstream-drift [--scan-id <id>]");
       const connection = await ensureLocalRigServerConnection(context.projectRoot);
       const response = await fetch(new URL("/api/inspector/tools/invoke", connection.baseUrl), {
         method: "POST",

package/dist/src/commands/plugin.js

@@ -58,7 +58,7 @@ async function executePlugin(context, args) {
   const [command = "list", ...rest] = args;
   switch (command) {
     case "list": {
-      requireNoExtraArgs(rest, "bun run rig plugin list");
+      requireNoExtraArgs(rest, "rig plugin list");
       const legacyPlugins = context.plugins.list();
       const declarative = [];
       const config = await loadRigConfigOrNull(context.projectRoot);
@@ -125,8 +125,8 @@ async function executePlugin(context, args) {
     }
     case "validate": {
       const { value: task, rest: remaining } = takeOption(rest, "--task");
-      requireNoExtraArgs(remaining, "bun run rig plugin validate --task <beads-id>");
-      const taskId = requireTask(task, "bun run rig plugin validate --task <beads-id>");
+      requireNoExtraArgs(remaining, "rig plugin validate --task <task-id>");
+      const taskId = requireTask(task, "rig plugin validate --task <task-id>");
       const results = await context.plugins.runValidators(taskId);
       const passed = results.filter((result) => result.passed).length;
       const failed = results.length - passed;