@h-rig/cli 0.0.6-alpha.0

package/dist/src/commands/task.js

@@ -0,0 +1,1325 @@
+// @bun
+// packages/cli/src/commands/task.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+import { createInterface as createInterface3 } from "readline/promises";
+import { resolve as resolve3 } from "path";
+
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
+import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
+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}`);
+      }
+      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;
+}
+
+// packages/cli/src/commands/task.ts
+import {
+  taskArtifactDir,
+  taskArtifacts,
+  taskArtifactWrite,
+  taskDeps,
+  taskInfo,
+  taskLookup,
+  taskReady,
+  taskRecord,
+  taskReopen,
+  taskScope,
+  taskStatus as taskStatus2,
+  taskValidate,
+  taskVerify
+} from "@rig/runtime/control-plane/native/task-ops";
+
+// packages/cli/src/commands/_authority-runs.ts
+import {
+  readAuthorityRun,
+  readJsonlFile,
+  resolveAuthorityRunDir,
+  writeJsonFile
+} from "@rig/runtime/control-plane/authority-files";
+
+// packages/cli/src/commands/_paths.ts
+import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
+
+// packages/cli/src/commands/_authority-runs.ts
+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";
+}
+
+// packages/cli/src/commands/_preflight.ts
+import { ensureProjectMainFreshBeforeRun } from "@rig/runtime/control-plane/project-main-pre-run-sync";
+
+// packages/cli/src/commands/_connection-state.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+function resolveGlobalConnectionsPath(env = process.env) {
+  const explicit = env.RIG_CONNECTIONS_FILE?.trim();
+  if (explicit)
+    return resolve(explicit);
+  const stateDir = env.RIG_GLOBAL_STATE_DIR?.trim();
+  if (stateDir)
+    return resolve(stateDir, "connections.json");
+  return resolve(homedir(), ".rig", "connections.json");
+}
+function resolveRepoConnectionPath(projectRoot) {
+  return resolve(projectRoot, ".rig", "state", "connection.json");
+}
+function readJsonFile(path) {
+  if (!existsSync(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new CliError2(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1);
+  }
+}
+function normalizeConnection(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = value;
+  if (record.kind === "local")
+    return { kind: "local", mode: "auto" };
+  if (record.kind === "remote" && typeof record.baseUrl === "string" && record.baseUrl.trim()) {
+    const baseUrl = record.baseUrl.trim().replace(/\/+$/, "");
+    return { kind: "remote", baseUrl };
+  }
+  return null;
+}
+function readGlobalConnections(options = {}) {
+  const path = resolveGlobalConnectionsPath(options.env ?? process.env);
+  const payload = readJsonFile(path);
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return { connections: {} };
+  }
+  const rawConnections = payload.connections;
+  const connections = {};
+  if (rawConnections && typeof rawConnections === "object" && !Array.isArray(rawConnections)) {
+    for (const [alias, raw] of Object.entries(rawConnections)) {
+      const connection = normalizeConnection(raw);
+      if (connection)
+        connections[alias] = connection;
+    }
+  }
+  return { connections };
+}
+function readRepoConnection(projectRoot) {
+  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
+  if (!selected)
+    return null;
+  return {
+    selected,
+    project: typeof record.project === "string" ? record.project : undefined,
+    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined
+  };
+}
+function resolveSelectedConnection(projectRoot, options = {}) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return null;
+  if (repo.selected === "local")
+    return { alias: "local", connection: { kind: "local", mode: "auto" } };
+  const global = readGlobalConnections(options);
+  const connection = global.connections[repo.selected];
+  if (!connection) {
+    throw new CliError2(`Selected Rig connection "${repo.selected}" was not found. Run \`rig connect list\` or \`rig connect use local\`.`, 1);
+  }
+  return { alias: repo.selected, connection };
+}
+
+// packages/cli/src/commands/_server-client.ts
+import { spawnSync } from "child_process";
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+var cachedGitHubBearerToken;
+function cleanToken(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function readGitHubBearerTokenForRemote() {
+  if (cachedGitHubBearerToken !== undefined)
+    return cachedGitHubBearerToken;
+  const envToken = cleanToken(process.env.RIG_GITHUB_TOKEN) ?? cleanToken(process.env.GITHUB_TOKEN) ?? cleanToken(process.env.GH_TOKEN);
+  if (envToken) {
+    cachedGitHubBearerToken = envToken;
+    return cachedGitHubBearerToken;
+  }
+  const result = spawnSync("gh", ["auth", "token"], {
+    encoding: "utf8",
+    timeout: 5000,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  cachedGitHubBearerToken = result.status === 0 ? cleanToken(result.stdout) : null;
+  return cachedGitHubBearerToken;
+}
+async function ensureServerForCli(projectRoot) {
+  try {
+    const selected = resolveSelectedConnection(projectRoot);
+    if (selected?.connection.kind === "remote") {
+      return {
+        baseUrl: selected.connection.baseUrl,
+        authToken: readGitHubBearerTokenForRemote(),
+        connectionKind: "remote"
+      };
+    }
+    const connection = await ensureLocalRigServerConnection(projectRoot);
+    return {
+      baseUrl: connection.baseUrl,
+      authToken: connection.authToken,
+      connectionKind: "local"
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new CliError2(error.message, 1);
+    }
+    throw error;
+  }
+}
+function 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 requestServerJson(context, pathname, init = {}) {
+  const server = await ensureServerForCli(context.projectRoot);
+  const response = await fetch(`${server.baseUrl}${pathname}`, {
+    ...init,
+    headers: mergeHeaders(init.headers, server.authToken)
+  });
+  const text = await response.text();
+  const payload = text.trim().length > 0 ? (() => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  })() : null;
+  if (!response.ok) {
+    const diagnostics = diagnosticMessage(payload);
+    const detail = diagnostics ?? (text || response.statusText);
+    throw new CliError2(`Rig server request failed (${response.status}): ${detail}`, 1);
+  }
+  return payload;
+}
+async function 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 CliError2("Rig server returned an invalid task list payload.", 1);
+  }
+  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 CliError2("Rig server returned an invalid next-task payload.", 1);
+  }
+  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 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 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 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 CliError2("Rig server returned an invalid run submission payload.", 1);
+  }
+  const runId = payload.runId;
+  if (typeof runId !== "string" || runId.trim().length === 0) {
+    throw new CliError2("Rig server returned no runId for the submitted run.", 1);
+  }
+  return { runId };
+}
+
+// packages/cli/src/commands/_pi-install.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { resolve as resolve2 } from "path";
+var PI_RIG_PACKAGE_NAME = "@rig/pi-rig";
+async function defaultCommandRunner(command, options = {}) {
+  const proc = Bun.spawn(command, { cwd: options.cwd, stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  return { exitCode, stdout, stderr };
+}
+function resolvePiRigExtensionPath(homeDir) {
+  return resolve2(homeDir, ".pi", "agent", "extensions", "pi-rig");
+}
+function resolvePiHomeDir(inputHomeDir) {
+  return inputHomeDir ?? process.env.RIG_PI_HOME_DIR?.trim() ?? homedir2();
+}
+function piListContainsPiRig(output) {
+  return output.split(/\r?\n/).some((line) => {
+    const normalized = line.trim();
+    return normalized.includes(PI_RIG_PACKAGE_NAME) || /(?:^|[\\/])packages[\\/]pi-rig(?:$|\s)/.test(normalized);
+  });
+}
+async function safeRun(runner, command, options) {
+  try {
+    return await runner(command, options);
+  } catch (error) {
+    return { exitCode: 1, stdout: "", stderr: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function checkPiRigInstall(input = {}) {
+  const home = resolvePiHomeDir(input.homeDir);
+  const extensionPath = resolvePiRigExtensionPath(home);
+  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1") {
+    return {
+      extensionPath,
+      pi: { ok: true, label: "pi", detail: "fake-pi" },
+      piRig: { ok: true, label: "pi-rig global extension", detail: extensionPath }
+    };
+  }
+  const exists = input.exists ?? existsSync2;
+  const runner = input.commandRunner ?? defaultCommandRunner;
+  const piResult = await safeRun(runner, ["pi", "--version"]);
+  const piListResult = piResult.exitCode === 0 ? await safeRun(runner, ["pi", "list"]) : { exitCode: 1, stdout: "", stderr: "" };
+  const listedPiRig = piListResult.exitCode === 0 && piListContainsPiRig(`${piListResult.stdout}
+${piListResult.stderr}`);
+  const legacyBridge = exists(resolve2(extensionPath, "index.ts"));
+  const hasPiRig = listedPiRig;
+  return {
+    extensionPath,
+    pi: {
+      ok: piResult.exitCode === 0,
+      label: "pi",
+      detail: (piResult.stdout || piResult.stderr).trim() || undefined,
+      hint: piResult.exitCode === 0 ? undefined : "Install Pi or run `rig init --yes` to install/update the Pi runtime."
+    },
+    piRig: {
+      ok: hasPiRig,
+      label: "pi-rig global extension",
+      detail: hasPiRig ? piListResult.stdout.trim() || PI_RIG_PACKAGE_NAME : legacyBridge ? `${extensionPath} (legacy bridge; reinstall required)` : undefined,
+      hint: hasPiRig ? undefined : "Run `rig init --yes` to install/enable the global pi-rig package with `pi install`."
+    }
+  };
+}
+async function buildPiSetupChecks(input = {}) {
+  const status = await checkPiRigInstall(input);
+  return [status.pi, status.piRig];
+}
+
+// packages/cli/src/commands/_preflight.ts
+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 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;
+  try {
+    await request("/api/server/status");
+    checks.push(preflightCheck("server", "Rig server reachable", "pass"));
+  } catch (error) {
+    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 connection", 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 connection", "fail", "missing .rig/state/connection.json", "Run `rig init` or `rig connect 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", "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", "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", "fail", taskId, "Confirm the issue exists and matches the configured task filters."));
+    } catch (error) {
+      checks.push(preflightCheck("issue", "task/issue accessible", "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") {
+    const piChecks = await (options.piChecks ?? (() => buildPiSetupChecks()))().catch((error) => [{
+      ok: false,
+      label: "pi/pi-rig checks",
+      hint: message(error)
+    }]);
+    for (const pi of piChecks) {
+      checks.push(preflightCheck(pi.label === "pi" ? "pi" : "pi-rig", pi.label, pi.ok ? "pass" : "fail", pi.detail, pi.hint ?? (pi.ok ? undefined : "Run `rig init --yes` to install/update Pi and enable pi-rig.")));
+    }
+  } 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 CliError2(`Task ${taskId} already has an active Rig run. ${summary}`, 1);
+    }
+    throw new CliError2(`Task run preflight failed: ${summary}`, 1);
+  }
+  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 CliError2(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;
+  }
+}
+
+// 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/_task-picker.ts
+import { createInterface } from "readline/promises";
+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 selectTaskWithTextPicker(tasks, io = {}) {
+  if (tasks.length === 0)
+    return null;
+  if (tasks.length === 1)
+    return tasks[0];
+  const isTty = io.isTty ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (!isTty) {
+    throw new Error("task run requires an interactive terminal to pick a task; pass --task <id>, --next, or --detach with a task id.");
+  }
+  const prompt = io.prompt ?? (async (question) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      return await rl.question(question);
+    } finally {
+      rl.close();
+    }
+  });
+  console.log("Select Rig task:");
+  for (const row of renderTaskPickerRows(tasks))
+    console.log(`  ${row}`);
+  const answer = (await prompt(`Task [1-${tasks.length}] or id: `)).trim();
+  if (!answer)
+    return null;
+  if (/^\d+$/.test(answer)) {
+    const index = Number.parseInt(answer, 10) - 1;
+    return tasks[index] ?? null;
+  }
+  return tasks.find((task) => taskId(task) === answer) ?? null;
+}
+
+// packages/cli/src/commands/_operator-view.ts
+import { createInterface as createInterface2 } from "readline";
+var TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
+var CANONICAL_STAGES = [
+  "Connect",
+  "GitHub/task sync",
+  "Prepare workspace",
+  "Launch Pi",
+  "Plan",
+  "Implement",
+  "Validate",
+  "Commit",
+  "Open PR",
+  "Review/CI",
+  "Merge",
+  "Complete"
+];
+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 stageLines = CANONICAL_STAGES.flatMap((stage) => {
+    const match = logs.find((log) => String(log.title ?? "").toLowerCase() === stage.toLowerCase() || String(log.stage ?? "").toLowerCase() === stage.toLowerCase());
+    return match ? [`${stage}: ${String(match.status ?? status)}`] : [];
+  });
+  return [`Rig run ${runId}: ${status}`, ...stageLines].join(`
+`);
+}
+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) {
+  const run = await getRunDetailsViaServer(context, runId);
+  const logsPage = await getRunLogsViaServer(context, runId, { limit: 100 });
+  const entries = Array.isArray(logsPage.entries) ? logsPage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+  return { run, logs: entries, rendered: renderOperatorSnapshot({ run, logs: entries }) };
+}
+async function attachRunOperatorView(context, input) {
+  let steered = false;
+  if (input.message?.trim()) {
+    await steerRunViaServer(context, input.runId, input.message.trim());
+    steered = true;
+  }
+  let snapshot = await readOperatorSnapshot(context, input.runId);
+  if (context.outputMode === "text") {
+    console.log(snapshot.rendered);
+    if (steered)
+      console.log("Steering message queued.");
+  }
+  let detached = false;
+  let rl = null;
+  if (input.follow && !input.once && context.outputMode === "text") {
+    if (input.interactive !== false && process.stdin.isTTY) {
+      console.log("Controls: /user <message>, /stop, /detach");
+      rl = createInterface2({ input: process.stdin, output: process.stdout, terminal: false });
+      rl.on("line", (line) => {
+        applyOperatorCommand(context, { runId: input.runId, line }).then((result) => {
+          if (result.message)
+            console.log(result.message);
+          if (result.action === "detach" || result.action === "stopped") {
+            detached = true;
+            rl?.close();
+          }
+        }).catch((error) => console.log(`Operator command failed: ${error instanceof Error ? error.message : String(error)}`));
+      });
+    }
+    let lastRendered = snapshot.rendered;
+    const pollMs = Math.max(250, Math.trunc(input.pollMs ?? 2000));
+    while (!detached && !TERMINAL_RUN_STATUSES.has(runStatusFromPayload(snapshot.run))) {
+      await Bun.sleep(pollMs);
+      snapshot = await readOperatorSnapshot(context, input.runId);
+      if (snapshot.rendered !== lastRendered) {
+        console.log(snapshot.rendered);
+        lastRendered = snapshot.rendered;
+      }
+    }
+    rl?.close();
+  }
+  return { ...snapshot, steered, detached };
+}
+
+// packages/cli/src/commands/task.ts
+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 normalizeAssignedToAlias(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 assignedToResult = takeOption(pending, "--assigned-to");
+  pending = assignedToResult.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 normalizedAssignedTo = normalizeAssignedToAlias(assignedToResult.value);
+  if (assigneeResult.value && normalizedAssignedTo && assigneeResult.value !== normalizedAssignedTo) {
+    throw new CliError2("--assignee and --assigned-to cannot specify different assignees.", 2);
+  }
+  const assignee = normalizedAssignedTo ?? assigneeResult.value;
+  const limit = (() => {
+    if (!limitResult.value)
+      return;
+    const parsed = Number.parseInt(limitResult.value, 10);
+    if (!Number.isFinite(parsed) || parsed < 1) {
+      throw new CliError2("--limit must be a positive integer.", 2);
+    }
+    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 CliError2("--pr must be auto, ask, or off.", 2);
+}
+function detectLocalDirtyState(projectRoot) {
+  const result = spawnSync2("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 CliError2("--dirty-baseline must be head or dirty-snapshot.", 2);
+  }
+  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 rl = createInterface3({ input: process.stdin, output: process.stdout });
+    try {
+      const answer = (await rl.question("Include current uncommitted changes in run baseline? [y/N] ")).trim().toLowerCase();
+      return { mode: answer === "y" || answer === "yes" ? "dirty-snapshot" : "head", state };
+    } finally {
+      rl.close();
+    }
+  }
+  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 } : {}
+  };
+}
+function printTaskSummary(task) {
+  const id = readTaskId(task) ?? "<unknown>";
+  const title = readTaskString(task, "title") ?? "Untitled task";
+  const status = readTaskString(task, "status") ?? "unknown";
+  console.log(`- ${id} \xB7 ${status} \xB7 ${title}`);
+}
+async function validatorRegistryForTaskCommands(projectRoot) {
+  return buildPluginHostContext(projectRoot).then((ctx) => ctx?.validatorRegistry ?? undefined).catch(() => {
+    return;
+  });
+}
+async function executeTask(context, args, options) {
+  const [command = "info", ...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, "bun run rig task list [--raw] [--assignee <login|@me>] [--assigned-to <login|me|@me>] [--state open|closed] [--status <status>] [--limit <n>]");
+      const tasks = await listWorkspaceTasksViaServer(context, filters);
+      if (context.outputMode === "text") {
+        if (tasks.length === 0) {
+          console.log("No matching tasks.");
+        } else {
+          for (const task of tasks) {
+            if (rawResult.value)
+              console.log(JSON.stringify(summarizeTask(task, { raw: true })));
+            else
+              printTaskSummary(task);
+          }
+        }
+      }
+      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": {
+      const taskOption = takeOption(rest, "--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, "bun run rig task show <id>|--task <id>");
+      const taskId2 = normalizeTaskRunTaskId(taskOption.value ?? positional);
+      if (!taskId2)
+        throw new CliError2("task show requires a task id.", 2);
+      const task = await getWorkspaceTaskViaServer(context, taskId2);
+      if (!task)
+        throw new CliError2(`Task not found: ${taskId2}`, 3);
+      const summary = summarizeTask(task, { raw: true });
+      if (context.outputMode === "text")
+        console.log(JSON.stringify(summary, null, 2));
+      return { ok: true, group: "task", command, details: { task: summary } };
+    }
+    case "next": {
+      const { filters, rest: remaining } = parseTaskFilters(rest);
+      requireNoExtraArgs(remaining, "bun run rig task next [--assignee <login|@me>] [--assigned-to <login|me|@me>] [--state open|closed] [--status <status>] [--limit <n>]");
+      const selected = await selectNextWorkspaceTaskViaServer(context, filters);
+      if (context.outputMode === "text") {
+        if (selected.task) {
+          printTaskSummary(selected.task);
+        } else {
+          console.log("No matching tasks.");
+        }
+      }
+      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, "bun run rig task info [--task <beads-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, "bun run 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, "bun run rig task deps");
+      await withMutedConsole(context.outputMode === "json", () => taskDeps(context.projectRoot));
+      return { ok: true, group: "task", command };
+    case "status":
+      requireNoExtraArgs(rest, "bun run rig task status");
+      withMutedConsole(context.outputMode === "json", () => taskStatus2(context.projectRoot));
+      return { ok: true, group: "task", command };
+    case "artifacts":
+      requireNoExtraArgs(rest, "bun run rig task artifacts");
+      withMutedConsole(context.outputMode === "json", () => taskArtifacts(context.projectRoot));
+      return { ok: true, group: "task", command };
+    case "artifact-dir": {
+      requireNoExtraArgs(rest, "bun run 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 CliError2(`Usage: bun run 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 = readFileSync3(resolve3(context.projectRoot, fileFlag.value), "utf-8");
+      } else {
+        content = await readStdin();
+      }
+      if (!artifactFilename) {
+        throw new CliError2("Usage: bun run 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 CliError2("Usage: bun run rig task lookup <beads-id>");
+      }
+      const lookupId = rest[0];
+      if (!lookupId) {
+        throw new CliError2("Usage: bun run rig task lookup <beads-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 CliError2("Usage: bun run rig task record <decision|failure> <text>");
+      }
+      const type = rest[0];
+      if (type !== "decision" && type !== "failure") {
+        throw new CliError2("Usage: bun run 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, "bun run 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, "bun run rig task run [#<issue>|<task-id>] [--next] [--task <id>] [--detach] [--assignee <login|@me>] [--assigned-to <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 CliError2("task run cannot combine --next with an explicit task id.", 2);
+      }
+      if (taskResult.value && positionalTaskId) {
+        throw new CliError2("task run cannot combine positional task id with --task <id>.", 2);
+      }
+      if (prResult.value && noPrResult.value) {
+        throw new CliError2("task run cannot combine --pr with --no-pr.", 2);
+      }
+      let selectedTask = null;
+      let selectedTaskId = normalizeTaskRunTaskId(taskResult.value) ?? positionalTaskId;
+      if (nextResult.value) {
+        const selected = await selectNextWorkspaceTaskViaServer(context, filterResult.filters);
+        selectedTask = selected.task;
+        selectedTaskId = selected.task ? readTaskId(selected.task) : null;
+        if (!selectedTaskId) {
+          throw new CliError2("No matching task found for task run --next.", 3);
+        }
+      }
+      if (!selectedTaskId && !initialPromptResult.value && !titleResult.value) {
+        if (context.outputMode !== "text" || !process.stdin.isTTY || !process.stdout.isTTY) {
+          throw new CliError2("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 listWorkspaceTasksViaServer(context, filterResult.filters);
+        selectedTask = await selectTaskWithTextPicker(tasks);
+        selectedTaskId = selectedTask ? readTaskId(selectedTask) : null;
+        if (!selectedTaskId) {
+          throw new CliError2("No task selected.", 3);
+        }
+      }
+      await runProjectMainSyncPreflight(context, { disabled: skipProjectSyncResult.value });
+      const projectDefaults = await loadTaskRunProjectDefaults(context.projectRoot);
+      const runtimeAdapter = normalizeRuntimeAdapter(runtimeAdapterResult.value ?? projectDefaults.runtimeAdapter);
+      await runFastTaskRunPreflight(context, {
+        taskId: selectedTaskId,
+        runtimeAdapter
+      });
+      const dirtyBaseline = await resolveDirtyBaselineForTaskRun(context, dirtyBaselineResult.value);
+      const prMode = noPrResult.value ? "off" : normalizePrMode(prResult.value) ?? projectDefaults.prMode;
+      const submitted = await 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
+      });
+      let attachDetails = null;
+      if (!detachResult.value && context.outputMode === "text") {
+        console.log(`Run submitted: ${submitted.runId}`);
+        if (selectedTask) {
+          printTaskSummary(selectedTask);
+        }
+        attachDetails = await attachRunOperatorView(context, { runId: submitted.runId, follow: true });
+      } else if (context.outputMode === "text") {
+        console.log(`Run submitted: ${submitted.runId}`);
+        if (selectedTask) {
+          printTaskSummary(selectedTask);
+        }
+      }
+      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, "bun run rig task validate [--task <beads-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 CliError2(`Validation failed for ${task || "active task"}.`, 2);
+      }
+      return { ok: true, group: "task", command, details: { task: task || "active" } };
+    }
+    case "verify": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "bun run rig task verify [--task <beads-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, context.plugins, task || undefined));
+      if (!ok) {
+        throw new CliError2(`Verification rejected for ${task || "active task"}.`, 2);
+      }
+      return { ok: true, group: "task", command, details: { task: task || "active" } };
+    }
+    case "reset": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "bun run rig task reset --task <beads-id>");
+      const requiredTask = requireTask(task, "bun run rig task reset --task <beads-id>");
+      await context.runCommand(["br", "--no-db", "update", requiredTask, "--status", "open"]);
+      return { ok: true, group: "task", command, details: { task: requiredTask } };
+    }
+    case "details": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "bun run rig task details --task <beads-id>");
+      const requiredTask = requireTask(task, "bun run rig task details --task <beads-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, "bun run rig task reopen [--task <id> | --all] [--reason <text>]");
+      if (!allFlag.value && !task) {
+        throw new CliError2("Usage: bun run 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:
+      throw new CliError2(`Unknown task command: ${command}`);
+  }
+}
+export {
+  executeTask
+};