@h-rig/cli 0.0.6-alpha.8 → 0.0.6-alpha.81

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

@@ -0,0 +1,3472 @@
+// @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);
+
+// 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 };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+function requireTask(taskId, usage) {
+  if (!taskId) {
+    throw new CliError(`Missing --task option.
+Usage: ${usage}`);
+  }
+  return taskId;
+}
+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 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
+  };
+}
+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" }, 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: repo.serverProjectRoot };
+}
+function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return;
+  writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
+}
+var init__connection_state = __esm(() => {
+  init_runner();
+});
+
+// packages/cli/src/commands/_server-client.ts
+var exports__server_client = {};
+__export(exports__server_client, {
+  updateWorkspaceTaskViaServer: () => updateWorkspaceTaskViaServer,
+  switchServerProjectRootViaServer: () => switchServerProjectRootViaServer,
+  submitTaskRunViaServer: () => submitTaskRunViaServer,
+  stopRunViaServer: () => stopRunViaServer,
+  steerRunViaServer: () => steerRunViaServer,
+  setServerPhaseListener: () => setServerPhaseListener,
+  setGitHubBearerTokenForCurrentProcess: () => setGitHubBearerTokenForCurrentProcess,
+  sendRunPiShellViaServer: () => sendRunPiShellViaServer,
+  sendRunPiPromptViaServer: () => sendRunPiPromptViaServer,
+  selectNextWorkspaceTaskViaServer: () => selectNextWorkspaceTaskViaServer,
+  runRunPiCommandViaServer: () => runRunPiCommandViaServer,
+  resumeRunViaServer: () => resumeRunViaServer,
+  respondRunPiExtensionUiViaServer: () => respondRunPiExtensionUiViaServer,
+  resolveServerConnectionLabel: () => resolveServerConnectionLabel,
+  requestServerJson: () => requestServerJson,
+  registerProjectViaServer: () => registerProjectViaServer,
+  prepareRemoteCheckoutViaServer: () => prepareRemoteCheckoutViaServer,
+  postGitHubTokenViaServer: () => postGitHubTokenViaServer,
+  listWorkspaceTasksViaServer: () => listWorkspaceTasksViaServer,
+  listRunsViaServer: () => listRunsViaServer,
+  listGitHubProjectsViaServer: () => listGitHubProjectsViaServer,
+  getWorkspaceTaskViaServer: () => getWorkspaceTaskViaServer,
+  getRunTimelineViaServer: () => getRunTimelineViaServer,
+  getRunPiStatusViaServer: () => getRunPiStatusViaServer,
+  getRunPiSessionViaServer: () => getRunPiSessionViaServer,
+  getRunPiMessagesViaServer: () => getRunPiMessagesViaServer,
+  getRunPiCommandsViaServer: () => getRunPiCommandsViaServer,
+  getRunPiCapabilitiesViaServer: () => getRunPiCapabilitiesViaServer,
+  getRunLogsViaServer: () => getRunLogsViaServer,
+  getRunDetailsViaServer: () => getRunDetailsViaServer,
+  getGitHubProjectStatusFieldViaServer: () => getGitHubProjectStatusFieldViaServer,
+  getGitHubAuthStatusViaServer: () => getGitHubAuthStatusViaServer,
+  ensureTaskLabelsViaServer: () => ensureTaskLabelsViaServer,
+  ensureServerForCli: () => ensureServerForCli,
+  buildRunPiEventsWebSocketUrl: () => buildRunPiEventsWebSocketUrl,
+  abortRunPiViaServer: () => abortRunPiViaServer
+});
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+function setServerPhaseListener(listener) {
+  const previous = serverPhaseListener;
+  serverPhaseListener = listener;
+  return previous;
+}
+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 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);
+}
+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;
+  }
+}
+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") {
+      reportServerPhase(`Connecting to ${selected.alias}\u2026`);
+      const authToken = readGitHubBearerTokenForRemote(projectRoot);
+      const serverProjectRoot = selected.serverProjectRoot ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
+      return {
+        baseUrl: selected.connection.baseUrl,
+        authToken,
+        connectionKind: "remote",
+        serverProjectRoot
+      };
+    }
+    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;
+  }
+}
+async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken) {
+  const repo = readRepoConnection(projectRoot);
+  const slug = repo?.project?.trim();
+  if (!slug)
+    return null;
+  try {
+    const response = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`, {
+      headers: mergeHeaders(undefined, authToken)
+    });
+    if (!response.ok)
+      return null;
+    const payload = await response.json();
+    const project = payload.project && typeof payload.project === "object" && !Array.isArray(payload.project) ? payload.project : null;
+    const checkouts = Array.isArray(project?.checkouts) ? project.checkouts : [];
+    const latestCheckout = [...checkouts].reverse().find((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.path === "string"));
+    const path = typeof latestCheckout?.path === "string" && latestCheckout.path.trim() ? latestCheckout.path.trim() : null;
+    if (path)
+      writeRepoServerProjectRoot(projectRoot, path);
+    return path;
+  } catch {
+    return null;
+  }
+}
+function appendTaskFilterParams(url, filters) {
+  if (filters.assignee)
+    url.searchParams.set("assignee", filters.assignee);
+  if (filters.state)
+    url.searchParams.set("state", filters.state);
+  if (filters.status)
+    url.searchParams.set("status", filters.status);
+  if (filters.limit !== undefined)
+    url.searchParams.set("limit", String(filters.limit));
+}
+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 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>`."
+  };
+}
+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);
+  reportServerPhase(`${(init.method ?? "GET").toUpperCase()} ${pathname.split("?")[0]}\u2026`);
+  let response;
+  try {
+    response = await fetch(`${server.baseUrl}${pathname}`, {
+      ...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 listWorkspaceTasksViaServer(context, filters = {}) {
+  const url = new URL("http://rig.local/api/workspace/tasks");
+  appendTaskFilterParams(url, filters);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  if (!Array.isArray(payload)) {
+    throw new CliError("Rig server returned an invalid task list payload.", 1, { hint: "Check the selected server with `rig server status`; mixed CLI/server versions can mismatch \u2014 try `rig doctor`." });
+  }
+  return payload.flatMap((entry) => entry && typeof entry === "object" && !Array.isArray(entry) ? [entry] : []);
+}
+async function getWorkspaceTaskViaServer(context, taskId) {
+  const payload = await requestServerJson(context, `/api/workspace/tasks/${encodeURIComponent(taskId)}`);
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const task = payload.task;
+  return task && typeof task === "object" && !Array.isArray(task) ? task : null;
+}
+async function selectNextWorkspaceTaskViaServer(context, filters = {}) {
+  const url = new URL("http://rig.local/api/workspace/tasks/next");
+  appendTaskFilterParams(url, filters);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new CliError("Rig server returned an invalid next-task payload.", 1, { hint: "Check the selected server with `rig server status`; try `rig task list` to see the raw task set." });
+  }
+  const record = payload;
+  const rawTask = record.task;
+  const task = rawTask && typeof rawTask === "object" && !Array.isArray(rawTask) ? rawTask : null;
+  const count = typeof record.count === "number" && Number.isFinite(record.count) ? record.count : task ? 1 : 0;
+  return { task, count };
+}
+async function getGitHubAuthStatusViaServer(context) {
+  const payload = await requestServerJson(context, "/api/github/auth/status");
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function postGitHubTokenViaServer(context, token, options = {}) {
+  const payload = await requestServerJson(context, "/api/github/auth/token", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ token, selectedRepo: options.selectedRepo, projectRoot: options.projectRoot })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function prepareRemoteCheckoutViaServer(context, input) {
+  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 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 : {};
+}
+async function getRunLogsViaServer(context, runId, options = {}) {
+  const url = new URL(`http://rig.local/api/runs/${encodeURIComponent(runId)}/logs`);
+  if (options.limit !== undefined)
+    url.searchParams.set("limit", String(options.limit));
+  if (options.cursor)
+    url.searchParams.set("cursor", options.cursor);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { entries: [] };
+}
+async function getRunTimelineViaServer(context, runId, options = {}) {
+  const url = new URL(`http://rig.local/api/runs/${encodeURIComponent(runId)}/timeline`);
+  if (options.limit !== undefined)
+    url.searchParams.set("limit", String(options.limit));
+  if (options.cursor)
+    url.searchParams.set("cursor", options.cursor);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { entries: [] };
+}
+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 : {};
+}
+async function updateWorkspaceTaskViaServer(context, input) {
+  const payload = await requestServerJson(context, "/api/tasks/update", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(input)
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
+}
+async function resumeRunViaServer(context, runId, options) {
+  let targetRunId = runId?.trim() || null;
+  if (!targetRunId) {
+    const candidates = (await listRunsViaServer(context)).filter((run) => RESUMABLE_RUN_STATUSES.has(String(run.status ?? ""))).sort((left, right) => String(right.updatedAt ?? "").localeCompare(String(left.updatedAt ?? "")));
+    targetRunId = typeof candidates[0]?.runId === "string" ? candidates[0].runId : null;
+  }
+  if (!targetRunId) {
+    throw new CliError(options.restart ? "No run is available to restart." : "No resumable run is available.", 2, { hint: "List runs with `rig run list`, then pass an explicit id: `rig run resume <run-id>`." });
+  }
+  const payload = await requestServerJson(context, "/api/runs/resume", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ runId: targetRunId, createdAt: new Date().toISOString(), restart: options.restart })
+  });
+  const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+  if (record.ok === false) {
+    const message = typeof record.error === "string" && record.error.trim() ? record.error : "run resume failed";
+    throw new CliError(`${options.restart ? "restart" : "resume"} failed for ${targetRunId}: ${message}`, 1);
+  }
+  return { ok: true, runId: targetRunId, ...record };
+}
+async function resolveServerConnectionLabel(projectRoot) {
+  try {
+    const selected = resolveSelectedConnection(projectRoot);
+    if (!selected)
+      return "no server selected";
+    if (selected.connection.kind === "remote") {
+      return selected.connection.baseUrl.replace(/^https?:\/\//, "");
+    }
+    return `local (${selected.alias})`;
+  } catch {
+    return "no server selected";
+  }
+}
+async function stopRunViaServer(context, runId) {
+  const payload = await requestServerJson(context, "/api/runs/stop", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ runId })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true, runId };
+}
+async function steerRunViaServer(context, runId, message) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/steer`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ message })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
+}
+async function getRunPiSessionViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function getRunPiMessagesViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/messages`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { messages: [] };
+}
+async function getRunPiStatusViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/status`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function getRunPiCommandsViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/commands`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { commands: [] };
+}
+async function getRunPiCapabilitiesViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/capabilities`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { capabilities: null };
+}
+async function sendRunPiPromptViaServer(context, runId, text, streamingBehavior) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/prompt`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text, streamingBehavior })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function sendRunPiShellViaServer(context, runId, text) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/shell`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function runRunPiCommandViaServer(context, runId, text) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/commands/run`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { type: "done" };
+}
+async function respondRunPiExtensionUiViaServer(context, runId, requestId, valueOrCancel) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/extension-ui/respond`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ requestId, ...valueOrCancel })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function abortRunPiViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/abort`, { method: "POST" });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { aborted: true };
+}
+async function buildRunPiEventsWebSocketUrl(context, runId) {
+  const server = await ensureServerForCli(context.projectRoot);
+  const url = new URL(`${server.baseUrl.replace(/\/+$/, "")}/api/runs/${encodeURIComponent(runId)}/pi/events`);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  if (server.authToken)
+    url.searchParams.set("token", server.authToken);
+  if (server.serverProjectRoot)
+    url.searchParams.set("rigProjectRoot", server.serverProjectRoot);
+  return url.toString();
+}
+async function submitTaskRunViaServer(context, input) {
+  const isTaskRun = Boolean(input.taskId);
+  const endpoint = isTaskRun ? "/api/runs/task" : "/api/runs/adhoc";
+  const payload = await requestServerJson(context, endpoint, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      runId: input.runId,
+      taskId: input.taskId,
+      title: input.title,
+      runtimeAdapter: input.runtimeAdapter,
+      model: input.model,
+      runtimeMode: input.runtimeMode,
+      interactionMode: input.interactionMode,
+      initialPrompt: input.initialPrompt,
+      baselineMode: input.baselineMode,
+      prMode: input.prMode,
+      executionTarget: "local"
+    })
+  });
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new CliError("Rig server returned an invalid run submission payload.", 1, { hint: "Check `rig server status` and retry; `rig run list` shows whether the run was created anyway." });
+  }
+  const runId = payload.runId;
+  if (typeof runId !== "string" || runId.trim().length === 0) {
+    throw new CliError("Rig server returned no runId for the submitted run.", 1, { hint: "Check `rig run list` \u2014 the run may still have been created; otherwise retry the submission." });
+  }
+  return { runId };
+}
+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/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
+import { ProcessTerminal, TUI, Text, Input, SelectList, matchesKey } from "@earendil-works/pi-tui";
+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 droneCancel(text) {
+  console.log(` ${red("\u2716")} ${ink3(text)}`);
+}
+async function runMiniTui(build) {
+  const terminal = new ProcessTerminal;
+  const tui = new TUI(terminal);
+  let settled = false;
+  return await new Promise((resolve3) => {
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      tui.stop();
+      resolve3(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 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/_paths.ts
+import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
+var init__paths = () => {};
+
+// packages/cli/src/commands/_authority-runs.ts
+import {
+  readAuthorityRun,
+  readJsonlFile,
+  writeAuthorityRunRecord
+} from "@rig/runtime/control-plane/authority-files";
+function normalizeRuntimeAdapter(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return "pi";
+  }
+  if (normalized === "codex" || normalized === "codex-cli" || normalized === "codex-app-server" || normalized === "gpt-codex") {
+    return "codex";
+  }
+  if (normalized === "pi" || normalized === "rig-pi" || normalized === "@rig/pi") {
+    return "pi";
+  }
+  return "claude-code";
+}
+var init__authority_runs = __esm(() => {
+  init__paths();
+});
+
+// packages/cli/src/commands/_preflight.ts
+import { ensureProjectMainFreshBeforeRun } from "@rig/runtime/control-plane/project-main-pre-run-sync";
+function preflightCheck(id, label, status, detail, remediation) {
+  return {
+    id,
+    label,
+    status,
+    ...detail ? { detail } : {},
+    ...remediation ? { remediation } : {}
+  };
+}
+function message(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 taskMatchesId(entry, taskId) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry))
+    return false;
+  const record = entry;
+  if (record.id === taskId || record.taskId === taskId)
+    return true;
+  const raw = record.raw;
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    const rawRecord = raw;
+    if (String(rawRecord.number ?? "") === taskId.replace(/^#/, ""))
+      return true;
+  }
+  return false;
+}
+function isActiveRunStatus(status) {
+  const normalized = String(status ?? "running").toLowerCase();
+  return !["completed", "complete", "done", "merged", "closed", "failed", "cancelled", "canceled", "needs_attention", "needs-attention", "stopped"].includes(normalized);
+}
+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 isNotFoundError(error) {
+  return /\b(404|not found)\b/i.test(message(error));
+}
+function projectCheckoutReady(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  if (record.checkoutReady === true || record.ready === true)
+    return true;
+  if (record.checkoutReady === false || record.ready === false)
+    return false;
+  const project = record.project;
+  if (project && typeof project === "object" && !Array.isArray(project)) {
+    const checkouts = project.checkouts;
+    if (Array.isArray(checkouts))
+      return checkouts.length > 0;
+  }
+  return null;
+}
+function activeDuplicateRun(runs, taskId) {
+  if (!Array.isArray(runs))
+    return null;
+  for (const run of runs) {
+    if (!run || typeof run !== "object" || Array.isArray(run))
+      continue;
+    const record = run;
+    if ((record.taskId === taskId || record.task === taskId) && isActiveRunStatus(record.status))
+      return record;
+  }
+  return null;
+}
+async function runFastTaskRunPreflight(context, options = {}) {
+  const checks = [];
+  const request = options.requestJson ?? ((pathname, init) => requestServerJson(context, pathname, init));
+  const taskId = options.taskId?.trim() || null;
+  const requiresCurrentRunApi = Boolean(taskId);
+  const selectedServer = options.requestJson ? null : await ensureServerForCli(context.projectRoot).catch(() => null);
+  const allowLocalLegacyTaskRunCompatibility = selectedServer?.connectionKind === "local";
+  let legacyServerCompatibility = false;
+  try {
+    await request("/api/server/status");
+    checks.push(preflightCheck("server", "Rig server reachable", "pass"));
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      try {
+        await request("/health");
+        legacyServerCompatibility = !requiresCurrentRunApi || allowLocalLegacyTaskRunCompatibility;
+        checks.push(requiresCurrentRunApi && !allowLocalLegacyTaskRunCompatibility ? preflightCheck("server", "Rig server reachable", "fail", "legacy /health endpoint only; current task-run APIs are required", "Upgrade/select the Rig server before launching a task run.") : preflightCheck("server", "Rig server reachable", "pass", allowLocalLegacyTaskRunCompatibility ? "local legacy /health endpoint; submit endpoint will be authoritative" : "legacy /health endpoint"));
+      } catch (healthError) {
+        checks.push(preflightCheck("server", "Rig server reachable", "fail", message(healthError), "Start or select a reachable Rig server."));
+      }
+    } else {
+      checks.push(preflightCheck("server", "Rig server reachable", "fail", message(error), "Start or select a reachable Rig server."));
+    }
+  }
+  const repo = readRepoConnection(context.projectRoot);
+  checks.push(repo ? preflightCheck("project-link", "project linked to Rig server", repo.project ? "pass" : "warn", `${repo.selected}${repo.project ? ` -> ${repo.project}` : ""}`, "Run `rig init --yes --repo owner/repo` to record the GitHub repo slug.") : preflightCheck("project-link", "project linked to Rig server", legacyServerCompatibility ? "warn" : "fail", "missing .rig/state/connection.json", "Run `rig init` or `rig server use <alias|local>`."));
+  try {
+    const auth = await request("/api/github/auth/status");
+    checks.push(isAuthenticated(auth) ? preflightCheck("github-auth", "GitHub auth valid", "pass") : preflightCheck("github-auth", "GitHub auth valid", legacyServerCompatibility ? "warn" : "fail", "not authenticated", "Run `rig github auth import-gh` or `rig github auth token --token <token>`."));
+  } catch (error) {
+    checks.push(preflightCheck("github-auth", "GitHub auth valid", legacyServerCompatibility ? "warn" : "fail", message(error), "Fix GitHub auth on the selected Rig server."));
+  }
+  try {
+    const projection = await request("/api/workspace/task-projection");
+    checks.push(preflightCheck("task-projection", "task projection ready", "pass", JSON.stringify(projection).slice(0, 120)));
+  } catch (error) {
+    checks.push(preflightCheck("task-projection", "task projection ready", "warn", message(error), "Refresh task projection with `rig task list` before launching."));
+  }
+  try {
+    const permissions = await request("/api/github/repo/permissions");
+    const allowed = permissionAllowsPr(permissions);
+    checks.push(allowed === false ? preflightCheck("github-repo-permissions", "GitHub PR permissions", "fail", JSON.stringify(permissions).slice(0, 120), "Grant the selected GitHub token permission to push branches and open PRs.") : preflightCheck("github-repo-permissions", "GitHub PR permissions", allowed === true ? "pass" : "warn", JSON.stringify(permissions).slice(0, 120), "Confirm the selected token can push branches and open PRs."));
+  } catch (error) {
+    checks.push(preflightCheck("github-repo-permissions", "GitHub PR permissions", "warn", message(error), "Ensure the selected token can push branches and open PRs."));
+  }
+  if (repo?.project) {
+    try {
+      const project = await request(`/api/projects/${encodeURIComponent(repo.project)}`);
+      const ready = projectCheckoutReady(project);
+      checks.push(ready === false ? preflightCheck("remote-checkout", "execution checkout ready", "fail", JSON.stringify(project).slice(0, 120), "Repair the server checkout or rerun `rig init` with a valid checkout strategy.") : preflightCheck("remote-checkout", "execution checkout ready", ready === true ? "pass" : "warn", JSON.stringify(project).slice(0, 120), "Confirm the selected server has a prepared execution checkout."));
+    } catch (error) {
+      checks.push(preflightCheck("remote-checkout", "execution checkout ready", "warn", message(error), "Run `rig init` or repair the server checkout before launch."));
+    }
+  }
+  if (taskId) {
+    try {
+      const tasks = await request(`/api/workspace/tasks?limit=200&refresh=1`);
+      const found = Array.isArray(tasks) && tasks.some((task) => taskMatchesId(task, taskId));
+      checks.push(found ? preflightCheck("issue", "task/issue accessible", "pass", taskId) : preflightCheck("issue", "task/issue accessible", legacyServerCompatibility ? "warn" : "fail", taskId, "Confirm the issue exists and matches the configured task filters."));
+    } catch (error) {
+      checks.push(preflightCheck("issue", "task/issue accessible", legacyServerCompatibility ? "warn" : "fail", message(error), "Fix the task source before launching a run."));
+    }
+    try {
+      const runs = await request("/api/runs?limit=200");
+      const duplicate = activeDuplicateRun(runs, taskId);
+      checks.push(duplicate ? preflightCheck("duplicate-active-run", "one active run per task", "fail", String(duplicate.runId ?? taskId), "Attach to or stop the existing run before starting another one for this task.") : preflightCheck("duplicate-active-run", "one active run per task", "pass", taskId));
+    } catch (error) {
+      checks.push(preflightCheck("duplicate-active-run", "one active run per task", "warn", message(error), "Could not list active runs; the server will still reject conflicting runs if configured."));
+    }
+  }
+  if ((options.runtimeAdapter ?? "pi") === "pi") {
+    checks.push(preflightCheck("runtime", "worker Pi SDK session daemon", "pass", selectedServer?.connectionKind === "remote" ? "remote worker-owned runtime" : "bundled server-owned runtime"));
+  } else {
+    checks.push(preflightCheck("runtime", "runtime adapter", "pass", options.runtimeAdapter));
+  }
+  const failures = checks.filter((check) => check.status === "fail");
+  if (failures.length > 0) {
+    const summary = failures.map((check) => `${check.label}${check.detail ? `: ${check.detail}` : ""}`).join("; ");
+    if (failures.some((check) => check.id === "duplicate-active-run") && taskId) {
+      throw new CliError(`Task ${taskId} already has an active Rig run. ${summary}`, 1, { hint: `Attach to it with \`rig run attach <run-id> --follow\`, or stop it first with \`rig run stop <run-id>\`.` });
+    }
+    throw new CliError(`Task run preflight failed: ${summary}`, 1, { hint: "Run `rig doctor` to diagnose, then retry `rig task run`." });
+  }
+  return { ok: true, checks };
+}
+async function runProjectMainSyncPreflight(context, options) {
+  if (context.dryRun) {
+    if (context.outputMode === "text" && !options.disabled) {
+      console.log("[dry-run] project-rig pre-run sync check");
+    }
+    return;
+  }
+  const result = await ensureProjectMainFreshBeforeRun({
+    projectRoot: context.projectRoot,
+    disabled: options.disabled,
+    runBootstrap: async () => {
+      const bootstrap = await context.runCommand(["bun", "run", "bootstrap"]);
+      if (bootstrap.exitCode !== 0) {
+        throw new CliError(bootstrap.stderr || bootstrap.stdout || "bun run bootstrap failed during project pre-run sync", bootstrap.exitCode || 1);
+      }
+    }
+  });
+  if (context.outputMode !== "text") {
+    return;
+  }
+  switch (result.status) {
+    case "disabled":
+      console.log("Project pre-run sync skipped (--skip-project-sync).");
+      break;
+    case "skipped_not_main":
+      console.log(`Project pre-run sync skipped (current branch: ${result.branch}).`);
+      break;
+    case "up_to_date":
+      break;
+    case "local_ahead":
+      console.log(`Project pre-run sync skipped (local main ahead by ${result.localAhead} commit(s)).`);
+      break;
+    case "updated":
+      console.log(`Project pre-run sync updated local main from origin/main (+${result.remoteAhead}) and bootstrapped.`);
+      break;
+  }
+}
+var init__preflight = __esm(() => {
+  init_runner();
+  init__connection_state();
+  init__server_client();
+});
+
+// packages/cli/src/withMutedConsole.ts
+function isPromise(value) {
+  if (typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  return value !== null && typeof value.then === "function";
+}
+function withMutedConsole(mute, fn) {
+  if (!mute) {
+    return fn();
+  }
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalInfo = console.info;
+  const restore = () => {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.info = originalInfo;
+  };
+  console.log = () => {};
+  console.warn = () => {};
+  console.info = () => {};
+  try {
+    const result = fn();
+    if (isPromise(result)) {
+      return result.finally(restore);
+    }
+    restore();
+    return result;
+  } catch (error) {
+    restore();
+    throw error;
+  } finally {
+    if (console.log === originalLog) {
+      restore();
+    }
+  }
+}
+
+// packages/cli/src/commands/_operator-surface.ts
+import { createInterface } from "readline";
+import { createInterface as createPromptInterface } from "readline/promises";
+function logDetail(log) {
+  return typeof log.detail === "string" ? log.detail.trim() : "";
+}
+function parseProviderProtocolLog(title, detail) {
+  if (title.trim().toLowerCase() !== "agent output")
+    return null;
+  if (!detail.startsWith("{") || !detail.endsWith("}"))
+    return null;
+  try {
+    const record = JSON.parse(detail);
+    if (!record || typeof record !== "object" || Array.isArray(record))
+      return null;
+    const type = record.type;
+    return typeof type === "string" && [
+      "assistant",
+      "message_start",
+      "message_update",
+      "message_end",
+      "stream_event",
+      "tool_result",
+      "tool_execution_start",
+      "tool_execution_update",
+      "tool_execution_end",
+      "turn_start",
+      "turn_end"
+    ].includes(type) ? record : null;
+  } catch {
+    return null;
+  }
+}
+function renderProviderProtocolLog(record) {
+  const type = typeof record.type === "string" ? record.type : "";
+  if (type === "tool_execution_start" || type === "tool_execution_update" || type === "tool_execution_end") {
+    const toolName = String(record.toolName ?? record.name ?? "tool");
+    const status = type === "tool_execution_start" ? "started" : type === "tool_execution_end" ? record.isError === true || record.result && typeof record.result === "object" && !Array.isArray(record.result) && record.result.isError === true ? "failed" : "completed" : "running";
+    return `[Pi tool] ${toolName} ${status}`;
+  }
+  return null;
+}
+function entryId(entry, fallback) {
+  return typeof entry.id === "string" && entry.id.trim() ? entry.id : fallback;
+}
+function renderOperatorSnapshot(snapshot) {
+  const run = snapshot.run.run && typeof snapshot.run.run === "object" ? snapshot.run.run : snapshot.run;
+  const runId = String(run.runId ?? run.id ?? "run");
+  const status = String(run.status ?? "unknown");
+  const logs = snapshot.logs ?? [];
+  const latestByStage = new Map;
+  for (const log of logs) {
+    const title = String(log.title ?? "").toLowerCase();
+    const stageName = String(log.stage ?? "").toLowerCase();
+    const stage = CANONICAL_STAGES.find((candidate) => candidate.toLowerCase() === title || candidate.toLowerCase() === stageName);
+    if (stage)
+      latestByStage.set(stage, log);
+  }
+  const stageLines = CANONICAL_STAGES.flatMap((stage) => {
+    const match = latestByStage.get(stage);
+    return match ? [`${stage}: ${String(match.status ?? status)}${logDetail(match) ? ` \u2014 ${logDetail(match)}` : ""}`] : [];
+  });
+  return [`Rig run ${runId}: ${status}`, ...stageLines].join(`
+`);
+}
+function createPiRunStreamRenderer(output = process.stdout) {
+  let lastSnapshot = "";
+  const assistantTextById = new Map;
+  const seenTimeline = new Set;
+  const seenLogs = new Set;
+  const writeLine = (line) => output.write(`${line}
+`);
+  return {
+    renderSnapshot(snapshot) {
+      const rendered = renderOperatorSnapshot(snapshot);
+      if (rendered && rendered !== lastSnapshot) {
+        writeLine(rendered);
+        lastSnapshot = rendered;
+      }
+    },
+    renderTimeline(entries) {
+      for (const [index, entry] of entries.entries()) {
+        const id = entryId(entry, `timeline:${index}:${String(entry.cursor ?? "")}`);
+        if (entry.type === "assistant_message" && typeof entry.text === "string") {
+          const text = entry.text;
+          const previousText = assistantTextById.get(id) ?? "";
+          if (!previousText && text.trim()) {
+            writeLine("[Pi assistant]");
+          }
+          if (text.startsWith(previousText)) {
+            const delta = text.slice(previousText.length);
+            if (delta)
+              output.write(delta);
+          } else if (text.trim() && text !== previousText) {
+            if (previousText)
+              writeLine(`
+[Pi assistant]`);
+            output.write(text);
+          }
+          assistantTextById.set(id, text);
+          continue;
+        }
+        if (seenTimeline.has(id))
+          continue;
+        seenTimeline.add(id);
+        if (entry.type === "tool_execution_start" || entry.type === "tool_execution_update" || entry.type === "tool_execution_end" || entry.type === "mcp_tool_call") {
+          writeLine(`[Pi tool] ${String(entry.toolName ?? entry.name ?? entry.title ?? entry.type)} ${String(entry.status ?? entry.state ?? "")}`.trim());
+          continue;
+        }
+        if (entry.type === "timeline_warning") {
+          writeLine(`[Rig timeline] ${String(entry.detail ?? entry.message ?? "timeline unavailable")}`);
+          continue;
+        }
+        if (entry.type === "action") {
+          const text = String(entry.detail ?? entry.message ?? entry.title ?? "").trim();
+          if (text)
+            writeLine(`[Rig action] ${text}`);
+          continue;
+        }
+        if (entry.type === "user_message") {
+          const text = String(entry.text ?? entry.message ?? entry.detail ?? "").trim();
+          if (text)
+            writeLine(`[Operator] ${text}`);
+          continue;
+        }
+        const fallback = String(entry.detail ?? entry.message ?? entry.text ?? entry.title ?? "").trim();
+        if (fallback)
+          writeLine(`[${String(entry.type ?? "timeline")}] ${fallback}`);
+      }
+    },
+    renderLogs(entries) {
+      for (const [index, entry] of entries.entries()) {
+        const id = entryId(entry, `log:${index}:${String(entry.createdAt ?? "")}:${String(entry.title ?? "")}`);
+        if (seenLogs.has(id))
+          continue;
+        seenLogs.add(id);
+        const title = String(entry.title ?? "");
+        if (CANONICAL_STAGES.some((stage) => stage.toLowerCase() === title.toLowerCase()))
+          continue;
+        const detail = logDetail(entry);
+        if (!detail)
+          continue;
+        const protocolRecord = parseProviderProtocolLog(title, detail);
+        if (protocolRecord) {
+          const protocolLine = renderProviderProtocolLog(protocolRecord);
+          if (protocolLine)
+            writeLine(protocolLine);
+          continue;
+        }
+        writeLine(`[${title || "Rig log"}] ${detail}`);
+      }
+    }
+  };
+}
+function createOperatorSurface(options = {}) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const errorOutput = options.errorOutput ?? process.stderr;
+  const renderer = createPiRunStreamRenderer(output);
+  const writeLine = (line) => output.write(`${line}
+`);
+  return {
+    mode: "pi-compatible-text",
+    ...renderer,
+    info: writeLine,
+    error: (message2) => errorOutput.write(`${message2}
+`),
+    attachCommandInput(handler) {
+      if (options.interactive === false || !input.isTTY)
+        return null;
+      const rl = createInterface({ input, output: process.stdout, terminal: false });
+      rl.on("line", (line) => {
+        Promise.resolve(handler(line)).catch((error) => writeLine(`Operator command failed: ${error instanceof Error ? error.message : String(error)}`));
+      });
+      return { close: () => rl.close() };
+    }
+  };
+}
+function taskId(task) {
+  return typeof task.id === "string" && task.id.trim() ? task.id : "<unknown>";
+}
+function taskTitle(task) {
+  return typeof task.title === "string" && task.title.trim() ? task.title : "Untitled task";
+}
+function taskStatus(task) {
+  return typeof task.status === "string" && task.status.trim() ? task.status : "unknown";
+}
+function renderTaskPickerRows(tasks) {
+  return tasks.map((task, index) => `${index + 1}. ${taskId(task)} \xB7 ${taskStatus(task)} \xB7 ${taskTitle(task)}`);
+}
+async function promptForTaskSelection(question) {
+  const rl = createPromptInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await rl.question(question);
+  } finally {
+    rl.close();
+  }
+}
+var CANONICAL_STAGES;
+var init__operator_surface = __esm(() => {
+  CANONICAL_STAGES = [
+    "Connect",
+    "GitHub/task sync",
+    "Prepare workspace",
+    "Launch Pi",
+    "Plan",
+    "Implement",
+    "Validate",
+    "Commit",
+    "Open PR",
+    "Review/CI",
+    "Merge",
+    "Complete"
+  ];
+});
+
+// packages/cli/src/commands/_task-picker.ts
+function taskId2(task) {
+  return typeof task.id === "string" && task.id.trim() ? task.id : "<unknown>";
+}
+async function selectTaskWithTextPicker(tasks, io = {}) {
+  if (tasks.length === 0)
+    return null;
+  if (tasks.length === 1)
+    return tasks[0];
+  const isTty2 = io.isTty ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (!isTty2) {
+    throw new Error("task run requires an interactive terminal to pick a task; pass --task <id>, --next, or --detach with a task id.");
+  }
+  if (io.prompt || io.renderer) {
+    const prompt = io.prompt ?? promptForTaskSelection;
+    const renderer = io.renderer ?? { writeLine: (line) => process.stdout.write(`${line}
+`) };
+    renderer.writeLine("Select Rig task:");
+    for (const row of renderTaskPickerRows(tasks))
+      renderer.writeLine(`  ${row}`);
+    const answer2 = (await prompt(`Task [1-${tasks.length}] or id: `)).trim();
+    if (!answer2)
+      return null;
+    if (/^\d+$/.test(answer2)) {
+      const index2 = Number.parseInt(answer2, 10) - 1;
+      return tasks[index2] ?? null;
+    }
+    return tasks.find((task) => taskId2(task) === answer2) ?? null;
+  }
+  const options = tasks.map((task, index2) => ({
+    value: `${index2}`,
+    label: `${taskId2(task)} \xB7 ${typeof task.title === "string" && task.title.trim() ? task.title.trim() : "Untitled task"}`,
+    hint: typeof task.status === "string" && task.status.trim() ? task.status.trim() : undefined
+  }));
+  const answer = await droneSelect({
+    message: "Select Rig task",
+    options
+  });
+  if (answer === null) {
+    droneCancel("No task selected.");
+    return null;
+  }
+  const index = Number.parseInt(String(answer), 10);
+  return Number.isFinite(index) ? tasks[index] ?? null : null;
+}
+var init__task_picker = __esm(() => {
+  init_drone_ui();
+  init__operator_surface();
+});
+
+// packages/cli/src/commands/_async-ui.ts
+import pc from "picocolors";
+async function withSpinner(label, work, options = {}) {
+  if (options.outputMode === "json") {
+    return work(() => {});
+  }
+  if (activeUpdate) {
+    const outer = activeUpdate;
+    outer(label);
+    return work(outer);
+  }
+  const output = options.output ?? process.stderr;
+  const isTty2 = output.isTTY === true;
+  let lastLabel = label;
+  if (!isTty2) {
+    output.write(`${label}
+`);
+    const update2 = (next) => {
+      lastLabel = next;
+    };
+    activeUpdate = update2;
+    const previousListener2 = setServerPhaseListener(update2);
+    try {
+      return await work(update2);
+    } finally {
+      activeUpdate = null;
+      setServerPhaseListener(previousListener2);
+    }
+  }
+  const spinner = createTtySpinner({
+    label,
+    output,
+    frames: MICRO_DRONE_FRAMES,
+    styleFrame: (frame) => renderMicroDroneFrame(Math.max(0, MICRO_DRONE_FRAMES.indexOf(frame)))
+  });
+  const update = (next) => {
+    lastLabel = next;
+    spinner.setLabel(next);
+  };
+  activeUpdate = update;
+  const previousListener = setServerPhaseListener(update);
+  try {
+    const result = await work(update);
+    spinner.stop(options.doneLabel ? `${DONE_SYMBOL} ${options.doneLabel}` : undefined);
+    return result;
+  } catch (error) {
+    spinner.stop(`${FAIL_SYMBOL} ${lastLabel}`);
+    throw error;
+  } finally {
+    activeUpdate = null;
+    setServerPhaseListener(previousListener);
+  }
+}
+var DONE_SYMBOL, FAIL_SYMBOL, activeUpdate = null;
+var init__async_ui = __esm(() => {
+  init__spinner();
+  init__server_client();
+  init_theme();
+  DONE_SYMBOL = pc.green("\u25C7");
+  FAIL_SYMBOL = pc.red("\u25A0");
+});
+
+// packages/cli/src/commands/_pi-frontend.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, mkdtempSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2, tmpdir } from "os";
+import { join } from "path";
+import { main as runPiMain } from "@earendil-works/pi-coding-agent";
+import createPiRigExtension from "@rig/pi-rig";
+function setTemporaryEnv(updates) {
+  const previous = new Map;
+  for (const [key, value] of Object.entries(updates)) {
+    previous.set(key, process.env[key]);
+    process.env[key] = value;
+  }
+  return () => {
+    for (const [key, value] of previous) {
+      if (value === undefined)
+        delete process.env[key];
+      else
+        process.env[key] = value;
+    }
+  };
+}
+function buildOperatorPiEnv(input) {
+  return {
+    PI_CODING_AGENT_SESSION_DIR: input.sessionDir,
+    PI_SKIP_VERSION_CHECK: "1",
+    PI_HIDDEN_COMMANDS: "import,fork,clone,tree,new,resume,trust",
+    RIG_PI_OPERATOR_SESSION: "1",
+    RIG_RUN_ID: input.runId,
+    RIG_SERVER_URL: input.serverUrl,
+    ...input.authToken ? { RIG_AUTH_TOKEN: input.authToken } : {},
+    ...input.serverProjectRoot ? { RIG_PROJECT_ROOT: input.serverProjectRoot } : {}
+  };
+}
+async function prepareOperatorConsole(context, runId, tempSessionDir) {
+  const server = await ensureServerForCli(context.projectRoot);
+  const localCwd = join(homedir2(), ".rig", "drones", runId.slice(0, 8));
+  mkdirSync2(localCwd, { recursive: true });
+  trustDroneCwd(localCwd);
+  installRigPiTheme();
+  let sessionFileArg = [];
+  try {
+    const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/session-file`);
+    if (payload?.ok && typeof payload.content === "string" && payload.content.trim()) {
+      const fileName = typeof payload.fileName === "string" && payload.fileName.trim() ? payload.fileName.replace(/[^A-Za-z0-9._-]/g, "_") : `rig-run-${runId}.jsonl`;
+      const localSessionPath = join(tempSessionDir, fileName);
+      const content = payload.content.split(`
+`).map((line, index) => {
+        if (index > 0 || !line.trim())
+          return line;
+        try {
+          const header = JSON.parse(line);
+          if (header.type === "session" && typeof header.cwd === "string") {
+            return JSON.stringify({ ...header, cwd: localCwd });
+          }
+        } catch {}
+        return line;
+      }).join(`
+`);
+      writeFileSync2(localSessionPath, content);
+      sessionFileArg = ["--session", localSessionPath];
+    }
+  } catch {}
+  return { server, sessionFileArg };
+}
+function trustDroneCwd(localCwd) {
+  try {
+    const agentDir = join(homedir2(), ".pi", "agent");
+    mkdirSync2(agentDir, { recursive: true });
+    const trustPath = join(agentDir, "trust.json");
+    const store = existsSync3(trustPath) ? JSON.parse(readFileSync3(trustPath, "utf8")) : {};
+    if (store[localCwd] !== true) {
+      store[localCwd] = true;
+      writeFileSync2(trustPath, `${JSON.stringify(store, null, "\t")}
+`);
+    }
+  } catch {}
+}
+function installRigPiTheme() {
+  try {
+    const themesDir = join(homedir2(), ".pi", "agent", "themes");
+    mkdirSync2(themesDir, { recursive: true });
+    const themePath = join(themesDir, "rig.json");
+    const next = `${JSON.stringify(RIG_PI_THEME, null, "\t")}
+`;
+    if (!existsSync3(themePath) || readFileSync3(themePath, "utf8") !== next) {
+      writeFileSync2(themePath, next);
+    }
+  } catch {}
+}
+async function attachRunBundledPiFrontend(context, input) {
+  const tempSessionDir = mkdtempSync(join(tmpdir(), "rig-pi-frontend-sessions-"));
+  const { server, sessionFileArg } = await withSpinner(`Opening Pi console for run ${input.runId}\u2026`, () => prepareOperatorConsole(context, input.runId, tempSessionDir), { outputMode: context.outputMode });
+  const restoreEnv = setTemporaryEnv(buildOperatorPiEnv({
+    runId: input.runId,
+    serverUrl: server.baseUrl,
+    authToken: server.authToken,
+    serverProjectRoot: server.serverProjectRoot,
+    sessionDir: tempSessionDir
+  }));
+  const piRigExtensionFactory = (pi) => {
+    createPiRigExtension(pi);
+  };
+  let detached = false;
+  try {
+    await runPiMain([
+      "--no-extensions",
+      "--no-skills",
+      "--no-prompt-templates",
+      "--no-context-files",
+      ...sessionFileArg
+    ], {
+      extensionFactories: [piRigExtensionFactory]
+    });
+    detached = true;
+  } finally {
+    restoreEnv();
+    rmSync(tempSessionDir, { recursive: true, force: true });
+  }
+  let run = { runId: input.runId, status: "unknown" };
+  try {
+    run = await getRunDetailsViaServer(context, input.runId);
+  } catch {}
+  return {
+    run,
+    logs: [],
+    timeline: [],
+    timelineCursor: null,
+    steered: input.steered === true,
+    detached,
+    rendered: "stock Pi operator console with the pi-rig extension"
+  };
+}
+var RIG_PI_THEME;
+var init__pi_frontend = __esm(() => {
+  init__server_client();
+  init__async_ui();
+  RIG_PI_THEME = {
+    $schema: "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+    name: "rig",
+    vars: {
+      acid: "#ccff4d",
+      acidDim: "#a9d63f",
+      cyan: "#56d8ff",
+      red: "#ff5d5d",
+      yellow: "#ffd24d",
+      ink: "#f2f3f6",
+      ink2: "#aeb0ba",
+      ink3: "#6c6e79",
+      ink4: "#44464f",
+      panel: "#101115",
+      panelUser: "#14161b",
+      toolPending: "#0e1013",
+      toolSuccess: "#10150c",
+      toolError: "#1a0f0f",
+      customMsg: "#0f1410"
+    },
+    colors: {
+      accent: "acid",
+      border: "ink4",
+      borderAccent: "acid",
+      borderMuted: "ink4",
+      success: "acid",
+      error: "red",
+      warning: "yellow",
+      muted: "ink3",
+      dim: "ink4",
+      text: "ink",
+      thinkingText: "ink3",
+      selectedBg: "panel",
+      userMessageBg: "panelUser",
+      userMessageText: "ink",
+      customMessageBg: "customMsg",
+      customMessageText: "ink2",
+      customMessageLabel: "acidDim",
+      toolPendingBg: "toolPending",
+      toolSuccessBg: "toolSuccess",
+      toolErrorBg: "toolError",
+      toolTitle: "ink",
+      toolOutput: "ink3",
+      mdHeading: "acid",
+      mdLink: "cyan",
+      mdLinkUrl: "ink4",
+      mdCode: "acidDim",
+      mdCodeBlock: "ink2",
+      mdCodeBlockBorder: "ink4",
+      mdQuote: "ink3",
+      mdQuoteBorder: "ink4",
+      mdHr: "ink4",
+      mdListBullet: "acid",
+      toolDiffAdded: "acid",
+      toolDiffRemoved: "red",
+      toolDiffContext: "ink3",
+      syntaxComment: "ink3",
+      syntaxKeyword: "cyan",
+      syntaxFunction: "acid",
+      syntaxVariable: "ink",
+      syntaxString: "acidDim",
+      syntaxNumber: "yellow",
+      syntaxType: "cyan",
+      syntaxOperator: "ink2",
+      syntaxPunctuation: "ink3",
+      thinkingOff: "ink4",
+      thinkingMinimal: "ink3",
+      thinkingLow: "ink2",
+      thinkingMedium: "cyan",
+      thinkingHigh: "acidDim",
+      thinkingXhigh: "acid",
+      bashMode: "cyan"
+    }
+  };
+});
+
+// packages/cli/src/commands/_operator-view.ts
+function runStatusFromPayload(payload) {
+  const run = payload.run && typeof payload.run === "object" && !Array.isArray(payload.run) ? payload.run : payload;
+  return String(run.status ?? "unknown").toLowerCase();
+}
+async function applyOperatorCommand(context, input, deps = {}) {
+  const line = input.line.trim();
+  if (!line)
+    return { action: "ignored" };
+  if (line === "/detach" || line === "/quit" || line === "/q") {
+    return { action: "detach", message: "Detached from run." };
+  }
+  if (line === "/stop") {
+    await (deps.stop ?? stopRunViaServer)(context, input.runId);
+    return { action: "stopped", message: "Stop requested." };
+  }
+  const userMessage = line.startsWith("/user ") ? line.slice("/user ".length).trim() : line;
+  if (!userMessage)
+    return { action: "ignored" };
+  await (deps.steer ?? steerRunViaServer)(context, input.runId, userMessage);
+  return { action: "continue", message: "Steering message queued." };
+}
+async function readOperatorSnapshot(context, runId, options = {}) {
+  const run = await getRunDetailsViaServer(context, runId);
+  const logsPage = await getRunLogsViaServer(context, runId, { limit: 100 });
+  const timelinePage = await getRunTimelineViaServer(context, runId, { limit: 200, ...options.timelineCursor ? { cursor: options.timelineCursor } : {} }).catch((error) => ({
+    entries: [{
+      id: `timeline-unavailable:${runId}`,
+      type: "timeline_warning",
+      detail: `Selected Rig server did not provide run timeline events: ${error instanceof Error ? error.message : String(error)}`,
+      createdAt: new Date().toISOString()
+    }],
+    nextCursor: options.timelineCursor ?? null
+  }));
+  const logs = Array.isArray(logsPage.entries) ? logsPage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))).toReversed() : [];
+  const timeline = Array.isArray(timelinePage.entries) ? timelinePage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+  const timelineCursor = typeof timelinePage.nextCursor === "string" ? timelinePage.nextCursor : options.timelineCursor ?? null;
+  return { run, logs, timeline, timelineCursor, rendered: renderOperatorSnapshot({ run, logs, timeline }) };
+}
+async function attachRunOperatorView(context, input) {
+  let steered = false;
+  const attachMessage = input.message?.trim();
+  if (attachMessage) {
+    await withSpinner("Queueing steering message\u2026", () => sendRunPiPromptViaServer(context, input.runId, attachMessage, "steer").catch(() => steerRunViaServer(context, input.runId, attachMessage)), { outputMode: context.outputMode });
+    steered = true;
+  }
+  if (!input.once && input.interactive !== false && context.outputMode === "text" && Boolean(process.stdin.isTTY && process.stdout.isTTY)) {
+    return attachRunBundledPiFrontend(context, {
+      runId: input.runId,
+      steered
+    });
+  }
+  const surface = createOperatorSurface({ interactive: input.interactive !== false });
+  let snapshot = await withSpinner(`Connecting to run ${input.runId}\u2026`, () => readOperatorSnapshot(context, input.runId), { outputMode: context.outputMode });
+  if (context.outputMode === "text") {
+    surface.renderSnapshot(snapshot);
+    surface.renderTimeline(snapshot.timeline);
+    surface.renderLogs(snapshot.logs);
+    if (steered)
+      surface.info("Message submitted to worker Pi.");
+  }
+  let detached = false;
+  let commandInput = null;
+  if (input.follow && !input.once && context.outputMode === "text") {
+    if (input.interactive !== false && process.stdin.isTTY) {
+      surface.info("Controls: /user <message>, /stop, /detach");
+      commandInput = surface.attachCommandInput(async (line) => {
+        const result = await applyOperatorCommand(context, { runId: input.runId, line });
+        if (result.message)
+          surface.info(result.message);
+        if (result.action === "detach" || result.action === "stopped") {
+          detached = true;
+          commandInput?.close();
+        }
+      });
+    }
+    const pollMs = Math.max(250, Math.trunc(input.pollMs ?? 2000));
+    let timelineCursor = snapshot.timelineCursor;
+    while (!detached && !TERMINAL_RUN_STATUSES.has(runStatusFromPayload(snapshot.run))) {
+      await Bun.sleep(pollMs);
+      snapshot = await readOperatorSnapshot(context, input.runId, { timelineCursor });
+      timelineCursor = snapshot.timelineCursor;
+      surface.renderSnapshot(snapshot);
+      surface.renderTimeline(snapshot.timeline);
+      surface.renderLogs(snapshot.logs);
+    }
+    commandInput?.close();
+  }
+  return { ...snapshot, steered, detached };
+}
+var TERMINAL_RUN_STATUSES;
+var init__operator_view = __esm(() => {
+  init__server_client();
+  init__operator_surface();
+  init__pi_frontend();
+  init__async_ui();
+  TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
+});
+
+// packages/cli/src/commands/_cli-format.ts
+import pc2 from "picocolors";
+function stringField2(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", "running"].includes(normalized))
+    return accent;
+  if (["failed", "needs_attention", "needs-attention", "blocked", "error", "rejected"].includes(normalized))
+    return red;
+  if (["reviewing", "validating", "in_progress", "in-progress", "remote", "preparing", "closing-out"].includes(normalized))
+    return cyan;
+  if (["ready", "open", "queued", "created", "local", "pending"].includes(normalized))
+    return yellow;
+  return themeDim;
+}
+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 shouldUseClackOutput() {
+  return Boolean(process.stdout.isTTY) && process.env.RIG_CLI_PLAIN_HELP !== "1";
+}
+function printFormattedOutput(message2, options = {}) {
+  if (!shouldUseClackOutput()) {
+    console.log(message2);
+    return;
+  }
+  droneNote(message2, options.title);
+}
+function formatStatusPill(status) {
+  const label = status || "unknown";
+  return statusColor(label)(`\u25CF ${label}`);
+}
+function formatSection(title, subtitle) {
+  return `${pc2.bold(accent("\u25C6"))} ${pc2.bold(title)}${subtitle ? themeDim(` \u2014 ${subtitle}`) : ""}`;
+}
+function formatSuccessCard(title, rows = []) {
+  const body = rows.filter(([, value]) => value !== undefined && value !== null && String(value).length > 0).map(([key, value]) => `${themeFaint("\u2502")} ${themeDim(key.padEnd(12))} ${value}`);
+  return [formatSection(title), ...body].join(`
+`);
+}
+function formatNextSteps(steps) {
+  if (steps.length === 0)
+    return [];
+  return [pc2.bold("Next"), ...steps.map((step) => `${accent("\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 = stringField2(task, "id", "<unknown>");
+    const status = stringField2(task, "status", "unknown");
+    const title = stringField2(task, "title", "Untitled task");
+    const source = stringField2(task, "source", stringField2(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 = `${pc2.bold(pad("TASK", idWidth))}  ${pc2.bold(pad("STATUS", statusWidth))}  ${pc2.bold("TITLE")}`;
+  const body = rows.map((row) => {
+    const labels = row.labels.length > 0 ? themeDim(`  ${row.labels.slice(0, 4).map((label) => `#${label}`).join(" ")}`) : "";
+    const source = row.source ? themeDim(`  ${row.source}`) : "";
+    return [
+      pc2.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 = stringField2(task, "id", stringField2(raw, "id", "<unknown>"));
+  const status = stringField2(task, "status", stringField2(raw, "status", "unknown"));
+  const title = stringField2(task, "title", stringField2(raw, "title", "Untitled task"));
+  const source = stringField2(task, "source", stringField2(raw, "source", ""));
+  const url = stringField2(task, "url", stringField2(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", pc2.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 formatSubmittedRun(input) {
+  const rows = [["run", pc2.bold(input.runId)]];
+  if (input.task) {
+    const id = stringField2(input.task, "id", "<unknown>");
+    const status = stringField2(input.task, "status", "unknown");
+    const title = stringField2(input.task, "title", "Untitled task");
+    rows.push(["task", `${pc2.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(`
+`);
+}
+var themeDim = (value) => ink3(value), themeFaint = (value) => ink4(value);
+var init__cli_format = __esm(() => {
+  init_drone_ui();
+  init_theme();
+});
+
+// packages/cli/src/commands/inbox.ts
+async function listInboxRecords(context, kind, filters) {
+  const params = new URLSearchParams;
+  if (filters.run)
+    params.set("runId", filters.run);
+  if (filters.task)
+    params.set("taskId", filters.task);
+  const query = params.size > 0 ? `?${params.toString()}` : "";
+  const payload = await requestServerJson(context, `/api/inbox/${kind}${query}`);
+  const records = Array.isArray(payload) ? payload : [];
+  return filters.pendingOnly ? records.filter((entry) => (entry.status ?? "pending") !== "resolved") : records;
+}
+async function readPendingInboxCounts(context) {
+  try {
+    const [approvals, inputs] = await Promise.all([
+      listInboxRecords(context, "approvals", { pendingOnly: true }),
+      listInboxRecords(context, "inputs", { pendingOnly: true })
+    ]);
+    return { approvals: approvals.length, inputs: inputs.length };
+  } catch {
+    return null;
+  }
+}
+async function printPendingInboxFooter(context) {
+  if (context.outputMode !== "text")
+    return;
+  const counts = await readPendingInboxCounts(context);
+  if (!counts || counts.approvals === 0 && counts.inputs === 0)
+    return;
+  const parts = [];
+  if (counts.approvals > 0)
+    parts.push(`${counts.approvals} approval${counts.approvals === 1 ? "" : "s"}`);
+  if (counts.inputs > 0)
+    parts.push(`${counts.inputs} input request${counts.inputs === 1 ? "" : "s"}`);
+  console.log(`
+\u26A0 ${parts.join(" and ")} pending \u2014 run \`rig inbox\` to review.`);
+}
+var init_inbox = __esm(() => {
+  init_runner();
+  init__cli_format();
+  init__server_client();
+  init__async_ui();
+});
+
+// packages/cli/src/commands/_help-catalog.ts
+import pc3 from "picocolors";
+function heading(title) {
+  return pc3.bold(pc3.cyan(title));
+}
+function commandLine(command, description) {
+  const commandColumn = command.length >= 38 ? `${command}  ` : command.padEnd(38);
+  return `${pc3.dim("\u2502")} ${pc3.bold(commandColumn)} ${description}`;
+}
+function renderCommandBlock(commands) {
+  return commands.map((entry) => commandLine(entry.command, entry.description)).join(`
+`);
+}
+function renderGroup(group) {
+  const lines = [
+    `${heading(`rig ${group.name}`)} \u2014 ${group.summary}`,
+    "",
+    pc3.bold("Usage"),
+    ...group.usage.map((line) => `  ${line}`),
+    "",
+    pc3.bold("Commands"),
+    ...group.commands.map((entry) => commandLine(entry.command, entry.description))
+  ];
+  if (group.examples?.length) {
+    lines.push("", pc3.bold("Examples"), ...group.examples.map((line) => `  ${pc3.dim("$")} ${line}`));
+  }
+  if (group.next?.length) {
+    lines.push("", pc3.bold("Next steps"), ...group.next.map((line) => `  ${pc3.dim("\u203A")} ${line}`));
+  }
+  if (group.advanced?.length) {
+    lines.push("", pc3.bold("Compatibility / advanced"), ...group.advanced.map((line) => `  ${pc3.dim("\u203A")} ${line}`));
+  }
+  return lines.join(`
+`);
+}
+function renderTopLevelHelp() {
+  return [
+    `${heading("rig")} ${pc3.dim("\u2014 server-owned task/run control plane for Pi-backed engineering work")}`,
+    pc3.dim("The loop: pick a task, dispatch an agent, open its Pi console (`rig run attach <id>`) to watch and steer it live, clear inbox gates, merge."),
+    "",
+    ...TOP_LEVEL_SECTIONS.flatMap((section) => [
+      `${pc3.bold(pc3.magenta(`\u25C7 ${section.title}`))} \u2014 ${pc3.dim(section.subtitle)}`,
+      renderCommandBlock(section.commands),
+      ""
+    ]),
+    pc3.dim("More: `rig help --advanced` for dev/compatibility commands; `rig <group> --help` for rich per-group help; `rig --version` for the installed version."),
+    "",
+    pc3.bold("Global options"),
+    commandLine("--project <path>", "Use a project root instead of auto-discovery."),
+    commandLine("--json", "Emit structured output for scripts/agents."),
+    commandLine("--dry-run", "Print the command plan without mutating state.")
+  ].join(`
+`).trimEnd();
+}
+function renderGroupHelp(groupName) {
+  const group = ALL_GROUPS.find((candidate) => candidate.name === groupName);
+  return group ? renderGroup(group) : null;
+}
+function printGroupHelpDocument(groupName) {
+  console.log(renderGroupHelp(groupName) ?? renderTopLevelHelp());
+}
+var TOP_LEVEL_SECTIONS, PRIMARY_GROUPS, ADVANCED_GROUPS, ALL_GROUPS;
+var init__help_catalog = __esm(() => {
+  TOP_LEVEL_SECTIONS = [
+    {
+      title: "Pi console",
+      subtitle: "the operator surface \u2014 every attach opens the run's FULL Pi session",
+      commands: [
+        { command: "rig run attach <run-id>", description: "Open the run's Pi console: complete transcript (live AND finished runs), worker turns streaming in live." },
+        { command: "type a message", description: "Inside the console, plain text steers the worker mid-turn \u2014 it lands in the agent's context, not a local model." },
+        { command: "!<command>", description: "Inside the console, runs shell in the WORKER's workspace; output streams back into the transcript." },
+        { command: "/<command>", description: "The palette includes the WORKER session's slash commands ([worker]-tagged) next to /rig." },
+        { command: "/rig abort | /rig stop", description: "Abort the worker's current turn, or stop the whole run, from inside the console." },
+        { command: "rig run steer <id> --message <text>", description: "Steer without attaching \u2014 queue a message; the worker picks it up within seconds." }
+      ]
+    },
+    {
+      title: "Start here",
+      subtitle: "one-time setup, pick a server",
+      commands: [
+        { command: "rig init", description: "Wizard: config, GitHub auth, task source, server, Pi wiring." },
+        { command: "rig server use <alias|local>", description: "Pick which Rig server owns this repo (`rig server list` to see them)." },
+        { command: "rig server status", description: "Show the selected server for this repo." }
+      ]
+    },
+    {
+      title: "Work",
+      subtitle: "find a task, put an agent on it, answer what it asks",
+      commands: [
+        { command: "rig task list", description: "What's on the board (from the selected source/server)." },
+        { command: "rig task run --next", description: "Dispatch an agent on the next ready task; interactive mode drops you into its Pi console." },
+        { command: "rig run status", description: "Active and recent runs at a glance." },
+        { command: "rig run attach <id> --follow", description: "Same as plain attach \u2014 the Pi console is always the interactive surface." },
+        { command: "rig inbox approvals", description: "Approvals workers are waiting on (then `rig inbox approve \u2026`)." }
+      ]
+    },
+    {
+      title: "Watch",
+      subtitle: "fleet metrics and per-task forensics",
+      commands: [
+        { command: "rig stats [--since 7d]", description: "Fleet metrics: completion/failure rates, median run time, steering, stalls." },
+        { command: "rig inspect logs --task <id>", description: "Latest run log for a task." },
+        { command: "rig inspect diff --task <id>", description: "Changed files for a task." }
+      ]
+    },
+    {
+      title: "Unblock",
+      subtitle: "diagnose wiring, fix auth",
+      commands: [
+        { command: "rig doctor", description: "Check every part of the wiring \u2014 run this when anything feels off." },
+        { command: "rig github auth status", description: "GitHub auth state on the selected server." }
+      ]
+    },
+    {
+      title: "Extend",
+      subtitle: "plugins contribute validators, hooks, task sources, commands",
+      commands: [
+        { command: "rig plugin list", description: "What the rig.config.ts plugins contribute." },
+        { command: "rig plugin run <command-id>", description: "Execute a plugin-contributed CLI command." }
+      ]
+    }
+  ];
+  PRIMARY_GROUPS = [
+    {
+      name: "server",
+      summary: "Choose, inspect, and start the Rig server that owns tasks and runs.",
+      usage: ["rig server <status|list|add|use|start> [options]"],
+      commands: [
+        { command: "status", description: "Show the selected server for this repo.", primary: true },
+        { command: "use local", description: "Switch this repo to the local Rig server.", primary: true },
+        { command: "add <alias> <url>", description: "Save a remote Rig server URL.", primary: true },
+        { command: "use <alias>", description: "Select a saved remote server alias.", primary: true },
+        { command: "list", description: "List saved local/remote server aliases.", primary: true },
+        { command: "start [--host <host>] [--port <n>]", description: "Start a local rig-server process." }
+      ],
+      examples: [
+        "rig server status",
+        "rig server add prod https://where.rig-does.work",
+        "rig server use prod",
+        "rig server use local",
+        "rig server start --port 3773"
+      ],
+      next: ["Use `rig task list` to see server-owned work.", "Use `rig run list` or `rig run attach <id> --follow` to monitor runs."]
+    },
+    {
+      name: "task",
+      summary: "Find work, start Pi-backed runs, and validate task results.",
+      usage: ["rig task <list|next|show|run> [options]"],
+      commands: [
+        { command: "list [--assignee <login|me|@me>] [--state open|closed]", description: "List tasks from the selected server/source.", primary: true },
+        { command: "next [filters]", description: "Render the next matching task as a selected-task card.", primary: true },
+        { command: "show <id>|--task <id> [--raw]", description: "Show a human task summary; --raw prints the full payload.", primary: true },
+        { command: "run [#<issue>|<task-id>|--next|--task <id>]", description: "Submit a task run; interactive follows with bundled Pi.", primary: true },
+        { command: "ready", description: "List task IDs that are runnable now." },
+        { command: "validate|verify [--task <id>]", description: "Run configured task checks/review gates." },
+        { command: "details --task <id>", description: "Show full task info from the configured source." },
+        { command: "reopen [--task <id> | --all] [--reason <text>]", description: "Reopen closed task(s) in the configured source." },
+        { command: "artifacts|artifact-dir|artifact-write", description: "Inspect or write task artifacts." },
+        { command: "report-bug", description: "Create a structured bug report/task." }
+      ],
+      examples: [
+        "rig task list --assignee @me --limit 20",
+        "rig task next",
+        "rig task show 123 --raw",
+        "rig task run --next",
+        "rig task run #123 --runtime-adapter pi",
+        "rig task run --title 'Investigate deploy drift' --initial-prompt 'Check server health'"
+      ],
+      next: ["Use `--detach` to submit without attaching.", "Use `rig run attach <run-id> --follow` to rejoin a live run."]
+    },
+    {
+      name: "run",
+      summary: "Observe, attach to, and control Rig runs. `attach` opens the Pi console \u2014 the full worker session, live.",
+      usage: ["rig run <list|status|show|attach|steer|stop|resume|restart> [options]"],
+      commands: [
+        { command: "list", description: "List recent runs from the selected server or local state.", primary: true },
+        { command: "status", description: "Render active and recent run groups.", primary: true },
+        { command: "show <id>|--run <id> [--raw]", description: "Show a human run summary; --raw prints the full payload.", primary: true },
+        { command: "attach <run-id>|--run <id>", description: "Open the run's Pi console \u2014 see 'Inside the console' below. Works on live AND finished runs.", primary: true },
+        { command: "steer <run-id> --message <text>", description: "Queue a steering message into a live worker without attaching \u2014 delivered into the agent's context within seconds.", primary: true },
+        { command: "stop [<run-id>|--run <id>]", description: "Request stop for one run or local active runs.", primary: true },
+        { command: "resume [<run-id>]", description: "Resume an interrupted run on the selected server (defaults to the most recent resumable)." },
+        { command: "restart [<run-id>]", description: "Re-dispatch a run from a clean runtime, reopening its Pi session where possible." },
+        { command: "timeline --run <id> [--follow]", description: "Stream raw run timeline events (scripts; humans should attach)." },
+        { command: "replay <run-id>|--run <id> [--with-session]", description: "Print the run's consolidated run.jsonl as a merged timeline; --with-session interleaves the Pi session log." },
+        { command: "delete|cleanup", description: "Remove completed run records/artifacts." }
+      ],
+      examples: [
+        "rig run attach <run-id>          # full session console \u2014 live mirror, steering, worker shell",
+        "rig run steer <run-id> --message 'focus on the failing test first'",
+        "rig run list",
+        "rig run show <run-id>",
+        "rig run stop <run-id>"
+      ],
+      next: [
+        "Inside the console: the run's COMPLETE transcript loads on open (finished runs too), and new worker turns stream in live.",
+        "Inside the console: plain text = steering into the worker's context \xB7 !<cmd> = shell in the WORKER workspace \xB7 /<cmd> includes the worker session's commands \xB7 /rig abort stops the current turn.",
+        "The console is read-write but remote-only: nothing runs on your machine; the worker keeps running when you exit.",
+        "Use `rig task run --next` to create a new run; interactive mode drops you straight into its console.",
+        "Use `--json` when scripts need the full structured record."
+      ]
+    },
+    {
+      name: "inbox",
+      summary: "Review approval and user-input requests that block worker runs.",
+      usage: ["rig inbox <approvals|approve|inputs|respond> [options]"],
+      commands: [
+        { command: "approvals [--run <id>] [--task <id>]", description: "List pending approvals.", primary: true },
+        { command: "inputs [--run <id>] [--task <id>]", description: "List pending user-input requests.", primary: true },
+        { command: "approve --run <id> --request <id> --decision approve|reject", description: "Resolve an approval request." },
+        { command: "respond --run <id> --request <id> --answer key=value", description: "Answer a user-input request." }
+      ],
+      examples: [
+        "rig inbox approvals",
+        "rig inbox inputs --run <run-id>",
+        "rig inbox approve --run <run-id> --request <request-id> --decision approve"
+      ],
+      next: ["Rejoin the run after resolving a block: `rig run attach <run-id> --follow`."]
+    },
+    {
+      name: "stats",
+      summary: "Fleet metrics computed from on-disk run journals (no server required).",
+      usage: ["rig stats [show] [--since <7d|30d|ISO date>]"],
+      commands: [
+        { command: "show [--since <window>]", description: "Total runs, completion/failure/needs-attention rates, median run time, steering, stalls, approvals.", primary: true }
+      ],
+      examples: [
+        "rig stats",
+        "rig stats --since 7d",
+        "rig stats --since 2026-06-01 --json"
+      ],
+      next: ["Inspect outliers with `rig run list` and `rig run show <run-id>`.", "Use `--json` for the schema'd envelope (see docs/cli-json.md)."]
+    },
+    {
+      name: "inspect",
+      summary: "Inspect logs, artifacts, graphs, failures for a task.",
+      usage: ["rig inspect <logs|artifacts|failures|graph|audit|diff> --task <id>"],
+      commands: [
+        { command: "logs --task <id>", description: "Latest run log for a task (local or selected server).", primary: true },
+        { command: "artifacts --task <id>", description: "List the task's completion artifacts.", primary: true },
+        { command: "failures --task <id>", description: "Recorded failures for a task.", primary: true },
+        { command: "diff --task <id>", description: "Changed files for a task.", primary: true },
+        { command: "graph", description: "Task dependency graph." },
+        { command: "audit", description: "Controlled-command audit trail." }
+      ],
+      examples: ["rig inspect logs --task <id>", "rig inspect diff --task <id>"],
+      next: ["Use `rig stats` for fleet-level metrics across runs."]
+    },
+    {
+      name: "repo",
+      summary: "Repository sync/baseline helpers for the Rig-managed checkout.",
+      usage: ["rig repo <sync|reset-baseline>"],
+      commands: [
+        { command: "sync", description: "Sync project repository state.", primary: true },
+        { command: "reset-baseline", description: "Reset the managed baseline for the repo." }
+      ],
+      examples: ["rig repo sync"]
+    },
+    {
+      name: "plugin",
+      summary: "Plugin listing, validation, and plugin-contributed commands.",
+      usage: ["rig plugin <list|validate|run> [options]"],
+      commands: [
+        { command: "list", description: "List plugins declared in rig.config.ts and their contributions.", primary: true },
+        { command: "validate --task <id>", description: "Run plugin-contributed validators for a task.", primary: true },
+        { command: "run <command-id> [args...]", description: "Execute a plugin-contributed CLI command (also callable as `rig <command-id>`)." }
+      ],
+      examples: ["rig plugin list", "rig plugin run <command-id>"]
+    },
+    {
+      name: "init",
+      summary: "Set up Rig for this repo: server, GitHub auth, checkout strategy, task source, and Pi wiring.",
+      usage: ["rig init [--yes] [--server local|remote] [--repo owner/repo] [--remote-url <url>]"],
+      commands: [
+        { command: "init", description: "Interactive setup wizard for a new or existing Rig repo.", primary: true },
+        { command: "init --demo", description: "Offline demo project: files task source + 3 sample tasks, zero GitHub.", primary: true },
+        { command: "init --yes", description: "Non-interactive setup using detected/default settings.", primary: true },
+        { command: "init --server remote --remote-url <url>", description: "Link this repo to a remote Rig server.", primary: true },
+        { command: "init --repair", description: "Repair missing private state without replacing project config." }
+      ],
+      examples: [
+        "rig init",
+        "rig init --demo",
+        "rig init --yes --repo humanity-org/humanwork",
+        "rig init --server remote --remote-url https://where.rig-does.work --repo owner/repo"
+      ],
+      next: ["After init, run `rig server status`.", "Then use `rig task list` and `rig task run --next` for day-to-day work."]
+    },
+    {
+      name: "doctor",
+      summary: "Diagnostics for project/server/GitHub/Pi state.",
+      usage: ["rig doctor"],
+      commands: [
+        { command: "doctor", description: "Run setup and runtime diagnostics.", primary: true },
+        { command: "check", description: "Compatibility spelling for diagnostics." }
+      ],
+      examples: ["rig doctor", "rig doctor --json"],
+      next: ["Use `rig server status` and `rig github auth status` to inspect common failure points."]
+    },
+    {
+      name: "github",
+      summary: "GitHub auth helpers for the selected Rig server.",
+      usage: ["rig github auth <status|import-gh|token>"],
+      commands: [
+        { command: "auth status", description: "Show GitHub auth state.", primary: true },
+        { command: "auth import-gh", description: "Import the current `gh` token into the selected server." },
+        { command: "auth token --token <token>", description: "Store a token on the selected server." }
+      ],
+      examples: ["rig github auth status", "rig github auth import-gh"],
+      next: ["After auth is valid, use `rig task run --next`."]
+    }
+  ];
+  ADVANCED_GROUPS = [
+    { name: "setup", summary: "Bootstrap/check local setup.", usage: ["rig setup <bootstrap|check|preflight>"], commands: [{ command: "bootstrap|check|preflight", description: "Setup helpers." }] },
+    { name: "profile", summary: "Runtime profile/model defaults.", usage: ["rig profile <show|set>"], commands: [{ command: "show", description: "Show active profile." }] },
+    {
+      name: "review",
+      summary: "Inspect or change completion review gate policy.",
+      usage: ["rig review <show|set>"],
+      commands: [
+        { command: "show", description: "Show current review gate settings." },
+        { command: "set <off|advisory|required> [--provider greptile]", description: "Change review strictness/provider." }
+      ],
+      examples: ["rig review show", "rig review set required --provider greptile"],
+      next: ["Use `rig inbox approvals` for blocked run handoffs."]
+    },
+    {
+      name: "browser",
+      summary: "Browser/app diagnostics for browser-required tasks.",
+      usage: ["rig browser <help|explain|demo|app|hp-next> [options]"],
+      commands: [
+        { command: "help", description: "Rich browser command help (canonical: `rig browser help`)." },
+        { command: "explain", description: "Explain the browser-required task contract." },
+        { command: "demo", description: "Run browser demo flows against a local page." },
+        { command: "app", description: "Launch the Rig Browser workstation app." },
+        { command: "hp-next <dev|check|e2e|reset>", description: "Drive the hp-next browser test harness." }
+      ]
+    },
+    {
+      name: "pi",
+      summary: "Manage Pi extension packages for this project (community extensions from npm/git).",
+      usage: ["rig pi <list|add|remove|search> [args]"],
+      commands: [
+        { command: "list", description: "Show project and user Pi extension packages." },
+        { command: "add <source>", description: "Add an npm/git Pi extension to .pi/settings.json (auto-installs at next session)." },
+        { command: "remove <source>", description: "Remove an operator-added Pi extension." },
+        { command: "search [term]", description: "Discover Pi extension packages on the npm registry." }
+      ],
+      examples: ["rig pi search subagents", "rig pi add pi-subagents", "rig pi list"],
+      next: ["Config-managed extensions: declare `runtime: { pi: { packages: [...] } }` in rig.config.ts \u2014 workers pick them up automatically."]
+    },
+    { name: "queue", summary: "Run task queues locally.", usage: ["rig queue run [options]"], commands: [{ command: "run", description: "Process queue work." }] },
+    { name: "agent", summary: "Runtime agent workspace helpers.", usage: ["rig agent <list|prepare|run|cleanup>"], commands: [{ command: "list", description: "List prepared agents." }] },
+    { name: "inspector", summary: "Event stream and drift scanners.", usage: ["rig inspector <stream|scan-upstream-drift>"], commands: [{ command: "stream", description: "Stream events." }] },
+    { name: "dist", summary: "Build/install packaged Rig CLI.", usage: ["rig dist <build|install|doctor>"], commands: [{ command: "build", description: "Build distribution." }] },
+    { name: "workspace", summary: "Workspace topology/service helpers.", usage: ["rig workspace <summary|topology|remote-hosts>"], commands: [{ command: "summary", description: "Show workspace summary." }] },
+    { name: "remote", summary: "Compatibility remote orchestration controls.", usage: ["rig remote <status|watch|pause|resume|...>"], commands: [{ command: "status", description: "Show remote state." }] },
+    { name: "git", summary: "Pass through to Rig git-flow helper.", usage: ["rig git <args...>"], commands: [{ command: "<args...>", description: "Advanced git flow operations." }] },
+    { name: "harness", summary: "Pass through to runtime harness CLI.", usage: ["rig harness <args...>"], commands: [{ command: "<args...>", description: "Advanced harness operations." }] },
+    { name: "test", summary: "Project test wrappers.", usage: ["rig test <unit|e2e|all>"], commands: [{ command: "all", description: "Run configured project tests." }] }
+  ];
+  ALL_GROUPS = [...PRIMARY_GROUPS, ...ADVANCED_GROUPS];
+});
+
+// packages/cli/src/commands/task.ts
+var exports_task = {};
+__export(exports_task, {
+  loadTaskRunProjectDefaults: () => loadTaskRunProjectDefaults,
+  executeTask: () => executeTask
+});
+import { readFileSync as readFileSync4 } from "fs";
+import { spawnSync } from "child_process";
+import { resolve as resolve3 } from "path";
+import {
+  taskArtifactDir,
+  taskArtifacts,
+  taskArtifactWrite,
+  taskDeps,
+  taskInfo,
+  taskLookup,
+  taskReady,
+  taskRecord,
+  taskReopen,
+  taskScope,
+  taskStatus as taskStatus2,
+  taskValidate,
+  taskVerify
+} from "@rig/runtime/control-plane/native/task-ops";
+import { buildPluginHostContext } from "@rig/runtime/control-plane/plugin-host-context";
+import { loadConfig } from "@rig/core/load-config";
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function normalizeAssigneeAlias(value) {
+  if (!value)
+    return;
+  return value.trim().toLowerCase() === "me" ? "@me" : value;
+}
+function parseTaskFilters(args) {
+  let pending = args;
+  const assigneeResult = takeOption(pending, "--assignee");
+  pending = assigneeResult.rest;
+  const stateResult = takeOption(pending, "--state");
+  pending = stateResult.rest;
+  const statusResult = takeOption(pending, "--status");
+  pending = statusResult.rest;
+  const limitResult = takeOption(pending, "--limit");
+  pending = limitResult.rest;
+  const assignee = normalizeAssigneeAlias(assigneeResult.value);
+  const limit = (() => {
+    if (!limitResult.value)
+      return;
+    const parsed = Number.parseInt(limitResult.value, 10);
+    if (!Number.isFinite(parsed) || parsed < 1) {
+      throw new CliError("--limit must be a positive integer.", 2, { hint: "Re-run with a positive number, e.g. `rig task list --limit 20`." });
+    }
+    return parsed;
+  })();
+  const filters = {
+    ...assignee ? { assignee } : {},
+    ...stateResult.value ? { state: stateResult.value } : {},
+    ...statusResult.value ? { status: statusResult.value } : {},
+    ...limit !== undefined ? { limit } : {}
+  };
+  return { filters, rest: pending };
+}
+function mapConfiguredRuntimeMode(mode) {
+  if (!mode)
+    return;
+  return mode === "yolo" ? "full-access" : mode;
+}
+async function loadTaskRunProjectDefaults(projectRoot) {
+  try {
+    const config = await loadConfig(projectRoot);
+    return {
+      runtimeAdapter: config.runtime?.harness,
+      model: config.runtime?.model,
+      runtimeMode: mapConfiguredRuntimeMode(config.runtime?.mode),
+      prMode: config.pr?.mode
+    };
+  } catch {
+    return {};
+  }
+}
+function normalizePrMode(value) {
+  if (!value)
+    return;
+  if (value === "auto" || value === "ask" || value === "off")
+    return value;
+  throw new CliError("--pr must be auto, ask, or off.", 2, { hint: "Re-run with `--pr auto|ask|off`, or pass `--no-pr` to disable the PR." });
+}
+function detectLocalDirtyState(projectRoot) {
+  const result = spawnSync("git", ["-C", projectRoot, "status", "--porcelain"], { encoding: "utf8", timeout: 5000 });
+  if (result.status !== 0)
+    return { dirty: false, modified: 0, untracked: 0, lines: [] };
+  const lines = result.stdout.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean);
+  return {
+    dirty: lines.length > 0,
+    modified: lines.filter((line) => !line.startsWith("?? ")).length,
+    untracked: lines.filter((line) => line.startsWith("?? ")).length,
+    lines
+  };
+}
+function selectedServerKind(projectRoot) {
+  try {
+    return resolveSelectedConnection(projectRoot)?.connection.kind === "remote" ? "remote" : "local";
+  } catch {
+    return "local";
+  }
+}
+async function resolveDirtyBaselineForTaskRun(context, explicit) {
+  if (explicit && explicit !== "head" && explicit !== "dirty-snapshot") {
+    throw new CliError("--dirty-baseline must be head or dirty-snapshot.", 2, { hint: "Re-run with `--dirty-baseline head` or `--dirty-baseline dirty-snapshot`." });
+  }
+  if (selectedServerKind(context.projectRoot) !== "local") {
+    return { mode: explicit === "dirty-snapshot" ? "dirty-snapshot" : "head", state: null };
+  }
+  const state = detectLocalDirtyState(context.projectRoot);
+  if (!state.dirty)
+    return { mode: "head", state };
+  if (context.outputMode === "text") {
+    console.log(`Repo state: dirty (${state.modified} modified, ${state.untracked} untracked).`);
+  }
+  if (explicit)
+    return { mode: explicit, state };
+  if (context.outputMode === "text" && process.stdin.isTTY && process.stdout.isTTY) {
+    const answer = await droneConfirm({
+      message: "Include current uncommitted changes in run baseline?",
+      initialValue: false
+    });
+    if (answer === null) {
+      droneCancel("Run cancelled.");
+      throw new CliError("Run cancelled by user.", 1);
+    }
+    return { mode: answer ? "dirty-snapshot" : "head", state };
+  }
+  return { mode: "head", state };
+}
+function normalizeTaskRunTaskId(value) {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed)
+    return null;
+  const issueNumber = trimmed.match(/^#(\d+)$/)?.[1];
+  return issueNumber ?? trimmed;
+}
+function readTaskId(task) {
+  return typeof task.id === "string" && task.id.trim().length > 0 ? task.id : null;
+}
+function readTaskString(task, key) {
+  const value = task[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function summarizeTask(task, options = {}) {
+  const raw = task.raw && typeof task.raw === "object" && !Array.isArray(task.raw) ? task.raw : null;
+  return {
+    id: readTaskId(task),
+    title: readTaskString(task, "title"),
+    status: readTaskString(task, "status"),
+    source: typeof task.source === "string" ? task.source : undefined,
+    url: typeof raw?.url === "string" ? raw.url : undefined,
+    number: typeof raw?.number === "number" ? raw.number : undefined,
+    labels: Array.isArray(task.labels) ? task.labels : Array.isArray(raw?.labels) ? raw.labels : undefined,
+    assignees: Array.isArray(raw?.assignees) ? raw.assignees : undefined,
+    readiness: typeof task.readiness === "string" || typeof task.readiness === "boolean" ? task.readiness : undefined,
+    validators: Array.isArray(task.validators) ? task.validators : Array.isArray(task.validation) ? task.validation : undefined,
+    ...options.raw ? { raw: raw ?? task } : {}
+  };
+}
+async function validatorRegistryForTaskCommands(projectRoot) {
+  return buildPluginHostContext(projectRoot).then((ctx) => ctx?.validatorRegistry ?? undefined).catch(() => {
+    return;
+  });
+}
+async function executeTask(context, args, options) {
+  if (args.length === 0) {
+    if (context.outputMode === "text") {
+      printGroupHelpDocument("task");
+    }
+    return { ok: true, group: "task", command: "help" };
+  }
+  const [command = "help", ...rest] = args;
+  switch (command) {
+    case "list": {
+      let pending = rest;
+      const rawResult = takeFlag(pending, "--raw");
+      pending = rawResult.rest;
+      const { filters, rest: remaining } = parseTaskFilters(pending);
+      requireNoExtraArgs(remaining, "rig task list [--raw] [--assignee <login|me|@me>] [--state open|closed] [--status <status>] [--limit <n>]");
+      const tasks = await withSpinner("Reading tasks from server\u2026", () => listWorkspaceTasksViaServer(context, filters), { outputMode: context.outputMode });
+      if (context.outputMode === "text") {
+        const renderedTasks = rawResult.value ? tasks.map((task) => summarizeTask(task, { raw: true })) : tasks.map((task) => summarizeTask(task));
+        printFormattedOutput(formatTaskList(renderedTasks, { raw: rawResult.value }));
+        await printPendingInboxFooter(context);
+      }
+      return {
+        ok: true,
+        group: "task",
+        command,
+        details: { count: tasks.length, filters, raw: rawResult.value, tasks: tasks.map((task) => summarizeTask(task, { raw: rawResult.value })) }
+      };
+    }
+    case "show": {
+      let pending = rest;
+      const rawResult = takeFlag(pending, "--raw");
+      pending = rawResult.rest;
+      const taskOption = takeOption(pending, "--task");
+      const positional = taskOption.rest.length > 0 && taskOption.rest[0] && !taskOption.rest[0].startsWith("-") ? taskOption.rest[0] : undefined;
+      const remaining = positional ? taskOption.rest.slice(1) : taskOption.rest;
+      requireNoExtraArgs(remaining, "rig task show <id>|--task <id> [--raw]");
+      const taskId3 = normalizeTaskRunTaskId(taskOption.value ?? positional);
+      if (!taskId3)
+        throw new CliError("task show requires a task id.", 2, { hint: "Run `rig task list` to find ids, then `rig task show <id>`." });
+      const task = await withSpinner(`Reading task ${taskId3} from server\u2026`, () => getWorkspaceTaskViaServer(context, taskId3), { outputMode: context.outputMode });
+      if (!task)
+        throw new CliError(`Task not found: ${taskId3}`, 3, { hint: "Run `rig task list` to see available tasks." });
+      const summary = summarizeTask(task, { raw: true });
+      if (context.outputMode === "text") {
+        printFormattedOutput(rawResult.value ? JSON.stringify(summary, null, 2) : formatTaskDetails(summary));
+      }
+      return { ok: true, group: "task", command, details: { task: summary, raw: rawResult.value } };
+    }
+    case "next": {
+      const { filters, rest: remaining } = parseTaskFilters(rest);
+      requireNoExtraArgs(remaining, "rig task next [--assignee <login|me|@me>] [--state open|closed] [--status <status>] [--limit <n>]");
+      const selected = await withSpinner("Selecting next ready task\u2026", () => selectNextWorkspaceTaskViaServer(context, filters), { outputMode: context.outputMode });
+      if (context.outputMode === "text") {
+        if (selected.task) {
+          printFormattedOutput(formatTaskCard(summarizeTask(selected.task, { raw: true }), { title: "Selected task", selected: true }));
+        } else {
+          printFormattedOutput("No matching tasks.\n\nNext\n\u203A Try `rig task list` to inspect available work.\n\u203A Check server: `rig server status`");
+        }
+      }
+      return {
+        ok: true,
+        group: "task",
+        command,
+        details: {
+          count: selected.count,
+          filters,
+          task: selected.task ? summarizeTask(selected.task) : null
+        }
+      };
+    }
+    case "info": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "rig task info [--task <task-id>]");
+      await withMutedConsole(context.outputMode === "json", () => taskInfo(context.projectRoot, task || undefined));
+      return { ok: true, group: "task", command, details: { task: task || null } };
+    }
+    case "scope": {
+      const filesFlag = takeFlag(rest, "--files");
+      const { value: task, rest: remaining } = takeOption(filesFlag.rest, "--task");
+      requireNoExtraArgs(remaining, "rig task scope [--task <id>] [--files]");
+      await withMutedConsole(context.outputMode === "json", () => taskScope(context.projectRoot, filesFlag.value, task || undefined));
+      return { ok: true, group: "task", command, details: { files: filesFlag.value, task: task || null } };
+    }
+    case "deps":
+      requireNoExtraArgs(rest, "rig task deps");
+      await withMutedConsole(context.outputMode === "json", () => taskDeps(context.projectRoot));
+      return { ok: true, group: "task", command };
+    case "status":
+      requireNoExtraArgs(rest, "rig task status");
+      withMutedConsole(context.outputMode === "json", () => taskStatus2(context.projectRoot));
+      return { ok: true, group: "task", command };
+    case "artifacts":
+      requireNoExtraArgs(rest, "rig task artifacts");
+      withMutedConsole(context.outputMode === "json", () => taskArtifacts(context.projectRoot));
+      return { ok: true, group: "task", command };
+    case "artifact-dir": {
+      requireNoExtraArgs(rest, "rig task artifact-dir");
+      const path = taskArtifactDir(context.projectRoot);
+      if (context.outputMode === "text") {
+        console.log(path);
+      }
+      return { ok: true, group: "task", command, details: { path } };
+    }
+    case "artifact-write": {
+      if (rest.length < 1) {
+        throw new CliError(`Usage: rig task artifact-write <filename> [--file <path>]
+` + `  Reads content from stdin (or --file), writes to the active task artifact dir.
+` + "  Example: echo '...' | rig task artifact-write collection-audit.md");
+      }
+      const artifactFilename = rest[0];
+      const fileFlag = takeOption(rest.slice(1), "--file");
+      let content;
+      if (fileFlag.value) {
+        content = readFileSync4(resolve3(context.projectRoot, fileFlag.value), "utf-8");
+      } else {
+        content = await readStdin();
+      }
+      if (!artifactFilename) {
+        throw new CliError("Usage: rig task artifact-write <filename> [--file path]");
+      }
+      withMutedConsole(context.outputMode === "json", () => taskArtifactWrite(context.projectRoot, artifactFilename, content));
+      return { ok: true, group: "task", command, details: { filename: artifactFilename } };
+    }
+    case "report-bug":
+      return options.executeTaskReportBug(context, rest);
+    case "lookup": {
+      if (rest.length !== 1) {
+        throw new CliError("Usage: rig task lookup <task-id>");
+      }
+      const lookupId = rest[0];
+      if (!lookupId) {
+        throw new CliError("Usage: rig task lookup <task-id>");
+      }
+      const result = taskLookup(context.projectRoot, lookupId);
+      if (context.outputMode === "text") {
+        console.log(result);
+      }
+      return { ok: true, group: "task", command, details: { id: lookupId, result } };
+    }
+    case "record": {
+      if (rest.length < 2) {
+        throw new CliError("Usage: rig task record <decision|failure> <text>");
+      }
+      const type = rest[0];
+      if (type !== "decision" && type !== "failure") {
+        throw new CliError("Usage: rig task record <decision|failure> <text>");
+      }
+      withMutedConsole(context.outputMode === "json", () => taskRecord(context.projectRoot, type, rest.slice(1).join(" ")));
+      return { ok: true, group: "task", command, details: { type: rest[0] } };
+    }
+    case "ready":
+      requireNoExtraArgs(rest, "rig task ready");
+      await withMutedConsole(context.outputMode === "json", () => taskReady(context.projectRoot));
+      return { ok: true, group: "task", command };
+    case "run": {
+      let pending = rest;
+      const nextResult = takeFlag(pending, "--next");
+      pending = nextResult.rest;
+      const taskResult = takeOption(pending, "--task");
+      pending = taskResult.rest;
+      const titleResult = takeOption(pending, "--title");
+      pending = titleResult.rest;
+      const runtimeAdapterResult = takeOption(pending, "--runtime-adapter");
+      pending = runtimeAdapterResult.rest;
+      const modelResult = takeOption(pending, "--model");
+      pending = modelResult.rest;
+      const runtimeModeResult = takeOption(pending, "--runtime-mode");
+      pending = runtimeModeResult.rest;
+      const interactionModeResult = takeOption(pending, "--interaction-mode");
+      pending = interactionModeResult.rest;
+      const initialPromptResult = takeOption(pending, "--initial-prompt");
+      pending = initialPromptResult.rest;
+      const prResult = takeOption(pending, "--pr");
+      pending = prResult.rest;
+      const noPrResult = takeFlag(pending, "--no-pr");
+      pending = noPrResult.rest;
+      const dirtyBaselineResult = takeOption(pending, "--dirty-baseline");
+      pending = dirtyBaselineResult.rest;
+      const skipProjectSyncResult = takeFlag(pending, "--skip-project-sync");
+      pending = skipProjectSyncResult.rest;
+      const detachResult = takeFlag(pending, "--detach");
+      pending = detachResult.rest;
+      const filterResult = parseTaskFilters(pending);
+      pending = filterResult.rest;
+      const positionalTaskId = pending.length > 0 && pending[0] && !pending[0].startsWith("-") ? normalizeTaskRunTaskId(pending[0]) : null;
+      if (positionalTaskId) {
+        pending = pending.slice(1);
+      }
+      requireNoExtraArgs(pending, "rig task run [#<issue>|<task-id>] [--next] [--task <id>] [--detach] [--assignee <login|me|@me>] [--state open|closed] [--status <status>] [--limit <n>] [--title <text>] [--runtime-adapter claude-code|codex|pi] [--model <model>] [--runtime-mode <mode>] [--interaction-mode <mode>] [--initial-prompt <text>] [--pr auto|ask|off] [--no-pr] [--dirty-baseline head|dirty-snapshot] [--skip-project-sync]");
+      if (nextResult.value && (taskResult.value || positionalTaskId)) {
+        throw new CliError("task run cannot combine --next with an explicit task id.", 2, { hint: "Use either `rig task run --next` or `rig task run <id>`." });
+      }
+      if (taskResult.value && positionalTaskId) {
+        throw new CliError("task run cannot combine positional task id with --task <id>.", 2, { hint: "Pass the id once, e.g. `rig task run <id>`." });
+      }
+      if (prResult.value && noPrResult.value) {
+        throw new CliError("task run cannot combine --pr with --no-pr.", 2, { hint: "Use `--pr auto|ask|off` or `--no-pr`, not both." });
+      }
+      let selectedTask = null;
+      let selectedTaskId = normalizeTaskRunTaskId(taskResult.value) ?? positionalTaskId;
+      if (nextResult.value) {
+        const selected = await withSpinner("Selecting next ready task\u2026", () => selectNextWorkspaceTaskViaServer(context, filterResult.filters), { outputMode: context.outputMode });
+        selectedTask = selected.task;
+        selectedTaskId = selected.task ? readTaskId(selected.task) : null;
+        if (!selectedTaskId) {
+          throw new CliError("No matching task found for task run --next.", 3, { hint: "Run `rig task list` to inspect available work, or relax the filters." });
+        }
+      }
+      if (!selectedTaskId && !initialPromptResult.value && !titleResult.value) {
+        if (context.outputMode !== "text" || !process.stdin.isTTY || !process.stdout.isTTY) {
+          throw new CliError("task run requires an interactive terminal to pick a task; pass --next, --task <id>, or --initial-prompt/--title for an ad hoc run.", 2);
+        }
+        const tasks = await withSpinner("Reading tasks from server\u2026", () => listWorkspaceTasksViaServer(context, filterResult.filters), { outputMode: context.outputMode });
+        selectedTask = await selectTaskWithTextPicker(tasks);
+        selectedTaskId = selectedTask ? readTaskId(selectedTask) : null;
+        if (!selectedTaskId) {
+          throw new CliError("No task selected.", 3, { hint: "Run `rig task run --next` for the next ready task, or `rig task run --task <id>`." });
+        }
+      }
+      await runProjectMainSyncPreflight(context, { disabled: skipProjectSyncResult.value });
+      const projectDefaults = await loadTaskRunProjectDefaults(context.projectRoot);
+      const runtimeAdapter = normalizeRuntimeAdapter(runtimeAdapterResult.value ?? projectDefaults.runtimeAdapter);
+      await withSpinner("Running task-run preflight\u2026", () => runFastTaskRunPreflight(context, {
+        taskId: selectedTaskId,
+        runtimeAdapter
+      }), { outputMode: context.outputMode });
+      const dirtyBaseline = await resolveDirtyBaselineForTaskRun(context, dirtyBaselineResult.value);
+      const prMode = noPrResult.value ? "off" : normalizePrMode(prResult.value) ?? projectDefaults.prMode;
+      const submitted = await withSpinner("Dispatching run\u2026", () => submitTaskRunViaServer(context, {
+        runId: context.runId,
+        taskId: selectedTaskId ?? undefined,
+        title: titleResult.value ?? undefined,
+        runtimeAdapter,
+        model: modelResult.value ?? projectDefaults.model,
+        runtimeMode: runtimeModeResult.value || projectDefaults.runtimeMode || "full-access",
+        interactionMode: interactionModeResult.value || "default",
+        initialPrompt: initialPromptResult.value ?? undefined,
+        baselineMode: dirtyBaseline.mode,
+        prMode
+      }), { outputMode: context.outputMode });
+      let attachDetails = null;
+      if (!detachResult.value && context.outputMode === "text") {
+        printFormattedOutput(formatSubmittedRun({
+          runId: submitted.runId,
+          task: selectedTask ? summarizeTask(selectedTask) : null,
+          runtimeAdapter,
+          runtimeMode: runtimeModeResult.value || projectDefaults.runtimeMode || "full-access",
+          interactionMode: interactionModeResult.value || "default",
+          detached: false
+        }));
+        attachDetails = await attachRunOperatorView(context, { runId: submitted.runId, follow: true });
+      } else if (context.outputMode === "text") {
+        printFormattedOutput(formatSubmittedRun({
+          runId: submitted.runId,
+          task: selectedTask ? summarizeTask(selectedTask) : null,
+          runtimeAdapter,
+          runtimeMode: runtimeModeResult.value || projectDefaults.runtimeMode || "full-access",
+          interactionMode: interactionModeResult.value || "default",
+          detached: true
+        }));
+      }
+      return {
+        ok: true,
+        group: "task",
+        command,
+        details: {
+          runId: submitted.runId,
+          taskId: selectedTaskId,
+          title: titleResult.value ?? null,
+          selectedTask: selectedTask ? summarizeTask(selectedTask) : null,
+          filters: nextResult.value ? filterResult.filters : undefined,
+          attached: Boolean(attachDetails),
+          attach: attachDetails,
+          runtimeAdapter,
+          model: modelResult.value ?? projectDefaults.model ?? null,
+          runtimeMode: runtimeModeResult.value || projectDefaults.runtimeMode || "full-access",
+          prMode: prMode ?? null,
+          dirtyBaseline: { mode: dirtyBaseline.mode, dirty: dirtyBaseline.state?.dirty ?? false }
+        }
+      };
+    }
+    case "validate": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "rig task validate [--task <task-id>]");
+      if (context.dryRun) {
+        await context.runCommand(["rig", "task", "validate", ...task ? ["--task", task] : []]);
+        return { ok: true, group: "task", command, details: { task: task || "active" } };
+      }
+      const ok = await withMutedConsole(context.outputMode === "json", async () => taskValidate(context.projectRoot, task || undefined, await validatorRegistryForTaskCommands(context.projectRoot)));
+      if (!ok) {
+        throw new CliError(`Validation failed for ${task || "active task"}.`, 2, { hint: "Inspect failures with `rig inspect failures --task <id>`, fix, then re-run `rig task validate --task <id>`." });
+      }
+      return { ok: true, group: "task", command, details: { task: task || "active" } };
+    }
+    case "verify": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "rig task verify [--task <task-id>]");
+      if (context.dryRun) {
+        await context.runCommand(["rig", "task", "verify", ...task ? ["--task", task] : []]);
+        return { ok: true, group: "task", command, details: { task: task || "active" } };
+      }
+      const ok = await withMutedConsole(context.outputMode === "json", () => taskVerify(context.projectRoot, task || undefined));
+      if (!ok) {
+        throw new CliError(`Verification rejected for ${task || "active task"}.`, 2, { hint: "Check `rig inspect logs --task <id>`, address the rejection, then re-run `rig task verify --task <id>`." });
+      }
+      return { ok: true, group: "task", command, details: { task: task || "active" } };
+    }
+    case "details": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "rig task details --task <task-id>");
+      const requiredTask = requireTask(task, "rig task details --task <task-id>");
+      await withMutedConsole(context.outputMode === "json", () => taskInfo(context.projectRoot, requiredTask));
+      return { ok: true, group: "task", command, details: { task: requiredTask } };
+    }
+    case "reopen": {
+      const { value: task, rest: rest1 } = takeOption(rest, "--task");
+      const allFlag = takeFlag(rest1, "--all");
+      const { rest: remaining } = takeOption(allFlag.rest, "--reason");
+      requireNoExtraArgs(remaining, "rig task reopen [--task <id> | --all] [--reason <text>]");
+      if (!allFlag.value && !task) {
+        throw new CliError("Usage: rig task reopen [--task <id> | --all] [--reason <text>]");
+      }
+      const summary = withMutedConsole(context.outputMode === "json", () => taskReopen(context.projectRoot, {
+        all: allFlag.value,
+        taskId: task || undefined,
+        dryRun: false
+      }));
+      return { ok: true, group: "task", command, details: summary };
+    }
+    default:
+      if (command === "reset") {
+        throw new CliError("Unknown task command: reset", 1, { hint: "Use `rig task reopen --task <id>`." });
+      }
+      throw new CliError(`Unknown task command: ${command}`, 1, { hint: "Run `rig task --help` to list available task commands." });
+  }
+}
+var init_task = __esm(() => {
+  init_drone_ui();
+  init_runner();
+  init__authority_runs();
+  init__preflight();
+  init__server_client();
+  init__task_picker();
+  init__async_ui();
+  init__operator_view();
+  init__cli_format();
+  init_inbox();
+  init__help_catalog();
+  init__connection_state();
+});
+
+// packages/cli/src/app-opentui/adapters/tasks.ts
+import { randomUUID } from "crypto";
+
+// packages/cli/src/app-opentui/adapters/common.ts
+function adapterContextFromRuntime(runtime, renderer) {
+  return {
+    projectRoot: runtime.getState().projectRoot,
+    renderer,
+    ensureRuntime: () => runtime.getRunnerContext(),
+    emit: (event) => runtime.emit(event),
+    getState: () => runtime.getState()
+  };
+}
+function projectRootOf(ctx) {
+  const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
+  if (typeof root === "string" && root.trim())
+    return root;
+  throw new Error("Rig 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("Rig 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 });
+}
+function patchFooter(ctx, footer) {
+  ctx.emit({ type: "footer.patch", footer });
+}
+function stringField(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+      return String(value);
+  }
+  return fallback;
+}
+function compactRecord(record, keys) {
+  const out = {};
+  for (const key of keys) {
+    const value = record[key];
+    if (value !== undefined && value !== null && value !== "")
+      out[key] = value;
+  }
+  return out;
+}
+function payloadString(intent, key) {
+  const value = intent.action.payload?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+// packages/cli/src/app-opentui/adapters/tasks.ts
+function createTasksAdapter() {
+  return {
+    id: "tasks",
+    async handleIntent(runtime, intent) {
+      if (intent.scene !== "tasks" && intent.action.kind !== "task-run-next" && intent.action.kind !== "task-run-id")
+        return false;
+      const ctx = adapterContextFromRuntime(runtime);
+      if (intent.action.kind === "task-run-next") {
+        await submitNextTaskRun(ctx);
+        return true;
+      }
+      if (intent.action.kind === "task-run-id") {
+        await submitTaskRun(ctx, { taskId: payloadString(intent, "task") });
+        return true;
+      }
+      if (intent.action.kind === "refresh" || intent.action.kind === "navigate") {
+        await refreshTasks(ctx, { limit: 20 });
+        return true;
+      }
+      return false;
+    }
+  };
+}
+function rawRecord(record, key) {
+  const direct = record[key];
+  if (direct !== undefined && direct !== null)
+    return direct;
+  const raw = record.raw;
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? raw[key] : undefined;
+}
+function optionalString(record, keys) {
+  for (const key of keys) {
+    const value = rawRecord(record, key);
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+      return String(value);
+  }
+  return;
+}
+function optionalNumber(record, keys) {
+  for (const key of keys) {
+    const value = rawRecord(record, key);
+    if (typeof value === "number" && Number.isFinite(value))
+      return value;
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed))
+        return parsed;
+    }
+  }
+  return;
+}
+function stringList(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (typeof entry === "string" && entry.trim())
+      return [entry.trim()];
+    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+      const record = entry;
+      const name = typeof record.name === "string" ? record.name : typeof record.login === "string" ? record.login : undefined;
+      return name?.trim() ? [name.trim()] : [];
+    }
+    return [];
+  });
+}
+function labelsFor(record) {
+  return stringList(rawRecord(record, "labels"));
+}
+function assigneesFor(record) {
+  return stringList(rawRecord(record, "assignees"));
+}
+function normalizeTaskRecord(record) {
+  const id = stringField(record, ["id", "taskId", "number"]);
+  if (!id)
+    return null;
+  const priority = optionalNumber(record, ["priority", "rank", "score"]);
+  const updatedAt = optionalString(record, ["updatedAt", "updated_at", "modifiedAt"]);
+  const createdAt = optionalString(record, ["createdAt", "created_at"]);
+  return {
+    id,
+    status: stringField(record, ["status", "state"], "unknown"),
+    title: stringField(record, ["title", "name", "summary"], "Untitled task"),
+    ...priority !== undefined ? { priority } : {},
+    ...updatedAt ? { updatedAt } : {},
+    ...createdAt ? { createdAt } : {},
+    labels: labelsFor(record),
+    assignees: assigneesFor(record),
+    raw: record
+  };
+}
+function currentTaskView(ctx) {
+  const value = ctx.getState().data?.tasks;
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function taskPayload(ctx) {
+  const intent = ctx.getState().data?.lastIntent;
+  return intent && typeof intent === "object" && !Array.isArray(intent) ? intent.action?.payload ?? {} : {};
+}
+function stringPayload(payload, key) {
+  const value = payload[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function numericPayload(payload, key) {
+  const value = payload[key];
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return;
+}
+function normalizeSort(value, fallback = "priority") {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "recent" || normalized === "recency" || normalized === "updated" || normalized === "updated-at")
+    return "recency";
+  if (normalized === "status" || normalized === "state")
+    return "status";
+  if (normalized === "id" || normalized === "number")
+    return "id";
+  if (normalized === "priority" || normalized === "prio" || normalized === "rank")
+    return "priority";
+  return fallback;
+}
+function normalizeAssigneeAlias2(value) {
+  if (!value)
+    return;
+  const trimmed = value.trim();
+  return trimmed.toLowerCase() === "me" ? "@me" : trimmed;
+}
+function filtersFromPreset(preset) {
+  switch (preset?.trim().toLowerCase()) {
+    case "all":
+      return { preset: "all" };
+    case "ready":
+      return { preset: "ready", status: "ready" };
+    case "blocked":
+      return { preset: "blocked", status: "blocked" };
+    case "closed":
+    case "done":
+      return { preset: "closed", state: "closed" };
+    case "mine":
+    case "me":
+      return { preset: "mine", state: "open", assignee: "@me" };
+    case "open":
+    case undefined:
+    case "":
+      return { preset: "open", state: "open" };
+    default:
+      return { preset: "custom", status: preset };
+  }
+}
+function effectiveTaskViewOptions(ctx, input = {}) {
+  const current = currentTaskView(ctx);
+  const payload = taskPayload(ctx);
+  const preset = input.preset ?? stringPayload(payload, "taskFilterPreset");
+  const baseFilters = preset !== undefined ? filtersFromPreset(preset) : current?.filters ?? filtersFromPreset("open");
+  const payloadLimit = numericPayload(payload, "taskLimit");
+  const mergedFilters = {
+    ...baseFilters,
+    ...input,
+    ...stringPayload(payload, "taskState") ? { state: stringPayload(payload, "taskState") } : {},
+    ...stringPayload(payload, "taskStatus") ? { status: stringPayload(payload, "taskStatus") } : {},
+    ...stringPayload(payload, "taskAssignee") ? { assignee: stringPayload(payload, "taskAssignee") } : {},
+    ...stringPayload(payload, "taskLabel") ? { label: stringPayload(payload, "taskLabel") } : {},
+    ...stringPayload(payload, "taskSearch") ? { search: stringPayload(payload, "taskSearch") } : {},
+    ...payloadLimit ? { limit: payloadLimit } : {}
+  };
+  const normalizedFilters = {
+    ...mergedFilters,
+    ...mergedFilters.assignee ? { assignee: normalizeAssigneeAlias2(mergedFilters.assignee) } : {}
+  };
+  const filters = !normalizedFilters.state && !normalizedFilters.status && !normalizedFilters.assignee && !normalizedFilters.label && !normalizedFilters.search && !normalizedFilters.preset ? { ...normalizedFilters, preset: "open", state: "open" } : normalizedFilters;
+  const sort = normalizeSort(typeof input.sort === "string" ? input.sort : stringPayload(payload, "taskSort"), current?.sort ?? "priority");
+  return { filters, sort };
+}
+function matchesSearch(task, search) {
+  const needle = search?.trim().toLowerCase();
+  if (!needle)
+    return true;
+  const raw = task.raw;
+  const haystack = [
+    task.id,
+    task.title,
+    task.status,
+    task.labels.join(" "),
+    task.assignees.join(" "),
+    optionalString(raw, ["externalRef", "sourceIssueId", "url", "description", "acceptanceCriteria"])
+  ].filter(Boolean).join(" ").toLowerCase();
+  return haystack.includes(needle);
+}
+function matchesLabel(task, label) {
+  const wanted = label?.trim().toLowerCase();
+  if (!wanted)
+    return true;
+  return task.labels.some((entry) => entry.toLowerCase() === wanted);
+}
+function timestamp(task) {
+  const parsed = Date.parse(task.updatedAt ?? task.createdAt ?? "");
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function statusRank(status) {
+  switch (status.toLowerCase().replace(/-/g, "_")) {
+    case "ready":
+      return 0;
+    case "open":
+      return 1;
+    case "in_progress":
+      return 2;
+    case "blocked":
+      return 3;
+    case "closed":
+    case "completed":
+      return 4;
+    default:
+      return 5;
+  }
+}
+function sortTasks(tasks, sort) {
+  return [...tasks].sort((left, right) => {
+    if (sort === "recency")
+      return timestamp(right) - timestamp(left) || left.id.localeCompare(right.id);
+    if (sort === "status")
+      return statusRank(left.status) - statusRank(right.status) || left.id.localeCompare(right.id);
+    if (sort === "id")
+      return left.id.localeCompare(right.id, undefined, { numeric: true });
+    const leftPriority = left.priority ?? Number.NEGATIVE_INFINITY;
+    const rightPriority = right.priority ?? Number.NEGATIVE_INFINITY;
+    return rightPriority - leftPriority || statusRank(left.status) - statusRank(right.status) || left.id.localeCompare(right.id, undefined, { numeric: true });
+  });
+}
+function applyLocalTaskView(records, filters, sort) {
+  const sorted = sortTasks(records.filter((task) => matchesSearch(task, filters.search) && matchesLabel(task, filters.label)), sort);
+  return filters.limit && filters.limit > 0 ? sorted.slice(0, filters.limit) : sorted;
+}
+function serverFilters(filters) {
+  return {
+    ...filters.state ? { state: filters.state } : {},
+    ...filters.status ? { status: filters.status } : {},
+    ...filters.assignee ? { assignee: filters.assignee } : {}
+  };
+}
+async function refreshTasks(ctx, input = {}) {
+  const { filters, sort } = effectiveTaskViewOptions(ctx, input);
+  const label = "Loading tasks";
+  emitStarted(ctx, label);
+  try {
+    const { listWorkspaceTasksViaServer: listWorkspaceTasksViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
+    emitProgress(ctx, label, `reading workspace tasks \xB7 filter ${filters.preset ?? filters.status ?? filters.state ?? "custom"} \xB7 sort ${sort}`);
+    const tasks = await listWorkspaceTasksViaServer2({ projectRoot: projectRootOf(ctx) }, serverFilters(filters));
+    const allRecords = tasks.flatMap((task) => {
+      const entry = normalizeTaskRecord(task);
+      return entry ? [entry] : [];
+    });
+    const records = applyLocalTaskView(allRecords, filters, sort);
+    const view = {
+      records,
+      allRecords,
+      filters,
+      sort,
+      refreshedAt: new Date().toISOString(),
+      totalCount: allRecords.length,
+      visibleCount: records.length
+    };
+    patchData(ctx, { tasks: view, selectedTaskId: records[0]?.id });
+    patchFooter(ctx, { tasks: `${records.length}/${allRecords.length}` });
+    emitCompleted(ctx, label, { count: records.length, totalCount: allRecords.length, sort, filters });
+    return records;
+  } catch (error) {
+    emitFailed(ctx, label, error);
+    throw error;
+  }
+}
+async function loadRunDefaults(projectRoot) {
+  try {
+    const { loadTaskRunProjectDefaults: loadTaskRunProjectDefaults2 } = await Promise.resolve().then(() => (init_task(), exports_task));
+    const defaults = await loadTaskRunProjectDefaults2(projectRoot);
+    return {
+      runtimeAdapter: defaults.runtimeAdapter ?? "pi",
+      ...defaults.model ? { model: defaults.model } : {},
+      runtimeMode: defaults.runtimeMode ?? "full-access",
+      ...defaults.prMode ? { prMode: defaults.prMode } : {}
+    };
+  } catch {
+    return { runtimeAdapter: "pi", runtimeMode: "full-access" };
+  }
+}
+async function submitTaskRun(ctx, input = {}) {
+  const projectRoot = projectRootOf(ctx);
+  const stateRunId = ctx.getState().runId;
+  const taskId3 = input.taskId?.trim();
+  const title = input.title?.trim();
+  const initialPrompt = input.initialPrompt?.trim();
+  if (!taskId3 && !title && !initialPrompt) {
+    const error = new Error("Select a task, then press Enter; or use run next.");
+    emitFailed(ctx, "Dispatching task", error);
+    throw error;
+  }
+  const runId = input.runId?.trim() || ctx.rig?.runId || (typeof stateRunId === "string" ? stateRunId : undefined) || randomUUID();
+  const label = taskId3 ? `Dispatching ${taskId3}` : "Dispatching ad-hoc run";
+  emitStarted(ctx, label, {
+    dispatch: { runId, taskId: taskId3 ?? null, status: "dispatching" }
+  });
+  const optimisticTitle = title ?? taskId3 ?? "ad hoc run";
+  patchData(ctx, {
+    selectedRunId: runId,
+    dispatchingRun: { runId, taskId: taskId3 ?? null, status: "dispatching", title: optimisticTitle },
+    runDetail: { runId, status: "dispatching", title: optimisticTitle, run: {}, logs: [], timeline: [], timelineCursor: null }
+  });
+  patchFooter(ctx, { run: `${runId.slice(0, 8)} dispatching` });
+  try {
+    const { submitTaskRunViaServer: submitTaskRunViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
+    const defaults = await loadRunDefaults(projectRoot);
+    emitProgress(ctx, label, "submitting run to selected Rig server", { runId, taskId: taskId3 ?? null });
+    const submitted = await submitTaskRunViaServer2({ projectRoot }, {
+      runId,
+      taskId: taskId3 || undefined,
+      title,
+      runtimeAdapter: defaults.runtimeAdapter,
+      model: defaults.model,
+      runtimeMode: defaults.runtimeMode,
+      interactionMode: "default",
+      initialPrompt,
+      baselineMode: "head",
+      prMode: defaults.prMode
+    });
+    emitCompleted(ctx, label, { runId: submitted.runId, taskId: taskId3 ?? null });
+    patchData(ctx, {
+      selectedRunId: submitted.runId,
+      dispatchingRun: null,
+      latestSubmittedRun: { runId: submitted.runId, taskId: taskId3 ?? null },
+      runDetail: { runId: submitted.runId, status: "submitted", title: optimisticTitle, run: submitted, logs: [], timeline: [], timelineCursor: null }
+    });
+    patchFooter(ctx, { run: `${submitted.runId.slice(0, 8)} submitted` });
+    return submitted;
+  } catch (error) {
+    emitFailed(ctx, label, error, { runId, taskId: taskId3 ?? null, revert: { dispatchingRun: null } });
+    throw error;
+  }
+}
+async function submitNextTaskRun(ctx, filters = {}) {
+  const label = "Selecting next task";
+  emitStarted(ctx, label, { dispatch: { status: "selecting-next" } });
+  try {
+    const { selectNextWorkspaceTaskViaServer: selectNextWorkspaceTaskViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
+    const projectRoot = projectRootOf(ctx);
+    emitProgress(ctx, label, "asking server for next runnable task");
+    const selected = await selectNextWorkspaceTaskViaServer2({ projectRoot }, filters);
+    const task = selected.task ? normalizeTaskRecord(selected.task) : null;
+    patchData(ctx, { nextTask: task, nextTaskCount: selected.count });
+    if (!task) {
+      const error = new Error("No runnable task is available.");
+      emitFailed(ctx, label, error, { count: selected.count });
+      throw error;
+    }
+    emitCompleted(ctx, label, { taskId: task.id, count: selected.count });
+    const submitted = await submitTaskRun(ctx, { taskId: task.id, title: task.title });
+    return { ...submitted, task };
+  } catch (error) {
+    emitFailed(ctx, label, error);
+    throw error;
+  }
+}
+async function loadTaskPreview(ctx, taskId3) {
+  const label = `Loading task ${taskId3}`;
+  emitStarted(ctx, label);
+  try {
+    const { getWorkspaceTaskViaServer: getWorkspaceTaskViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
+    const task = await getWorkspaceTaskViaServer2({ projectRoot: projectRootOf(ctx) }, taskId3);
+    const normalized = task ? normalizeTaskRecord(task) : null;
+    patchData(ctx, { selectedTaskId: taskId3, taskPreview: normalized, taskPreviewRaw: task ? compactRecord(task, ["id", "title", "status", "body", "url"]) : null });
+    emitCompleted(ctx, label, { taskId: taskId3, found: Boolean(normalized) });
+    return normalized;
+  } catch (error) {
+    emitFailed(ctx, label, error, { taskId: taskId3 });
+    throw error;
+  }
+}
+async function ensureTaskRuntime(ctx) {
+  await runtimeOf(ctx);
+}
+export {
+  submitTaskRun,
+  submitNextTaskRun,
+  refreshTasks,
+  normalizeTaskRecord,
+  loadTaskPreview,
+  ensureTaskRuntime,
+  createTasksAdapter
+};