@h-rig/cli 0.0.6-alpha.9 → 0.0.6-alpha.91

package/dist/src/commands/inbox.js

@@ -1,16 +1,22 @@
 // @bun
 // packages/cli/src/commands/inbox.ts
-import { writeFileSync } from "fs";
-import { resolve } from "path";
+import { Duration, Effect, Stream } from "effect";
 
 // packages/cli/src/runner.ts
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
-import { CliError } from "@rig/runtime/control-plane/errors";
+import { CliError as RuntimeCliError } 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";
+
+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;
@@ -19,7 +25,7 @@ function takeOption(args, option) {
     if (current === option) {
       const next = args[index + 1];
       if (!next || next.startsWith("-")) {
-        throw new CliError(`Missing value for ${option}`);
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
       }
       value = next;
       index += 1;
@@ -39,122 +45,535 @@ Usage: ${usage}`);
 }
 
 // packages/cli/src/commands/inbox.ts
+import { localRunChanges } from "@rig/runtime/control-plane/run-discovery-stream";
+
+// 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 statusColor(status) {
+  const normalized = status.trim().toLowerCase();
+  if (["done", "completed", "ready", "healthy", "open", "approved"].includes(normalized))
+    return pc.green;
+  if (["failed", "error", "blocked", "rejected", "stopped"].includes(normalized))
+    return pc.red;
+  if (["running", "in_progress", "in-progress", "active", "booting"].includes(normalized))
+    return pc.cyan;
+  if (["pending", "queued", "created", "local"].includes(normalized))
+    return pc.yellow;
+  return pc.dim;
+}
+function firstString(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value;
+  }
+  return fallback;
+}
+function requestIdOf(entry) {
+  return firstString(entry, ["requestId", "id", "approvalId", "inputId"], "(unknown-request)");
+}
+function printFormattedOutput(message) {
+  console.log(message);
+}
+function formatStatusPill(status) {
+  const label = status || "unknown";
+  return statusColor(label)(`\u25CF ${label}`);
+}
+function formatSection(title, subtitle) {
+  return `${pc.bold(accent("\u25C6"))} ${pc.bold(title)}${subtitle ? dim(` \u2014 ${subtitle}`) : ""}`;
+}
+function formatNextSteps(steps) {
+  if (steps.length === 0)
+    return [];
+  return [pc.bold("Next"), ...steps.map((step) => `${accent("\u203A")} ${step}`)];
+}
+function formatLegacyAutomationSurface() {
+  return [];
+}
+function formatInboxList(kind, entries) {
+  const title = kind === "approvals" ? "Pending approvals" : "Pending user input";
+  if (entries.length === 0) {
+    return [
+      formatSection(title, "empty"),
+      dim(kind === "approvals" ? "No pending approvals." : "No pending user-input requests."),
+      "",
+      ...formatLegacyAutomationSurface()
+    ].join(`
+`);
+  }
+  const lines = [formatSection(title, `${entries.length}`)];
+  for (const record of entries) {
+    const runId = firstString(record, ["runId"], "(unknown-run)");
+    const taskId = firstString(record, ["taskId"], "");
+    const status = firstString(record, ["status"], "pending");
+    const prompt = firstString(record, ["prompt", "message", "reason", "title", "summary"], kind === "approvals" ? "Approval requested" : "Input requested");
+    lines.push(`${faintBar} ${pc.bold(requestIdOf(record))} ${formatStatusPill(status)} ${prompt}`);
+    lines.push(`${faintBar} ${dim("run".padEnd(12))} ${runId}${taskId ? dim(`  task ${taskId}`) : ""}`);
+  }
+  lines.push("", ...formatLegacyAutomationSurface(), ...formatNextSteps(kind === "approvals" ? ["Resolve: `rig inbox approve --run <run-id> --request <request-id> --decision approve|reject`"] : ["Reply: `rig inbox answer --run <run-id> --request <request-id> --text ...`"]));
+  return lines.join(`
+`);
+}
+
+// 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 {
-  listAuthorityRuns,
-  readJsonlFile,
-  resolveAuthorityRunDir
-} from "@rig/runtime/control-plane/authority-files";
-async function executeInbox(context, args) {
-  const [command = "approvals", ...rest] = args;
-  switch (command) {
-    case "approvals": {
-      let pending = rest;
-      const run = takeOption(pending, "--run");
-      pending = run.rest;
-      const task = takeOption(pending, "--task");
-      pending = task.rest;
-      requireNoExtraArgs(pending, "bun run rig inbox approvals [--run <id>] [--task <id>]");
-      const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!run.value || entry.runId === run.value) && (!task.value || entry.taskId === task.value));
-      const approvals = runs.flatMap((entry) => readJsonlFile(resolve(resolveAuthorityRunDir(context.projectRoot, entry.runId), "approvals.jsonl")).map((record) => ({
-        runId: entry.runId,
-        record
-      })));
-      if (context.outputMode === "text") {
-        for (const approval of approvals) {
-          console.log(JSON.stringify(approval));
-        }
-      }
-      return { ok: true, group: "inbox", command, details: { approvals } };
+  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;
     }
-    case "approve": {
-      let pending = rest;
-      const run = takeOption(pending, "--run");
-      pending = run.rest;
-      const request = takeOption(pending, "--request");
-      pending = request.rest;
-      const decision = takeOption(pending, "--decision");
-      pending = decision.rest;
-      const note = takeOption(pending, "--note");
-      pending = note.rest;
-      requireNoExtraArgs(pending, "bun run rig inbox approve --run <id> --request <id> --decision approve|reject [--note <text>]");
-      if (!run.value || !request.value || !decision.value) {
-        throw new CliError2("approve requires --run, --request, and --decision.");
+    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 (decision.value !== "approve" && decision.value !== "reject") {
-        throw new CliError2("decision must be approve or reject.");
+      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" });
       }
-      const approvalsPath = resolve(resolveAuthorityRunDir(context.projectRoot, run.value), "approvals.jsonl");
-      const approvals = readJsonlFile(approvalsPath);
-      const resolvedAt = new Date().toISOString();
-      const next = approvals.map((entry) => entry.requestId === request.value || entry.id === request.value ? { ...entry, status: "resolved", decision: decision.value, note: note.value ?? null, resolvedAt } : entry);
-      writeFileSync(approvalsPath, `${next.map((entry) => JSON.stringify(entry)).join(`
-`)}
-`, "utf8");
-      return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, decision: decision.value } };
+      continue;
+    }
+    if (byRunId.has(runtime.id))
+      continue;
+    byRunId.set(record.runId, record);
+  }
+  return sortByRecency([...byRunId.values()]);
+}
+
+// packages/cli/src/commands/inbox.ts
+function promptFromPayload(payload, fallback) {
+  if (payload && typeof payload === "object") {
+    const record = payload;
+    for (const key of ["title", "message", "reason", "prompt", "summary"]) {
+      const value = record[key];
+      if (typeof value === "string" && value.trim().length > 0)
+        return value.trim();
     }
+  }
+  return fallback;
+}
+function recordsFromRun(run, kind) {
+  const pending = kind === "approvals" ? run.projection.pendingApprovals : run.projection.pendingUserInputs;
+  return pending.map((request) => ({
+    runId: run.runId,
+    taskId: run.taskId,
+    requestId: request.requestId,
+    status: "pending",
+    prompt: promptFromPayload(request.payload, kind === "approvals" ? "Approval requested" : "Input requested"),
+    requestedAt: request.requestedAt,
+    payload: request.payload
+  }));
+}
+async function listInboxRecords(context, kind, filters = {}, deps = {}) {
+  const runs = await (deps.listRuns ?? ((root) => listRunProjections(root)))(context.projectRoot);
+  const out = [];
+  for (const run of runs) {
+    if (filters.run && run.runId !== filters.run)
+      continue;
+    if (filters.task && run.taskId !== filters.task)
+      continue;
+    out.push(...recordsFromRun(run, kind));
+  }
+  return out;
+}
+async function readPendingInboxCounts(context) {
+  try {
+    const [approvals, inputs] = await Promise.all([
+      listInboxRecords(context, "approvals"),
+      listInboxRecords(context, "inputs")
+    ]);
+    return { approvals: approvals.length, inputs: inputs.length };
+  } catch {
+    return null;
+  }
+}
+function resolveRequiresAttach(runId, verb) {
+  const target = runId ?? "<run-id>";
+  throw new CliError(`rig inbox ${verb} cannot deliver a resolution into a live worker from a one-shot command.`, 2, { hint: `Attach to resolve interactively: rig run attach ${target}` });
+}
+async function readInboxSnapshot(context, filters, deps) {
+  const [approvals, inputs] = await Promise.all([
+    listInboxRecords(context, "approvals", filters, deps),
+    listInboxRecords(context, "inputs", filters, deps)
+  ]);
+  return { approvals, inputs };
+}
+function renderInboxSnapshot(snapshot) {
+  console.clear();
+  console.log(`rig inbox \u2014 watching (Ctrl-C to stop) \u2014 ${new Date().toLocaleTimeString()}`);
+  printFormattedOutput(formatInboxList("approvals", snapshot.approvals.map((entry) => ({ ...entry }))));
+  printFormattedOutput(formatInboxList("inputs", snapshot.inputs.map((entry) => ({ ...entry }))));
+  if (snapshot.approvals.length === 0 && snapshot.inputs.length === 0)
+    console.log("Nothing pending.");
+}
+async function watchInbox(context, filters, deps) {
+  const snapshot = await readInboxSnapshot(context, filters, deps);
+  if (context.outputMode !== "text") {
+    return { ok: true, group: "inbox", command: "watch", details: snapshot };
+  }
+  renderInboxSnapshot(snapshot);
+  await Effect.runPromise(localRunChanges(context.projectRoot).pipe(Stream.debounce(Duration.millis(500)), Stream.runForEach(() => Effect.promise(async () => {
+    renderInboxSnapshot(await readInboxSnapshot(context, filters, deps));
+  }))));
+  return { ok: true, group: "inbox", command: "watch", details: snapshot };
+}
+async function executeInbox(context, args, deps = {}) {
+  const [command = "approvals", ...rest] = args;
+  const text = context.outputMode === "text";
+  switch (command) {
+    case "approvals":
     case "inputs": {
-      let pending = rest;
-      const run = takeOption(pending, "--run");
-      pending = run.rest;
-      const task = takeOption(pending, "--task");
-      pending = task.rest;
-      requireNoExtraArgs(pending, "bun run rig inbox inputs [--run <id>] [--task <id>]");
-      const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!run.value || entry.runId === run.value) && (!task.value || entry.taskId === task.value));
-      const requests = runs.flatMap((entry) => readJsonlFile(resolve(resolveAuthorityRunDir(context.projectRoot, entry.runId), "user-input.jsonl")).map((record) => ({
-        runId: entry.runId,
-        record
-      })));
-      if (context.outputMode === "text") {
-        for (const request of requests) {
-          console.log(JSON.stringify(request));
-        }
-      }
-      return { ok: true, group: "inbox", command, details: { requests } };
+      const run = takeOption(rest, "--run");
+      const task = takeOption(run.rest, "--task");
+      requireNoExtraArgs(task.rest, `rig inbox ${command} [--run <id>] [--task <id>]`);
+      const kind = command === "approvals" ? "approvals" : "inputs";
+      const filters = {
+        ...run.value ? { run: run.value } : {},
+        ...task.value ? { task: task.value } : {}
+      };
+      const entries = await listInboxRecords(context, kind, filters, deps);
+      if (text)
+        printFormattedOutput(formatInboxList(kind, entries.map((entry) => ({ ...entry }))));
+      return { ok: true, group: "inbox", command, details: { entries } };
+    }
+    case "approve": {
+      const run = takeOption(rest, "--run");
+      resolveRequiresAttach(run.value, "approve");
+      break;
     }
     case "respond": {
-      let pending = rest;
-      const run = takeOption(pending, "--run");
-      pending = run.rest;
-      const request = takeOption(pending, "--request");
-      pending = request.rest;
-      const answers = [];
-      const remaining = [];
-      for (let index = 0;index < pending.length; index += 1) {
-        const current = pending[index];
-        if (current === "--answer") {
-          const next2 = pending[index + 1];
-          if (!next2 || next2.startsWith("-")) {
-            throw new CliError2("Missing value for --answer");
-          }
-          answers.push(next2);
-          index += 1;
-          continue;
-        }
-        if (current !== undefined) {
-          remaining.push(current);
-        }
-      }
-      requireNoExtraArgs(remaining, "bun run rig inbox respond --run <id> --request <id> --answer key=value [--answer key=value]");
-      if (!run.value || !request.value || answers.length === 0) {
-        throw new CliError2("respond requires --run, --request, and at least one --answer.");
-      }
-      const parsedAnswers = Object.fromEntries(answers.map((entry) => {
-        const [key, ...restValue] = entry.split("=");
-        return [key, restValue.join("=")];
-      }));
-      const requestsPath = resolve(resolveAuthorityRunDir(context.projectRoot, run.value), "user-input.jsonl");
-      const requests = readJsonlFile(requestsPath);
-      const resolvedAt = new Date().toISOString();
-      const next = requests.map((entry) => entry.requestId === request.value || entry.id === request.value ? { ...entry, status: "resolved", answers: parsedAnswers, respondedAt: resolvedAt, resolvedAt } : entry);
-      writeFileSync(requestsPath, `${next.map((entry) => JSON.stringify(entry)).join(`
-`)}
-`, "utf8");
-      return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, answers: parsedAnswers } };
+      const run = takeOption(rest, "--run");
+      resolveRequiresAttach(run.value, "respond");
+      break;
+    }
+    case "watch": {
+      const run = takeOption(rest, "--run");
+      const task = takeOption(run.rest, "--task");
+      requireNoExtraArgs(task.rest, "rig inbox watch [--run <id>] [--task <id>]");
+      const filters = {
+        ...run.value ? { run: run.value } : {},
+        ...task.value ? { task: task.value } : {}
+      };
+      return watchInbox(context, filters, deps);
     }
     default:
-      throw new CliError2(`Unknown inbox command: ${command}`);
+      throw new CliError(`Unknown inbox command: ${command}`, 1, { hint: "Run `rig inbox --help` to list inbox commands." });
   }
+  return { ok: true, group: "inbox", command };
 }
 export {
+  readPendingInboxCounts,
+  listInboxRecords,
   executeInbox
 };