@h-rig/cli 0.0.6-alpha.10 → 0.0.6-alpha.100

package/dist/src/commands/stats.d.ts

@@ -0,0 +1,15 @@
+import type { RigStatsData } from "@rig/contracts";
+import type { CommandOutcome } from "@rig/runtime";
+import { type RunnerContext } from "../runner";
+import { listRunProjections } from "./_run-projection";
+type StatsCommandDeps = {
+    listRuns?: typeof listRunProjections;
+};
+export declare function parseSinceOption(value: string | undefined, now?: Date): Date | null;
+export declare function computeRigStats(projectRoot: string, options?: {
+    since?: Date | null;
+    listRuns?: typeof listRunProjections;
+}): Promise<RigStatsData>;
+export declare function formatStatsRows(stats: RigStatsData): Array<[string, unknown]>;
+export declare function executeStats(context: RunnerContext, args: string[], deps?: StatsCommandDeps): Promise<CommandOutcome>;
+export {};

package/dist/src/commands/stats.js

@@ -0,0 +1,632 @@
+// @bun
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+
+// packages/cli/src/commands/_cli-format.ts
+import pc from "picocolors";
+var dim = pc.dim;
+var faintBar = pc.dim("\u2502");
+var accent = pc.cyan;
+function compactValue(value) {
+  if (value === null || value === undefined)
+    return "\u2014";
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  return JSON.stringify(value);
+}
+function printFormattedOutput(message) {
+  console.log(message);
+}
+function formatStatsTable(rows) {
+  return rows.map(([label, value]) => `${faintBar} ${dim(label.padEnd(20))} ${compactValue(value)}`).join(`
+`);
+}
+
+// packages/cli/src/commands/_help-catalog.ts
+import pc2 from "picocolors";
+import {
+  ADVANCED_COMMANDS,
+  ADVANCED_GROUPS,
+  ALL_GROUPS,
+  helpCatalog,
+  TOP_LEVEL_SECTIONS
+} from "@rig/contracts";
+function heading(title) {
+  return pc2.bold(pc2.cyan(title));
+}
+function commandLine(command, description) {
+  const commandColumn = command.length >= 38 ? `${command}  ` : command.padEnd(38);
+  return `${pc2.dim("\u2502")} ${pc2.bold(commandColumn)} ${description}`;
+}
+function renderCommandBlock(commands) {
+  return commands.map((entry) => commandLine(entry.command, entry.description)).join(`
+`);
+}
+function renderGroup(group) {
+  const lines = [
+    `${heading(`rig ${group.name}`)} \u2014 ${group.summary}`,
+    "",
+    pc2.bold("Usage"),
+    ...group.usage.map((line) => `  ${line}`),
+    "",
+    pc2.bold("Commands"),
+    ...group.commands.map((entry) => commandLine(entry.command, entry.description))
+  ];
+  if (group.examples?.length) {
+    lines.push("", pc2.bold("Examples"), ...group.examples.map((line) => `  ${pc2.dim("$")} ${line}`));
+  }
+  if (group.next?.length) {
+    lines.push("", pc2.bold("Next steps"), ...group.next.map((line) => `  ${pc2.dim("\u203A")} ${line}`));
+  }
+  if (group.advanced?.length) {
+    lines.push("", pc2.bold("Compatibility / advanced"), ...group.advanced.map((line) => `  ${pc2.dim("\u203A")} ${line}`));
+  }
+  return lines.join(`
+`);
+}
+function renderTopLevelHelp() {
+  return [
+    `${heading("rig")} ${pc2.dim("\u2014 Rig Cockpit for autonomous coding agents")}`,
+    pc2.dim("The loop: bare `rig` \u2192 Cockpit \u2192 Server target \u2192 Tasks \u2192 Task detail \u2192 Dispatch/Attach; every run uses OMP collaboration as the session substrate."),
+    "",
+    ...TOP_LEVEL_SECTIONS.flatMap((section) => [
+      `${pc2.bold(pc2.magenta(`\u25C7 ${section.title}`))} \u2014 ${pc2.dim(section.subtitle)}`,
+      renderCommandBlock(section.commands),
+      ""
+    ]),
+    pc2.dim("More: `rig help --advanced` for fenced legacy/diagnostic commands; `rig <group> --help` for per-group compatibility help; `rig --version` for the installed version."),
+    "",
+    pc2.bold("Root options"),
+    commandLine("--workspace <path>", "Open Rig Cockpit for a workspace instead of the current directory."),
+    commandLine("--json", "Compatibility flag for fenced legacy/diagnostic subcommands."),
+    commandLine("--dry-run", "Compatibility flag for fenced legacy/diagnostic subcommands.")
+  ].join(`
+`).trimEnd();
+}
+function renderGroupHelp(groupName) {
+  const group = ALL_GROUPS.find((candidate) => candidate.name === groupName);
+  return group ? renderGroup(group) : null;
+}
+function printGroupHelpDocument(groupName) {
+  console.log(renderGroupHelp(groupName) ?? renderTopLevelHelp());
+}
+
+// packages/cli/src/commands/_run-projection.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import {
+  foldRunSessionEntries,
+  sessionIdFromSessionFile as sessionIdFromSessionFile2
+} from "@rig/contracts";
+import { listAgentRuntimes as listAgentRuntimes2 } from "@rig/runtime/control-plane/runtime/isolation";
+
+// packages/cli/src/commands/_run-bridge.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { CUSTOM_TYPE_FOR, sessionIdFromSessionFile } from "@rig/contracts";
+import { createPluginHost } from "@rig/core";
+import { loadConfig } from "@rig/core/load-config";
+import { resolveOwnerNamespaceKey, resolveRegistryBaseUrl, resolveRegistrySecret, resolveSelectedRemote } from "@rig/runtime/control-plane/remote";
+import { listAgentRuntimes } from "@rig/runtime/control-plane/runtime/isolation";
+import { createRegistryClient } from "@rig/relay-registry";
+import {
+  listActiveCollabSessions as ompListActiveCollabSessions
+} from "@oh-my-pi/pi-coding-agent/collab/api";
+function registrySecret(env = process.env) {
+  return resolveRegistrySecret(process.cwd(), env) ?? null;
+}
+function registryBaseUrl(env = process.env) {
+  return resolveRegistryBaseUrl(process.cwd(), env);
+}
+function collabFromRegistryEntry(entry) {
+  return {
+    sessionId: entry.roomId,
+    sessionPath: "",
+    cwd: "",
+    title: entry.title,
+    joinLink: entry.joinLink,
+    webLink: entry.webLink,
+    relayUrl: entry.relayUrl,
+    owner: entry.owner,
+    selectedRepo: entry.repo,
+    startedAt: entry.startedAt,
+    updatedAt: entry.heartbeatAt,
+    ...entry.pid === undefined ? {} : { pid: entry.pid },
+    stale: entry.stale
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readLocalRunCollab(runtime) {
+  if (!runtime.sessionDir || !existsSync(runtime.sessionDir))
+    return null;
+  let files;
+  try {
+    files = readdirSync(runtime.sessionDir).filter((f) => f.endsWith(".jsonl")).sort().reverse();
+  } catch {
+    return null;
+  }
+  for (const file of files) {
+    let lines;
+    try {
+      lines = readFileSync(resolve(runtime.sessionDir, file), "utf8").split(`
+`);
+    } catch {
+      continue;
+    }
+    let host = null;
+    for (const line of lines) {
+      if (!line.includes("collab-host-started"))
+        continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!isRecord(entry) || entry.customType !== CUSTOM_TYPE_FOR["timeline-entry"] || !isRecord(entry.data))
+        continue;
+      const payload = isRecord(entry.data.payload) ? entry.data.payload : entry.data;
+      if (payload.type !== "collab-host-started")
+        continue;
+      host = {
+        roomId: typeof payload.roomId === "string" ? payload.roomId : undefined,
+        joinLink: typeof payload.joinLink === "string" ? payload.joinLink : undefined,
+        webLink: typeof payload.webLink === "string" ? payload.webLink : undefined,
+        relayUrl: typeof payload.relayUrl === "string" ? payload.relayUrl : undefined,
+        at: typeof entry.data.at === "string" ? entry.data.at : undefined
+      };
+    }
+    if (!host?.joinLink)
+      continue;
+    const at = host.at ?? "";
+    const sessionId = host.roomId ?? sessionIdFromSessionFile(resolve(runtime.sessionDir, file)) ?? runtime.id;
+    return {
+      sessionId,
+      sessionPath: resolve(runtime.sessionDir, file),
+      cwd: runtime.workspaceDir,
+      joinLink: host.joinLink,
+      webLink: host.webLink ?? "",
+      relayUrl: host.relayUrl ?? "",
+      title: runtime.taskId ? `[${runtime.taskId}] Rig run ${sessionId}` : `Rig run ${sessionId}`,
+      startedAt: at,
+      updatedAt: at,
+      stale: false
+    };
+  }
+  return null;
+}
+async function listLocalRunCollabSessions(projectRoot) {
+  let runtimes;
+  try {
+    runtimes = await listAgentRuntimes(projectRoot);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const runtime of runtimes) {
+    const collab = readLocalRunCollab(runtime);
+    if (collab)
+      out.push(collab);
+  }
+  return out;
+}
+async function listActiveRunCollab(filter) {
+  return defaultListActiveCollabSessions(filter);
+}
+async function defaultListActiveCollabSessions(filter) {
+  const projectRoot = process.cwd();
+  const local = await listLocalRunCollabSessions(projectRoot);
+  const namespaceKey = filter.namespaceKey ?? resolveOwnerNamespaceKey(projectRoot);
+  const secret = registrySecret();
+  const remote = namespaceKey && secret ? (await createRegistryClient({ baseUrl: registryBaseUrl(), namespaceKey, secret }).listRoomsByOwner(filter)).map(collabFromRegistryEntry) : await ompListActiveCollabSessions(filter);
+  const seen = new Set(local.map((c) => c.sessionId));
+  return [...local, ...remote.filter((c) => !seen.has(c.sessionId))];
+}
+
+// packages/cli/src/commands/_run-diagnostics.ts
+function normalizeString(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function isGenericRunFailure(value) {
+  const text = normalizeString(value);
+  return Boolean(text && /^Task run failed \([^)]*\)$/i.test(text));
+}
+function appendCandidate(candidates, value) {
+  const text = normalizeString(value);
+  if (text && !candidates.includes(text))
+    candidates.push(text);
+}
+function categorizeUsefulRunError(lines) {
+  const taskSourceFailure = lines.find((line) => /failed to update task source/i.test(line));
+  if (taskSourceFailure)
+    return `Task source update failed: ${taskSourceFailure}`;
+  const moduleFailure = lines.find((line) => /cannot find module/i.test(line));
+  if (moduleFailure)
+    return `Runtime module resolution failed: ${moduleFailure}`;
+  const providerFailure = lines.find((line) => /no api key found|unauthorized|authentication failed|invalid api key/i.test(line));
+  if (providerFailure)
+    return `Provider authentication failed: ${providerFailure}`;
+  return null;
+}
+function summarizeUsefulRunError(projection) {
+  if (projection.status !== "failed")
+    return null;
+  const candidates = [];
+  for (const anomaly of projection.anomalies) {
+    appendCandidate(candidates, `Journal anomaly (${anomaly.kind}): ${anomaly.detail}`);
+  }
+  for (const phase of projection.closeoutPhases) {
+    if (phase.outcome === "failed")
+      appendCandidate(candidates, phase.detail);
+  }
+  for (const entry of projection.statusHistory) {
+    appendCandidate(candidates, entry.reason);
+  }
+  appendCandidate(candidates, projection.record.statusDetail);
+  appendCandidate(candidates, projection.record.errorText);
+  const nonGeneric = candidates.filter((candidate) => !isGenericRunFailure(candidate));
+  return categorizeUsefulRunError(nonGeneric) ?? nonGeneric.at(-1) ?? normalizeString(projection.record.errorText);
+}
+
+// packages/cli/src/commands/_run-projection.ts
+var EMPTY_PROJECTION = foldRunSessionEntries([], "");
+function stringOrNull(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function newestSessionFile(sessionDir) {
+  if (!sessionDir || !existsSync2(sessionDir))
+    return null;
+  try {
+    const files = readdirSync2(sessionDir).filter((file) => file.endsWith(".jsonl")).sort().reverse();
+    return files[0] ? resolve2(sessionDir, files[0]) : null;
+  } catch {
+    return null;
+  }
+}
+function readSessionRunEntries(sessionPath) {
+  if (!sessionPath || !existsSync2(sessionPath))
+    return [];
+  let raw;
+  try {
+    raw = readFileSync2(sessionPath, "utf8");
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      continue;
+    entries.push({
+      type: "type" in parsed && typeof parsed.type === "string" ? parsed.type : "",
+      ..."customType" in parsed && typeof parsed.customType === "string" ? { customType: parsed.customType } : {},
+      ..."data" in parsed ? { data: parsed.data } : {}
+    });
+  }
+  return entries;
+}
+function recordFromProjection(runId, projection, presence) {
+  const record = projection.record;
+  const status = projection.status ?? (presence.stale ? "stale" : presence.live ? "running" : "unknown");
+  const taskId = stringOrNull(record.taskId) ?? presence.fallbackTaskId ?? null;
+  const title = stringOrNull(record.title) ?? stringOrNull(presence.title) ?? (taskId ? `Run ${taskId}` : `Rig run ${runId}`);
+  return {
+    runId,
+    taskId,
+    title,
+    status,
+    source: presence.source,
+    live: presence.live,
+    stale: presence.stale,
+    startedAt: stringOrNull(record.startedAt) ?? presence.startedAt ?? null,
+    updatedAt: stringOrNull(record.updatedAt) ?? presence.updatedAt ?? projection.lastEventAt ?? null,
+    completedAt: stringOrNull(record.completedAt),
+    joinLink: presence.joinLink ?? null,
+    webLink: presence.webLink ?? null,
+    relayUrl: presence.relayUrl ?? null,
+    sessionPath: stringOrNull(record.sessionPath) ?? presence.sessionPath ?? null,
+    prUrl: stringOrNull(record.prUrl),
+    worktreePath: stringOrNull(record.worktreePath),
+    pendingApprovals: projection.pendingApprovals.length,
+    pendingInputs: projection.pendingUserInputs.length,
+    steeringCount: projection.steeringCount,
+    stallCount: projection.stallCount,
+    errorSummary: summarizeUsefulRunError(projection),
+    projection
+  };
+}
+function recordFromLiveCollab(collab) {
+  const runId = collab.sessionId;
+  const sessionPath = stringOrNull(collab.sessionPath);
+  const projection = sessionPath ? foldRunSessionEntries(readSessionRunEntries(sessionPath), runId) : EMPTY_PROJECTION;
+  return recordFromProjection(runId, projection, {
+    source: sessionPath ? "local" : "remote",
+    live: !collab.stale,
+    stale: Boolean(collab.stale),
+    title: collab.title,
+    joinLink: stringOrNull(collab.joinLink),
+    webLink: stringOrNull(collab.webLink),
+    relayUrl: stringOrNull(collab.relayUrl),
+    sessionPath,
+    startedAt: stringOrNull(collab.startedAt),
+    updatedAt: stringOrNull(collab.updatedAt)
+  });
+}
+function recordFromRuntime(runtime) {
+  const sessionPath = newestSessionFile(runtime.sessionDir ?? "");
+  if (!sessionPath)
+    return null;
+  const projection = foldRunSessionEntries(readSessionRunEntries(sessionPath), runtime.id);
+  if (projection.lastSeq === 0)
+    return null;
+  return recordFromProjection(sessionIdFromSessionFile2(sessionPath) ?? runtime.id, projection, {
+    source: "local",
+    live: false,
+    stale: false,
+    sessionPath,
+    fallbackTaskId: stringOrNull(runtime.taskId)
+  });
+}
+function sortByRecency(records) {
+  return [...records].sort((a, b) => {
+    const at = Date.parse(b.updatedAt ?? b.startedAt ?? "") || 0;
+    const bt = Date.parse(a.updatedAt ?? a.startedAt ?? "") || 0;
+    return at - bt;
+  });
+}
+async function listRunProjections(projectRoot, filter = {}) {
+  const byRunId = new Map;
+  let live = [];
+  try {
+    live = await listActiveRunCollab(filter);
+  } catch {
+    live = [];
+  }
+  for (const collab of live) {
+    const record = recordFromLiveCollab(collab);
+    byRunId.set(record.runId, record);
+  }
+  let runtimes = [];
+  try {
+    runtimes = await listAgentRuntimes2(projectRoot);
+  } catch {
+    runtimes = [];
+  }
+  for (const runtime of runtimes) {
+    const record = recordFromRuntime(runtime);
+    if (!record)
+      continue;
+    const sessionId = sessionIdFromSessionFile2(record.sessionPath);
+    const liveMatch = sessionId ? byRunId.get(sessionId) : undefined;
+    if (liveMatch) {
+      if (liveMatch.source === "remote" || !liveMatch.sessionPath) {
+        byRunId.set(liveMatch.runId, { ...liveMatch, sessionPath: record.sessionPath, source: "local" });
+      }
+      continue;
+    }
+    if (byRunId.has(runtime.id))
+      continue;
+    byRunId.set(record.runId, record);
+  }
+  return sortByRecency([...byRunId.values()]);
+}
+
+// packages/cli/src/commands/stats.ts
+var DAY_MS = 24 * 60 * 60 * 1000;
+function parseSinceOption(value, now = new Date) {
+  if (!value?.trim())
+    return null;
+  const trimmed = value.trim();
+  const relative = trimmed.match(/^(\d+)d$/i);
+  if (relative?.[1]) {
+    const days = Number.parseInt(relative[1], 10);
+    if (!Number.isFinite(days) || days <= 0) {
+      throw new CliError(`Invalid --since value: ${value}`, 2, {
+        hint: "Use an ISO date or a relative window like `7d`."
+      });
+    }
+    return new Date(now.getTime() - days * DAY_MS);
+  }
+  const parsed = Date.parse(trimmed);
+  if (!Number.isFinite(parsed)) {
+    throw new CliError(`Invalid --since value: ${value}`, 2, {
+      hint: "Use an ISO date or a relative window like `7d`."
+    });
+  }
+  return new Date(parsed);
+}
+function parseTimestamp(value) {
+  if (!value)
+    return null;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function median(values) {
+  if (values.length === 0)
+    return null;
+  const sorted = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+function rate(part, total) {
+  return total === 0 ? null : part / total;
+}
+function isNeedsAttention(run) {
+  return run.status === "needs-attention" || run.pendingApprovals + run.pendingInputs > 0 || run.stallCount > 0;
+}
+function completedDuration(run) {
+  if (run.status !== "completed")
+    return null;
+  const startedAt = parseTimestamp(run.startedAt);
+  const completedAt = parseTimestamp(run.completedAt);
+  if (startedAt === null || completedAt === null || completedAt < startedAt)
+    return null;
+  return completedAt - startedAt;
+}
+async function computeRigStats(projectRoot, options = {}) {
+  const sinceMs = options.since ? options.since.getTime() : null;
+  const allRuns = await (options.listRuns ?? listRunProjections)(projectRoot);
+  const runs = allRuns.filter((run) => {
+    if (sinceMs === null)
+      return true;
+    const startedAt = parseTimestamp(run.startedAt);
+    return startedAt !== null && startedAt >= sinceMs;
+  });
+  const statusCounts = {};
+  const completionDurations = [];
+  let completedRuns = 0;
+  let failedRuns = 0;
+  let needsAttentionRuns = 0;
+  let steeringTotal = 0;
+  let stallTotal = 0;
+  let approvalsPending = 0;
+  for (const run of runs) {
+    const status = run.status || "unknown";
+    statusCounts[status] = (statusCounts[status] ?? 0) + 1;
+    if (status === "completed")
+      completedRuns += 1;
+    if (status === "failed")
+      failedRuns += 1;
+    if (isNeedsAttention(run))
+      needsAttentionRuns += 1;
+    const duration = completedDuration(run);
+    if (duration !== null)
+      completionDurations.push(duration);
+    steeringTotal += run.steeringCount;
+    stallTotal += run.stallCount;
+    approvalsPending += run.pendingApprovals;
+  }
+  const totalRuns = runs.length;
+  return {
+    since: options.since ? options.since.toISOString() : null,
+    totalRuns,
+    statusCounts,
+    completedRuns,
+    failedRuns,
+    needsAttentionRuns,
+    completionRate: rate(completedRuns, totalRuns),
+    failureRate: rate(failedRuns, totalRuns),
+    needsAttentionRate: rate(needsAttentionRuns, totalRuns),
+    medianCompletionMs: median(completionDurations),
+    steeringTotal,
+    steeringPerRun: totalRuns === 0 ? null : steeringTotal / totalRuns,
+    stallTotal,
+    approvalsRequested: approvalsPending,
+    approvalsApproved: 0,
+    approvalsRejected: 0,
+    approvalsPending
+  };
+}
+function formatPercent(value) {
+  return value === null ? "\u2014" : `${Math.round(value * 100)}%`;
+}
+function formatDuration(ms) {
+  if (ms === null)
+    return "\u2014";
+  const seconds = Math.round(ms / 1000);
+  if (seconds < 60)
+    return `${seconds}s`;
+  const minutes = Math.round(ms / 60000);
+  if (minutes < 60)
+    return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const remainder = minutes % 60;
+  return remainder === 0 ? `${hours}h` : `${hours}h ${remainder}m`;
+}
+function formatStatsRows(stats) {
+  return [
+    ["window", stats.since ? `since ${stats.since}` : "all runs"],
+    ["total runs", stats.totalRuns],
+    ["completed", `${stats.completedRuns} (${formatPercent(stats.completionRate)})`],
+    ["failed", `${stats.failedRuns} (${formatPercent(stats.failureRate)})`],
+    ["needs attention", `${stats.needsAttentionRuns} (${formatPercent(stats.needsAttentionRate)})`],
+    ["median run time", formatDuration(stats.medianCompletionMs)],
+    ["steering", stats.steeringTotal],
+    ["stalls", stats.stallTotal],
+    ["pending approvals", stats.approvalsPending]
+  ];
+}
+async function executeStats(context, args, deps = {}) {
+  const [first = "show", ...rest] = args;
+  const command = first.startsWith("-") ? "show" : first;
+  const commandArgs = first.startsWith("-") ? args : rest;
+  if (command === "help") {
+    printGroupHelpDocument("stats");
+    return { ok: true, group: "stats", command };
+  }
+  if (command !== "show") {
+    throw new CliError(`Unknown stats command: ${command}`, 1, {
+      hint: "Run `rig stats --help` \u2014 the default command is `show`."
+    });
+  }
+  const sinceResult = takeOption(commandArgs, "--since");
+  requireNoExtraArgs(sinceResult.rest, "rig stats [show] [--since <7d|30d|ISO date>]");
+  const details = await computeRigStats(context.projectRoot, {
+    since: parseSinceOption(sinceResult.value),
+    listRuns: deps.listRuns
+  });
+  if (context.outputMode === "text") {
+    printFormattedOutput(formatStatsTable(formatStatsRows(details)));
+  }
+  return { ok: true, group: "stats", command, details };
+}
+export {
+  parseSinceOption,
+  formatStatsRows,
+  executeStats,
+  computeRigStats
+};