@h-rig/cli 0.0.6-alpha.18 → 0.0.6-alpha.180

package/dist/src/commands/run.js

@@ -1,893 +0,0 @@
-// @bun
-// packages/cli/src/commands/run.ts
-import { createInterface as createInterface2 } from "readline/promises";
-
-// 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}`);
-  }
-}
-
-// packages/cli/src/commands/run.ts
-import {
-  listAuthorityRuns,
-  readAuthorityRun
-} from "@rig/runtime/control-plane/authority-files";
-import {
-  cleanupRunState,
-  deleteRunState,
-  listOpenEpics,
-  resolveDefaultEpic,
-  runResume,
-  runRestart,
-  runStatus,
-  runStop,
-  startRun,
-  defaultStartRunOptions
-} from "@rig/runtime/control-plane/native/run-ops";
-import { loadRuntimeContextFromEnv as loadRuntimeContextFromEnv2 } from "@rig/runtime/control-plane/runtime/context";
-
-// packages/cli/src/commands/_parsers.ts
-function parsePositiveInt(value, option, fallback) {
-  if (!value) {
-    return fallback;
-  }
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new CliError2(`Invalid ${option} value: ${value}`);
-  }
-  return parsed;
-}
-
-// packages/cli/src/commands/_server-client.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
-import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
-
-// 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
-var scopedGitHubBearerTokens = new Map;
-function cleanToken(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : null;
-}
-function readPrivateRemoteSessionToken(projectRoot) {
-  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
-  if (!existsSync2(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined);
-  } catch {
-    return null;
-  }
-}
-function readGitHubBearerTokenForRemote(projectRoot) {
-  const scopedKey = resolve2(projectRoot);
-  if (scopedGitHubBearerTokens.has(scopedKey))
-    return scopedGitHubBearerTokens.get(scopedKey) ?? null;
-  const privateSession = readPrivateRemoteSessionToken(projectRoot);
-  if (privateSession)
-    return privateSession;
-  return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
-}
-async function ensureServerForCli(projectRoot) {
-  try {
-    const selected = resolveSelectedConnection(projectRoot);
-    if (selected?.connection.kind === "remote") {
-      return {
-        baseUrl: selected.connection.baseUrl,
-        authToken: readGitHubBearerTokenForRemote(projectRoot),
-        connectionKind: "remote"
-      };
-    }
-    const connection = await ensureLocalRigServerConnection(projectRoot);
-    return {
-      baseUrl: connection.baseUrl,
-      authToken: connection.authToken,
-      connectionKind: "local"
-    };
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new CliError2(error.message, 1);
-    }
-    throw error;
-  }
-}
-function mergeHeaders(headers, authToken) {
-  const merged = new Headers(headers);
-  if (authToken) {
-    merged.set("authorization", `Bearer ${authToken}`);
-  }
-  return merged;
-}
-function diagnosticMessage(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const record = payload;
-  const diagnostics = Array.isArray(record.diagnostics) ? record.diagnostics : [];
-  const messages = diagnostics.flatMap((entry) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry))
-      return [];
-    const diagnostic = entry;
-    const kind = typeof diagnostic.kind === "string" ? diagnostic.kind : "task-source";
-    const message = typeof diagnostic.message === "string" ? diagnostic.message : null;
-    return message ? [`${kind}: ${message}`] : [];
-  });
-  return messages.length > 0 ? messages.join("; ") : null;
-}
-async function requestServerJson(context, pathname, init = {}) {
-  const server = await ensureServerForCli(context.projectRoot);
-  const response = await fetch(`${server.baseUrl}${pathname}`, {
-    ...init,
-    headers: mergeHeaders(init.headers, server.authToken)
-  });
-  const text = await response.text();
-  const payload = text.trim().length > 0 ? (() => {
-    try {
-      return JSON.parse(text);
-    } catch {
-      return null;
-    }
-  })() : null;
-  if (!response.ok) {
-    const diagnostics = diagnosticMessage(payload);
-    const detail = diagnostics ?? (text || response.statusText);
-    throw new CliError2(`Rig server request failed (${response.status}): ${detail}`, 1);
-  }
-  return payload;
-}
-async function 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 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 };
-}
-
-// packages/cli/src/commands/_operator-surface.ts
-import { createInterface } from "readline";
-var CANONICAL_STAGES = [
-  "Connect",
-  "GitHub/task sync",
-  "Prepare workspace",
-  "Launch Pi",
-  "Plan",
-  "Implement",
-  "Validate",
-  "Commit",
-  "Open PR",
-  "Review/CI",
-  "Merge",
-  "Complete"
-];
-function logDetail(log) {
-  return typeof log.detail === "string" ? log.detail.trim() : "";
-}
-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 (text.startsWith(previousText)) {
-            const delta = text.slice(previousText.length);
-            if (delta)
-              output.write(delta);
-          } else if (text.trim() && text !== 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")}`);
-        }
-      }
-    },
-    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;
-        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: (message) => errorOutput.write(`${message}
-`),
-    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() };
-    }
-  };
-}
-
-// packages/cli/src/commands/_operator-view.ts
-var TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
-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;
-  if (input.message?.trim()) {
-    await steerRunViaServer(context, input.runId, input.message.trim());
-    steered = true;
-  }
-  const surface = createOperatorSurface({ interactive: input.interactive !== false });
-  let snapshot = await readOperatorSnapshot(context, input.runId);
-  if (context.outputMode === "text") {
-    surface.renderSnapshot(snapshot);
-    surface.renderTimeline(snapshot.timeline);
-    surface.renderLogs(snapshot.logs);
-    if (steered)
-      surface.info("Steering message queued.");
-  }
-  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 };
-}
-
-// packages/cli/src/commands/run.ts
-function normalizeRemoteRunDetails(payload) {
-  const run = payload.run;
-  if (!run || typeof run !== "object" || Array.isArray(run))
-    return null;
-  return {
-    ...run,
-    ...Array.isArray(payload.timeline) ? { timeline: payload.timeline } : {},
-    ...Array.isArray(payload.approvals) ? { approvals: payload.approvals } : {},
-    ...Array.isArray(payload.userInputs) ? { userInputs: payload.userInputs } : {}
-  };
-}
-function shouldPromptForEpicSelection(context, command, promptEpic, noEpicPrompt) {
-  if (noEpicPrompt) {
-    return false;
-  }
-  if (promptEpic) {
-    return true;
-  }
-  if (command !== "start-serial") {
-    return false;
-  }
-  return context.outputMode === "text" && process.stdin.isTTY && process.stdout.isTTY;
-}
-async function promptForEpicSelection(projectRoot, command) {
-  const epics = listOpenEpics(projectRoot);
-  const defaultEpic = await resolveDefaultEpic(projectRoot);
-  const options = epics.map((epic) => epic.id);
-  if (defaultEpic && !options.includes(defaultEpic)) {
-    options.unshift(defaultEpic);
-  }
-  if (options.length === 0) {
-    throw new CliError2("No open epic found. Pass --epic <id>.");
-  }
-  console.log(`Select epic for run ${command}:`);
-  options.forEach((id, index) => {
-    const metadata = epics.find((epic) => epic.id === id);
-    const details = [
-      metadata?.priority !== undefined ? `priority:${metadata.priority}` : "",
-      metadata?.createdAt ? `created:${metadata.createdAt.slice(0, 10)}` : "",
-      id === defaultEpic ? "default" : ""
-    ].filter(Boolean).join(" ");
-    const suffix = details ? ` (${details})` : "";
-    console.log(`  ${index + 1}. ${id}${suffix}`);
-  });
-  const fallback = defaultEpic || options[0];
-  const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  try {
-    while (true) {
-      const answer = (await rl.question(`Epic [1-${options.length}] or id (Enter for ${fallback}, q to cancel): `)).trim();
-      if (!answer) {
-        return fallback ?? options[0];
-      }
-      if (answer === "q" || answer === "quit") {
-        throw new CliError2("Run cancelled by user.");
-      }
-      if (/^\d+$/.test(answer)) {
-        const index = Number.parseInt(answer, 10) - 1;
-        if (index >= 0 && index < options.length) {
-          return options[index];
-        }
-      }
-      if (options.includes(answer)) {
-        return answer;
-      }
-      console.log("Invalid selection. Choose a listed number, exact epic id, or q to cancel.");
-    }
-  } finally {
-    rl.close();
-  }
-}
-async function executeRun(context, args) {
-  const [command = "status", ...rest] = args;
-  const runtimeContext = loadRuntimeContextFromEnv2() ?? undefined;
-  switch (command) {
-    case "list": {
-      requireNoExtraArgs(rest, "bun run rig run list");
-      const runs = listAuthorityRuns(context.projectRoot);
-      if (context.outputMode === "text") {
-        if (runs.length === 0) {
-          console.log("No runs recorded in .rig/runs.");
-        } else {
-          for (const run of runs) {
-            console.log(`- ${run.runId} \xB7 ${run.status} \xB7 ${run.title}`);
-          }
-        }
-      }
-      return { ok: true, group: "run", command, details: { runs } };
-    }
-    case "delete": {
-      let pending = rest;
-      const run = takeOption(pending, "--run");
-      pending = run.rest;
-      const purgeArtifacts = takeFlag(pending, "--purge-artifacts");
-      pending = purgeArtifacts.rest;
-      requireNoExtraArgs(pending, "bun run rig run delete --run <id> [--purge-artifacts]");
-      if (!run.value) {
-        throw new CliError2("run delete requires --run <id>.");
-      }
-      const result = await deleteRunState(context.projectRoot, {
-        runId: run.value,
-        purgeRuntime: true,
-        purgeTaskArtifacts: purgeArtifacts.value
-      });
-      if (context.outputMode === "text") {
-        console.log(`Deleted run ${result.runId}`);
-        if (result.runtimeIds.length > 0) {
-          console.log(`Cleaned runtimes: ${result.runtimeIds.join(", ")}`);
-        }
-        if (result.taskArtifactsDeleted) {
-          console.log(`Cleared task artifacts for ${result.taskId}`);
-        }
-      }
-      return { ok: true, group: "run", command, details: result };
-    }
-    case "cleanup": {
-      let pending = rest;
-      const all = takeFlag(pending, "--all");
-      pending = all.rest;
-      const keepArtifacts = takeFlag(pending, "--keep-artifacts");
-      pending = keepArtifacts.rest;
-      const keepRuntimes = takeFlag(pending, "--keep-runtimes");
-      pending = keepRuntimes.rest;
-      const keepQueue = takeFlag(pending, "--keep-queue");
-      pending = keepQueue.rest;
-      requireNoExtraArgs(pending, "bun run rig run cleanup --all [--keep-artifacts] [--keep-runtimes] [--keep-queue]");
-      if (!all.value) {
-        throw new CliError2("run cleanup currently requires --all.");
-      }
-      const result = await cleanupRunState(context.projectRoot, {
-        includeArtifacts: !keepArtifacts.value,
-        includeRuntimes: !keepRuntimes.value,
-        includeQueue: !keepQueue.value
-      });
-      if (context.outputMode === "text") {
-        console.log(`Deleted runs: ${result.runIds.length}`);
-        console.log(`Cleaned runtimes: ${result.runtimeIds.length}`);
-        console.log(`Artifacts cleared: ${result.artifactsCleared ? "yes" : "no"}`);
-        console.log(`Queue cleared: ${result.queueCleared ? "yes" : "no"}`);
-      }
-      return { ok: true, group: "run", command, details: result };
-    }
-    case "show": {
-      let pending = rest;
-      const run = takeOption(pending, "--run");
-      pending = run.rest;
-      requireNoExtraArgs(pending, "bun run rig run show --run <id>");
-      if (!run.value) {
-        throw new CliError2("run show requires --run <id>.");
-      }
-      const record = readAuthorityRun(context.projectRoot, run.value) ?? normalizeRemoteRunDetails(await getRunDetailsViaServer(context, run.value).catch(() => ({})));
-      if (!record) {
-        throw new CliError2(`Run not found: ${run.value}`, 2);
-      }
-      if (context.outputMode === "text") {
-        console.log(JSON.stringify(record, null, 2));
-      }
-      return { ok: true, group: "run", command, details: record };
-    }
-    case "timeline": {
-      let pending = rest;
-      const run = takeOption(pending, "--run");
-      pending = run.rest;
-      const follow = takeFlag(pending, "--follow");
-      pending = follow.rest;
-      requireNoExtraArgs(pending, "bun run rig run timeline --run <id> [--follow]");
-      if (!run.value) {
-        throw new CliError2("run timeline requires --run <id>.");
-      }
-      const renderer = createPiRunStreamRenderer();
-      let cursor = null;
-      const page = await getRunTimelineViaServer(context, run.value, { limit: 500 });
-      const events = Array.isArray(page.entries) ? page.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
-      cursor = typeof page.nextCursor === "string" ? page.nextCursor : null;
-      if (context.outputMode === "text") {
-        renderer.renderTimeline(events);
-      }
-      if (follow.value && context.outputMode === "text") {
-        while (true) {
-          await Bun.sleep(1000);
-          const nextPage = await getRunTimelineViaServer(context, run.value, { limit: 500, ...cursor ? { cursor } : {} });
-          const nextEvents = Array.isArray(nextPage.entries) ? nextPage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
-          cursor = typeof nextPage.nextCursor === "string" ? nextPage.nextCursor : cursor;
-          renderer.renderTimeline(nextEvents);
-        }
-      }
-      return { ok: true, group: "run", command, details: { runId: run.value, events, cursor } };
-    }
-    case "attach": {
-      let pending = rest;
-      const runOption = takeOption(pending, "--run");
-      pending = runOption.rest;
-      const messageOption = takeOption(pending, "--message");
-      pending = messageOption.rest;
-      const once = takeFlag(pending, "--once");
-      pending = once.rest;
-      const follow = takeFlag(pending, "--follow");
-      pending = follow.rest;
-      const pollMs = takeOption(pending, "--poll-ms");
-      pending = pollMs.rest;
-      const positionalRunId = pending.length > 0 ? pending[0] : undefined;
-      const extra = positionalRunId ? pending.slice(1) : pending;
-      requireNoExtraArgs(extra, "bun run rig run attach <run-id>|--run <run-id> [--message <text>] [--once|--follow] [--poll-ms <ms>]");
-      const runId = runOption.value ?? positionalRunId;
-      if (!runId) {
-        throw new CliError2("run attach requires a run id.", 2);
-      }
-      const attached = await attachRunOperatorView(context, {
-        runId,
-        message: messageOption.value ?? null,
-        once: once.value,
-        follow: follow.value,
-        pollMs: parsePositiveInt(pollMs.value, "--poll-ms", 2000)
-      });
-      return { ok: true, group: "run", command, details: attached };
-    }
-    case "status": {
-      requireNoExtraArgs(rest, "bun run rig run status");
-      if (context.dryRun) {
-        if (context.outputMode === "text") {
-          console.log("[dry-run] rig run status");
-        }
-        return { ok: true, group: "run", command };
-      }
-      const summary = runStatus(context.projectRoot, runtimeContext);
-      if (context.outputMode === "text") {
-        console.log(`Active runs: ${summary.activeRuns.length}`);
-        for (const run of summary.activeRuns) {
-          console.log(`- ${run.runId} \xB7 ${run.status} \xB7 ${run.taskId ?? run.title}`);
-        }
-        if (summary.recentRuns.length > 0) {
-          console.log("");
-          console.log("Recent runs:");
-          for (const run of summary.recentRuns) {
-            console.log(`- ${run.runId} \xB7 ${run.status} \xB7 ${run.taskId ?? run.title}`);
-          }
-        }
-      }
-      return { ok: true, group: "run", command, details: summary };
-    }
-    case "start":
-    case "start-serial":
-    case "start-parallel": {
-      let pending = rest;
-      const epicResult = takeOption(pending, "--epic");
-      pending = epicResult.rest;
-      const promptEpicResult = takeFlag(pending, "--prompt-epic");
-      pending = promptEpicResult.rest;
-      const noEpicPromptResult = takeFlag(pending, "--no-epic-prompt");
-      pending = noEpicPromptResult.rest;
-      const wsPortResult = takeOption(pending, "--ws-port");
-      pending = wsPortResult.rest;
-      const serverHostResult = takeOption(pending, "--server-host");
-      pending = serverHostResult.rest;
-      const serverPortResult = takeOption(pending, "--server-port");
-      pending = serverPortResult.rest;
-      const pollResult = takeOption(pending, "--poll-ms");
-      pending = pollResult.rest;
-      const noServerResult = takeFlag(pending, "--no-server");
-      pending = noServerResult.rest;
-      requireNoExtraArgs(pending, "bun run rig run start [--epic <id>] [--prompt-epic|--no-epic-prompt] [--ws-port <n>] [--server-host <host>] [--server-port <n>] [--poll-ms <n>] [--no-server]");
-      if (promptEpicResult.value && noEpicPromptResult.value) {
-        throw new CliError2("Cannot use --prompt-epic and --no-epic-prompt together.");
-      }
-      if (promptEpicResult.value && (context.outputMode !== "text" || !process.stdin.isTTY || !process.stdout.isTTY)) {
-        throw new CliError2("--prompt-epic requires an interactive terminal (TTY) in text mode.");
-      }
-      let resolvedEpicId = epicResult.value || undefined;
-      if (!resolvedEpicId && shouldPromptForEpicSelection(context, command, promptEpicResult.value, noEpicPromptResult.value)) {
-        resolvedEpicId = await promptForEpicSelection(context.projectRoot, command);
-      }
-      const defaults = defaultStartRunOptions(command === "start-parallel" ? "parallel" : "serial");
-      const result = await startRun(context.projectRoot, {
-        mode: command === "start-parallel" ? "parallel" : "serial",
-        workers: defaults.workers,
-        epicId: resolvedEpicId,
-        wsPort: parsePositiveInt(wsPortResult.value, "--ws-port", defaults.wsPort),
-        startEventServer: noServerResult.value ? false : defaults.startEventServer,
-        serverHost: serverHostResult.value || defaults.serverHost,
-        serverPort: parsePositiveInt(serverPortResult.value, "--server-port", defaults.serverPort),
-        serverPollMs: parsePositiveInt(pollResult.value, "--poll-ms", defaults.serverPollMs),
-        dryRun: context.dryRun,
-        runtimeContext
-      });
-      if (context.outputMode === "text") {
-        console.log(`Epic: ${result.epicId}`);
-        console.log(`Server: ${result.baseUrl}`);
-        if (result.eventServerUrl) {
-          console.log(`Events: ${result.eventServerUrl}`);
-        }
-        console.log(`Runs: ${result.runIds.join(", ")}`);
-      }
-      if (result.exitCode !== 0) {
-        throw new CliError2(`run ${command} failed with exit code ${result.exitCode}.`, result.exitCode);
-      }
-      return {
-        ok: true,
-        group: "run",
-        command,
-        details: {
-          epicId: result.epicId,
-          baseUrl: result.baseUrl,
-          runIds: result.runIds,
-          eventServerUrl: result.eventServerUrl || null
-        }
-      };
-    }
-    case "resume": {
-      requireNoExtraArgs(rest, "bun run rig run resume");
-      if (context.dryRun) {
-        if (context.outputMode === "text") {
-          console.log("[dry-run] rig run resume");
-        }
-        return { ok: true, group: "run", command };
-      }
-      const resumed = await runResume(context.projectRoot, runtimeContext);
-      if (context.outputMode === "text") {
-        console.log(`Resumed run: ${resumed.runId}`);
-      }
-      return { ok: true, group: "run", command, details: resumed };
-    }
-    case "restart": {
-      requireNoExtraArgs(rest, "bun run rig run restart");
-      if (context.dryRun) {
-        if (context.outputMode === "text") {
-          console.log("[dry-run] rig run restart");
-        }
-        return { ok: true, group: "run", command };
-      }
-      const restarted = await runRestart(context.projectRoot, runtimeContext);
-      if (context.outputMode === "text") {
-        console.log(`Restarted run: ${restarted.runId}`);
-      }
-      return { ok: true, group: "run", command, details: restarted };
-    }
-    case "stop": {
-      const runOption = takeOption(rest, "--run");
-      const positionalRunId = runOption.rest.length > 0 ? runOption.rest[0] : undefined;
-      const extra = positionalRunId ? runOption.rest.slice(1) : runOption.rest;
-      requireNoExtraArgs(extra, "bun run rig run stop [<run-id>|--run <id>]");
-      const runId = runOption.value ?? positionalRunId;
-      if (context.dryRun) {
-        return {
-          ok: true,
-          group: "run",
-          command,
-          details: runId ? { runId, accepted: true } : { stopped: 0, remaining: [] }
-        };
-      }
-      if (runId) {
-        const stopped = await stopRunViaServer(context, runId);
-        if (context.outputMode === "text")
-          console.log(`Stop requested: ${runId}`);
-        return { ok: true, group: "run", command, details: stopped };
-      }
-      const result = await runStop(context.projectRoot);
-      if (result.remaining.length > 0) {
-        throw new CliError2(`Failed to stop run(s): ${result.remaining.join(", ")}`, 1);
-      }
-      if (context.outputMode === "text") {
-        console.log(`Stopped process count: ${result.stopped}`);
-      }
-      return {
-        ok: true,
-        group: "run",
-        command,
-        details: {
-          stopped: result.stopped,
-          remaining: result.remaining
-        }
-      };
-    }
-    default:
-      throw new CliError2(`Unknown run command: ${command}`);
-  }
-}
-export {
-  executeRun
-};