@h-rig/run-plugin 0.0.6-alpha.186

package/dist/src/read-model/plugin.js

@@ -0,0 +1,2550 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// packages/run-plugin/src/read-model/stats-format.ts
+function formatRatePercent(value) {
+  return value === null ? "\u2014" : `${Math.round(value * 100)}%`;
+}
+
+// packages/run-plugin/src/read-model/session-journal.ts
+var exports_session_journal = {};
+__export(exports_session_journal, {
+  timelineEntriesFromCustomEntries: () => timelineEntriesFromCustomEntries,
+  sessionIdFromSessionFile: () => sessionIdFromSessionFile,
+  runSessionJournalCodec: () => runSessionJournalCodec,
+  projectRunFromSession: () => projectRunFromSession,
+  parseStopSentinel: () => parseStopSentinel,
+  parseResumeSentinel: () => parseResumeSentinel,
+  parsePauseSentinel: () => parsePauseSentinel,
+  parseInboxResolutionSentinel: () => parseInboxResolutionSentinel,
+  latestTimelineEntriesFromCustomEntries: () => latestTimelineEntriesFromCustomEntries,
+  isTerminalRunStatus: () => isTerminalRunStatus,
+  foldRunSessionEntries: () => foldRunSessionEntries
+});
+import { Schema } from "effect";
+import {
+  CUSTOM_TYPE_FOR,
+  RIG_CONTROL_SENTINEL_END,
+  RIG_INBOX_RESOLUTION_SENTINEL,
+  RIG_PAUSE_SENTINEL,
+  RIG_RESUME_SENTINEL,
+  RIG_STOP_SENTINEL,
+  RIG_STOP_SENTINEL_END,
+  RunJournalEvent,
+  TYPE_FOR_CUSTOM
+} from "@rig/contracts";
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+function canTransitionRunStatus(from, to) {
+  if (from === null)
+    return true;
+  if (from === to)
+    return true;
+  return RUN_STATUS_TRANSITIONS[from].includes(to);
+}
+function assertRunStatusTransition(from, to) {
+  if (!canTransitionRunStatus(from, to)) {
+    throw new Error(`Illegal run status transition: ${from ?? "(none)"} -> ${to}. ` + `Allowed from ${from ?? "(none)"}: ${from ? RUN_STATUS_TRANSITIONS[from].join(", ") : "(any)"}.`);
+  }
+}
+function reduceRunJournal(events, runId = null) {
+  let record = {};
+  let status = null;
+  const statusHistory = [];
+  const pendingApprovals = new Map;
+  const resolvedApprovals = [];
+  const pendingUserInputs = new Map;
+  const resolvedUserInputs = [];
+  const closeoutPhases = [];
+  let resolvedPipeline = null;
+  const stageOutcomes = [];
+  const anomalies = [];
+  let steeringCount = 0;
+  let stallCount = 0;
+  let lastSeq = 0;
+  let lastEventAt = null;
+  const projectedRunId = runId ?? events[0]?.runId ?? null;
+  for (const event of events) {
+    lastSeq = event.seq;
+    lastEventAt = event.at;
+    switch (event.type) {
+      case "status-changed": {
+        if (!canTransitionRunStatus(status, event.to)) {
+          anomalies.push({ seq: event.seq, kind: "illegal-transition", detail: `${status ?? "(none)"} -> ${event.to}` });
+        }
+        statusHistory.push({ seq: event.seq, at: event.at, from: status, to: event.to, reason: event.reason ?? null });
+        const wasTerminal = status !== null && isTerminalRunStatus(status);
+        status = event.to;
+        record = { ...record, updatedAt: event.at };
+        if (isTerminalRunStatus(event.to) && !record.completedAt)
+          record = { ...record, completedAt: event.at };
+        if (!isTerminalRunStatus(event.to) && wasTerminal)
+          record = { ...record, completedAt: null };
+        if (event.to === "running" && !record.startedAt)
+          record = { ...record, startedAt: event.at };
+        break;
+      }
+      case "record-patch": {
+        const next = { ...record };
+        for (const [key, value] of Object.entries(event.patch)) {
+          if (value !== undefined)
+            next[key] = value;
+        }
+        next.updatedAt = event.patch.updatedAt ?? event.at;
+        record = next;
+        break;
+      }
+      case "approval-requested": {
+        pendingApprovals.set(event.requestId, {
+          requestId: event.requestId,
+          requestKind: event.requestKind,
+          actionId: event.actionId ?? null,
+          payload: event.payload,
+          requestedAt: event.at
+        });
+        break;
+      }
+      case "approval-resolved": {
+        const pending = pendingApprovals.get(event.requestId);
+        if (!pending) {
+          const alreadyResolved = resolvedApprovals.some((entry) => entry.requestId === event.requestId);
+          anomalies.push({ seq: event.seq, kind: alreadyResolved ? "duplicate-resolution" : "unknown-request", detail: `approval ${event.requestId}` });
+          break;
+        }
+        pendingApprovals.delete(event.requestId);
+        resolvedApprovals.push({ ...pending, decision: event.decision, note: event.note ?? null, actor: event.actor, resolvedAt: event.at });
+        break;
+      }
+      case "input-requested": {
+        pendingUserInputs.set(event.requestId, {
+          requestId: event.requestId,
+          requestKind: "user-input",
+          actionId: null,
+          payload: event.payload,
+          requestedAt: event.at
+        });
+        break;
+      }
+      case "input-resolved": {
+        const pending = pendingUserInputs.get(event.requestId);
+        if (!pending) {
+          const alreadyResolved = resolvedUserInputs.some((entry) => entry.requestId === event.requestId);
+          anomalies.push({ seq: event.seq, kind: alreadyResolved ? "duplicate-resolution" : "unknown-request", detail: `user-input ${event.requestId}` });
+          break;
+        }
+        pendingUserInputs.delete(event.requestId);
+        resolvedUserInputs.push({ ...pending, answers: event.answers, actor: event.actor, resolvedAt: event.at });
+        break;
+      }
+      case "steering":
+        steeringCount += 1;
+        break;
+      case "adopted":
+        record = { ...record, pid: event.pid, updatedAt: event.at };
+        break;
+      case "stall-detected":
+        stallCount += 1;
+        break;
+      case "closeout-phase":
+        closeoutPhases.push({ seq: event.seq, at: event.at, phase: event.phase, outcome: event.outcome, detail: event.detail ?? null });
+        break;
+      case "pipeline-resolved":
+        resolvedPipeline = event.pipeline;
+        break;
+      case "stage-outcome":
+        stageOutcomes.push({ seq: event.seq, at: event.at, outcome: event.outcome });
+        break;
+      case "timeline-entry":
+      case "log-entry":
+        break;
+    }
+  }
+  return {
+    runId: projectedRunId,
+    record,
+    status,
+    statusHistory,
+    pendingApprovals: [...pendingApprovals.values()],
+    resolvedApprovals,
+    pendingUserInputs: [...pendingUserInputs.values()],
+    resolvedUserInputs,
+    steeringCount,
+    stallCount,
+    closeoutPhases,
+    resolvedPipeline,
+    stageOutcomes,
+    lastSeq,
+    lastEventAt,
+    anomalies
+  };
+}
+function sessionIdFromSessionFile(sessionPath) {
+  if (!sessionPath)
+    return null;
+  const file = sessionPath.split(/[\\/]/).pop() ?? "";
+  const match = file.match(/_([0-9a-fA-F][0-9a-fA-F-]{7,})\.jsonl$/);
+  return match?.[1] ?? null;
+}
+function isRunSessionCustomType(customType) {
+  return customType !== undefined && Object.hasOwn(TYPE_FOR_CUSTOM, customType);
+}
+function foldRunSessionEntries(entries, runId) {
+  const events = [];
+  entries.forEach((entry, index) => {
+    if (entry.type !== "custom" || !isRunSessionCustomType(entry.customType))
+      return;
+    const data = entry.data !== null && typeof entry.data === "object" ? entry.data : {};
+    const stamped = {
+      v: 1,
+      seq: index + 1,
+      at: typeof data.at === "string" ? data.at : new Date(0).toISOString(),
+      runId,
+      ...data,
+      type: TYPE_FOR_CUSTOM[entry.customType]
+    };
+    try {
+      events.push(decodeRunJournalEvent(stamped));
+    } catch {}
+  });
+  return reduceRunJournal(events, runId);
+}
+function projectRunFromSession(source, runId) {
+  const entries = "getEntries" in source ? source.getEntries() : source;
+  return foldRunSessionEntries(entries, runId);
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function timelineEntryFromCustomEntry(entry) {
+  if (entry.customType !== CUSTOM_TYPE_FOR["timeline-entry"] || !isRecord(entry.data))
+    return null;
+  const payload = isRecord(entry.data.payload) ? entry.data.payload : entry.data;
+  const type = typeof payload.type === "string" ? payload.type : "timeline";
+  const stage = typeof payload.stage === "string" ? payload.stage : typeof payload.name === "string" ? payload.name : null;
+  const status = typeof payload.status === "string" ? payload.status : typeof payload.outcome === "string" ? payload.outcome : null;
+  const detail = typeof payload.detail === "string" ? payload.detail : typeof payload.message === "string" ? payload.message : null;
+  const at = typeof entry.data.at === "string" ? entry.data.at : typeof payload.at === "string" ? payload.at : null;
+  return { at, type, stage, status, detail };
+}
+function timelineEntriesFromCustomEntries(entries) {
+  return entries.flatMap((entry) => {
+    const timelineEntry = timelineEntryFromCustomEntry(entry);
+    return timelineEntry ? [timelineEntry] : [];
+  });
+}
+function latestTimelineEntriesFromCustomEntries(entries, limit) {
+  if (limit <= 0)
+    return [];
+  const timeline = [];
+  for (let index = entries.length - 1;index >= 0 && timeline.length < limit; index -= 1) {
+    const timelineEntry = timelineEntryFromCustomEntry(entries[index]);
+    if (timelineEntry)
+      timeline.push(timelineEntry);
+  }
+  timeline.reverse();
+  return timeline;
+}
+function parseStopSentinel(text, expectedRunId) {
+  const start = text.indexOf(RIG_STOP_SENTINEL);
+  if (start < 0)
+    return null;
+  const end = text.indexOf(RIG_STOP_SENTINEL_END, start);
+  const body = text.slice(start + RIG_STOP_SENTINEL.length, end >= 0 ? end : undefined).trim();
+  const runId = body.match(/(?:^|\s)runId=([^\s>]+)/)?.[1] ?? "";
+  if (runId && runId !== expectedRunId)
+    return null;
+  const reason = body.match(/(?:^|\s)reason=(.+)$/)?.[1]?.trim() ?? null;
+  return { reason };
+}
+function parseControlSentinel(marker, text, expectedRunId) {
+  const start = text.indexOf(marker);
+  if (start < 0)
+    return null;
+  const end = text.indexOf(RIG_CONTROL_SENTINEL_END, start);
+  const body = text.slice(start + marker.length, end >= 0 ? end : undefined).trim();
+  const runId = body.match(/(?:^|\s)runId=([^\s>]+)/)?.[1] ?? "";
+  if (runId && runId !== expectedRunId)
+    return null;
+  const requestedBy = body.match(/(?:^|\s)requestedBy=([^\s>]+)/)?.[1] ?? null;
+  return { requestedBy };
+}
+function parsePauseSentinel(text, expectedRunId) {
+  return parseControlSentinel(RIG_PAUSE_SENTINEL, text, expectedRunId);
+}
+function parseResumeSentinel(text, expectedRunId) {
+  return parseControlSentinel(RIG_RESUME_SENTINEL, text, expectedRunId);
+}
+function decodeInboxResolutionPayload(payload) {
+  try {
+    const parsed = JSON.parse(decodeURIComponent(payload));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return null;
+    const record = parsed;
+    if (record.kind === "approval") {
+      const requestId = typeof record.requestId === "string" ? record.requestId.trim() : "";
+      const decision = record.decision === "approve" || record.decision === "reject" ? record.decision : null;
+      const note = typeof record.note === "string" ? record.note : record.note === null ? null : undefined;
+      if (!requestId || !decision)
+        return null;
+      return { kind: "approval", requestId, decision, ...note !== undefined ? { note } : {} };
+    }
+    if (record.kind === "input") {
+      const requestId = typeof record.requestId === "string" ? record.requestId.trim() : "";
+      const answers = record.answers && typeof record.answers === "object" && !Array.isArray(record.answers) ? Object.fromEntries(Object.entries(record.answers).filter((entry) => typeof entry[1] === "string")) : null;
+      if (!requestId || !answers)
+        return null;
+      return { kind: "input", requestId, answers };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function parseInboxResolutionSentinel(text, expectedRunId) {
+  const start = text.indexOf(RIG_INBOX_RESOLUTION_SENTINEL);
+  if (start < 0)
+    return null;
+  const end = text.indexOf(RIG_CONTROL_SENTINEL_END, start);
+  const body = text.slice(start + RIG_INBOX_RESOLUTION_SENTINEL.length, end >= 0 ? end : undefined).trim();
+  const runId = body.match(/(?:^|\s)runId=([^\s>]+)/)?.[1] ?? "";
+  if (runId && runId !== expectedRunId)
+    return null;
+  const requestedBy = body.match(/(?:^|\s)requestedBy=([^\s>]+)/)?.[1] ?? null;
+  const payload = body.match(/(?:^|\s)data=([^\s>]+)/)?.[1] ?? "";
+  const decoded = decodeInboxResolutionPayload(payload);
+  if (!decoded)
+    return null;
+  return { ...decoded, requestedBy };
+}
+var decodeRunJournalEvent = (value) => Schema.decodeUnknownSync(RunJournalEvent)(value), RUN_STATUS_TRANSITIONS, TERMINAL_RUN_STATUSES, runSessionJournalCodec;
+var init_session_journal = __esm(() => {
+  RUN_STATUS_TRANSITIONS = {
+    created: ["queued", "preparing", "running", "failed", "stopped"],
+    queued: ["preparing", "running", "failed", "stopped"],
+    preparing: ["queued", "running", "needs-attention", "failed", "stopped"],
+    running: [
+      "queued",
+      "waiting-approval",
+      "waiting-user-input",
+      "paused",
+      "validating",
+      "reviewing",
+      "closing-out",
+      "needs-attention",
+      "completed",
+      "failed",
+      "stopped"
+    ],
+    "waiting-approval": ["running", "needs-attention", "failed", "stopped"],
+    "waiting-user-input": ["running", "needs-attention", "failed", "stopped"],
+    paused: ["running", "failed", "stopped"],
+    validating: ["running", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+    reviewing: ["running", "validating", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+    "closing-out": ["running", "needs-attention", "completed", "failed", "stopped"],
+    "needs-attention": ["queued", "preparing", "running", "closing-out", "completed", "failed", "stopped"],
+    completed: [],
+    failed: ["queued", "preparing", "running", "closing-out"],
+    stopped: ["queued", "preparing", "running", "closing-out"]
+  };
+  TERMINAL_RUN_STATUSES = ["completed", "failed", "stopped"];
+  runSessionJournalCodec = {
+    foldRunSessionEntries,
+    projectRunFromSession,
+    isTerminalRunStatus,
+    canTransitionRunStatus,
+    assertRunStatusTransition,
+    sessionIdFromSessionFile,
+    timelineEntriesFromCustomEntries,
+    latestTimelineEntriesFromCustomEntries,
+    parseStopSentinel,
+    parsePauseSentinel,
+    parseResumeSentinel,
+    parseInboxResolutionSentinel
+  };
+});
+
+// packages/run-plugin/src/read-model/reconcile.ts
+import { defineCapability } from "@rig/core/capability";
+import { loadCapabilityForRoot } from "@rig/core/capability-loaders";
+import {
+  RUN_SESSION_JOURNAL_WRITER
+} from "@rig/contracts";
+async function loadCollabApi() {
+  collabApiPromise ??= import("@oh-my-pi/pi-coding-agent/collab-api").then((api) => api).catch(() => null);
+  return collabApiPromise;
+}
+function pidExists(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function projectionRunId(item) {
+  if (item.runId?.trim())
+    return item.runId.trim();
+  if (item.collab?.sessionId?.trim())
+    return item.collab.sessionId.trim();
+  if (item.session.id?.trim())
+    return item.session.id.trim();
+  return null;
+}
+function isLocallyDiscovered(item) {
+  return item.source === "session-list";
+}
+function isActiveStatus(status) {
+  if (status === null)
+    return false;
+  return !isTerminalRunStatus(status);
+}
+function shouldFlip(item, status, exists) {
+  if (!isActiveStatus(status))
+    return false;
+  if (item.collab?.stale === true)
+    return true;
+  const pid = item.collab?.pid;
+  return isLocallyDiscovered(item) && pid !== undefined && ACTIVE_LOCAL_RUN_STATUSES.has(status) && !exists(pid);
+}
+async function reconcileActiveRuns(input, deps = {}) {
+  const collabApi = deps.listCollabSessionProjections ? null : await loadCollabApi();
+  const listProjections = deps.listCollabSessionProjections ?? collabApi?.listCollabSessionProjections;
+  const journalWriter = deps.journalWriter ?? await loadCapabilityForRoot(input.workspaceRoot, RunSessionJournalWriterCap);
+  if (!journalWriter)
+    return { flipped: [], resumable: [] };
+  const exists = deps.processExists ?? pidExists;
+  if (!listProjections)
+    return { flipped: [], resumable: [] };
+  const projections = await listProjections(input.identityFilter);
+  const flipped = [];
+  for (const item of projections) {
+    const runId = projectionRunId(item);
+    const sessionPath = item.session.path || item.collab?.sessionPath || "";
+    if (!runId || !sessionPath)
+      continue;
+    const projection = projectRunFromSession(item.customEntries, runId);
+    const status = projection.status;
+    if (status === null || !shouldFlip(item, status, exists))
+      continue;
+    const result = await journalWriter.reconcileDeadPid({
+      projectRoot: input.workspaceRoot,
+      runId,
+      sessionPath,
+      reason: "lazy-reconcile:dead-pid"
+    });
+    if (result.updated)
+      flipped.push({ runId, sessionPath, reason: "lazy-reconcile:dead-pid" });
+  }
+  return { flipped, resumable: flipped };
+}
+var RunSessionJournalWriterCap, collabApiPromise = null, ACTIVE_LOCAL_RUN_STATUSES;
+var init_reconcile = __esm(() => {
+  init_session_journal();
+  RunSessionJournalWriterCap = defineCapability(RUN_SESSION_JOURNAL_WRITER);
+  ACTIVE_LOCAL_RUN_STATUSES = new Set([
+    "created",
+    "preparing",
+    "running",
+    "validating",
+    "reviewing",
+    "closing-out"
+  ]);
+});
+
+// packages/run-plugin/src/read-model/run-format.ts
+import pc from "picocolors";
+import { formatSection, formatSuccessCard, formatNextSteps } from "@rig/std-shared/cli-format";
+function projectedStatusRole(value) {
+  return typeof value === "string" && STATUS_ROLES.has(value) ? value : null;
+}
+function truncate(value, width) {
+  return value.length <= width ? value : `${value.slice(0, Math.max(0, width - 1))}\u2026`;
+}
+function pad(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+function colorForRole(role) {
+  switch (role) {
+    case "success":
+      return pc.green;
+    case "action-yellow":
+      return pc.yellow;
+    case "active-cyan":
+      return pc.cyan;
+    case "failure":
+      return pc.red;
+    case "muted":
+    case "neutral":
+      return pc.dim;
+  }
+}
+function inboxStatusRole(record) {
+  const projected = projectedStatusRole(record.statusRole);
+  if (projected)
+    return projected;
+  return record.status === "pending" ? "active-cyan" : "neutral";
+}
+function compactDate(value) {
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed))
+    return value;
+  return new Date(parsed).toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "Z");
+}
+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 runIdOf(run) {
+  return firstString(run, ["runId", "id"], "(unknown-run)");
+}
+function taskIdOf(run) {
+  return firstString(run, ["taskId", "task", "task_id"]);
+}
+function runTitleOf(run) {
+  return firstString(run, ["title", "summary", "name"], taskIdOf(run) || "(untitled)");
+}
+function requestIdOf(entry) {
+  return firstString(entry, ["requestId", "id", "approvalId", "inputId"], "(unknown-request)");
+}
+function runLikeStatusText(run) {
+  const record = run;
+  const status = typeof record.status === "string" ? record.status.trim() : "";
+  return status || "unclassified";
+}
+function runLikeStatusColor(run) {
+  const record = run;
+  return colorForRole(projectedStatusRole(record.statusRole) ?? "neutral");
+}
+function formatStatusPill(status, role) {
+  const label = status || "unclassified";
+  return colorForRole(role ?? "neutral")(`\u25CF ${label}`);
+}
+function formatLegacyAutomationSurface() {
+  return [];
+}
+function formatRunList(runs, options = {}) {
+  if (runs.length === 0) {
+    return [
+      formatSection("Runs", "none recorded"),
+      options.source === "server" ? dim("No runs recorded on the selected server.") : dim("No runs recorded in local state."),
+      "",
+      ...formatLegacyAutomationSurface()
+    ].join(`
+`);
+  }
+  const body = runs.map((run) => {
+    const row = run;
+    const runId = runIdOf(row);
+    const status = runLikeStatusText(run);
+    const runtime = firstString(row, ["runtime", "runtimeAdapter"], "");
+    return [
+      pc.bold(runId),
+      runLikeStatusColor(run)(pad(truncate(status, 12), 12)),
+      `${runTitleOf(row)}${runtime ? dim(`  ${runtime}`) : ""}`
+    ].join("  ");
+  });
+  return [formatSection("Runs", options.source === "server" ? "selected server" : "local state"), ...body, "", ...formatLegacyAutomationSurface()].join(`
+`);
+}
+function formatSubmittedRun(input) {
+  return formatSuccessCard("Run submitted", [
+    ["run", input.runId],
+    ["task", input.taskId ?? undefined],
+    ["title", input.title ?? undefined],
+    ["queue", input.queuePosition ?? undefined]
+  ]);
+}
+function formatRunCard(run, options = {}) {
+  const record = run;
+  const lines = [formatSection(options.title ?? "Run")];
+  for (const [label, value] of [
+    ["run", runIdOf(record)],
+    ["task", taskIdOf(record)],
+    ["title", runTitleOf(record)],
+    ["status", runLikeStatusText(run)],
+    ["runtime", firstString(record, ["runtime", "runtimeAdapter"], "")],
+    ["created", firstString(record, ["createdAt"], "")],
+    ["updated", firstString(record, ["updatedAt"], "")]
+  ]) {
+    if (value)
+      lines.push(`${faintBar} ${dim(label.padEnd(12))} ${label === "status" ? runLikeStatusColor(run)(value) : label === "created" || label === "updated" ? compactDate(value) : value}`);
+  }
+  const errorSummary = firstString(record, ["errorSummary"]);
+  if (errorSummary)
+    lines.push(`${faintBar} Error: ${errorSummary}`);
+  return lines.join(`
+`);
+}
+function formatRunStatus(summary, options = {}) {
+  const activeRuns = summary.activeRuns ?? [];
+  const recentRuns = summary.recentRuns ?? [];
+  const lines = [formatSection("Run status", options.source === "server" ? "selected server" : "local state")];
+  lines.push(`Active runs (${activeRuns.length})`);
+  if (activeRuns.length === 0)
+    lines.push(dim("No active runs."));
+  else
+    for (const run of activeRuns)
+      lines.push(formatRunSummaryLine(run));
+  lines.push("", `Recent runs (${recentRuns.length})`);
+  if (recentRuns.length === 0)
+    lines.push(dim("No recent terminal runs."));
+  else
+    for (const run of recentRuns.slice(0, 10))
+      lines.push(formatRunSummaryLine(run));
+  lines.push("", ...formatLegacyAutomationSurface());
+  return lines.join(`
+`);
+}
+function formatRunSummaryLine(run) {
+  const record = run;
+  const runId = runIdOf(record);
+  const taskId = taskIdOf(record);
+  const title = runTitleOf(record);
+  const status = runLikeStatusText(run);
+  const runtime = firstString(record, ["runtime", "runtimeAdapter"], "");
+  const descriptor = [taskId, title].filter(Boolean).join(" \xB7 ");
+  return `${faintBar} ${pc.bold(runId)} ${runLikeStatusColor(run)(`\u25CF ${status}`)} ${descriptor}${runtime ? dim(`  ${runtime}`) : ""}`;
+}
+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, inboxStatusRole(record))} ${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(`
+`);
+}
+var dim, faintBar, accent, STATUS_ROLES;
+var init_run_format = __esm(() => {
+  dim = pc.dim;
+  faintBar = pc.dim("\u2502");
+  accent = pc.cyan;
+  STATUS_ROLES = new Set([
+    "success",
+    "action-yellow",
+    "active-cyan",
+    "failure",
+    "muted",
+    "neutral"
+  ]);
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/guard.ts
+var TERMINAL;
+var init_guard = __esm(() => {
+  TERMINAL = new Set(["completed", "failed", "stopped"]);
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/run-status.ts
+function isTerminalRunStatus2(status) {
+  return TERMINAL_RUN_STATUSES2.includes(status);
+}
+function isActiveRunStatus(status) {
+  return !isTerminalRunStatus2(status);
+}
+function isRuntimeActiveStatus(status) {
+  return RUNTIME_ACTIVE_STATUSES.has(normalizeRunStatusToken(status));
+}
+function normalizeRunStatusToken(status) {
+  return String(status ?? "").trim().toLowerCase().replace(/[\s_]+/g, "-");
+}
+function isOperatorActiveRunStatus(status) {
+  const normalized = normalizeRunStatusToken(status);
+  if (!normalized)
+    return false;
+  return !OPERATOR_INACTIVE_RUN_STATUSES.has(normalized);
+}
+function canonicalStatusToken(status) {
+  const normalized = normalizeRunStatusToken(status);
+  if (normalized === "waiting-input")
+    return "waiting-user-input";
+  return normalized;
+}
+function asRunStatus(status) {
+  return KNOWN_RUN_STATUS[status] ? status : null;
+}
+function statusColorRole(status) {
+  switch (canonicalStatusToken(status)) {
+    case "done":
+    case "completed":
+    case "ready":
+    case "healthy":
+    case "approved":
+    case "merged":
+      return "success";
+    case "needs-attention":
+    case "waiting-approval":
+    case "waiting-user-input":
+    case "blocked":
+    case "paused":
+      return "action-yellow";
+    case "running":
+    case "adopted":
+    case "preparing":
+    case "created":
+    case "queued":
+    case "starting":
+    case "pending":
+    case "in-progress":
+    case "active":
+    case "booting":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return "active-cyan";
+    case "failed":
+    case "error":
+    case "rejected":
+      return "failure";
+    case "stopped":
+    case "cancelled":
+    case "canceled":
+    case "stale":
+      return "muted";
+    default:
+      return "neutral";
+  }
+}
+function isNeedsAttention(run) {
+  return canonicalStatusToken(run.status) === "needs-attention" || run.pendingApprovals + run.pendingInputs > 0 || run.stallCount > 0;
+}
+function phaseForStatus(status, runStatus, needsAttention) {
+  if (runStatus && isTerminalRunStatus2(runStatus))
+    return runStatus === "completed" || runStatus === "failed" || runStatus === "stopped" ? runStatus : "stopped";
+  if (needsAttention)
+    return "needs-attention";
+  switch (status) {
+    case "created":
+    case "queued":
+    case "preparing":
+    case "starting":
+    case "booting":
+      return "starting";
+    case "waiting-approval":
+    case "waiting-user-input":
+      return "waiting";
+    case "paused":
+      return "paused";
+    case "running":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return "active";
+    default:
+      return runStatus && isActiveRunStatus(runStatus) ? "active" : "unknown";
+  }
+}
+function classifyRun(run) {
+  const status = canonicalStatusToken(run.status) || (run.live && !run.stale ? "starting" : "unknown");
+  const runStatus = asRunStatus(status);
+  const isTerminal = runStatus ? isTerminalRunStatus2(runStatus) : false;
+  const isNeedsAttentionValue = isNeedsAttention(run);
+  const phase = phaseForStatus(status, runStatus, isNeedsAttentionValue);
+  return {
+    status,
+    runStatus: runStatus ?? "needs-attention",
+    phase,
+    isActive: runStatus ? isActiveRunStatus(runStatus) : !isTerminal && status !== "unknown",
+    isTerminal,
+    isNeedsAttention: isNeedsAttentionValue,
+    offersRecovery: phase === "failed"
+  };
+}
+function runStatusColorRole(run) {
+  const classification = classifyRun(run);
+  return classification.isNeedsAttention && !classification.isTerminal ? "action-yellow" : statusColorRole(classification.status);
+}
+function statusRank(run) {
+  const classification = classifyRun(run);
+  if (classification.isNeedsAttention)
+    return 0;
+  switch (classification.phase) {
+    case "needs-attention":
+      return 0;
+    case "active":
+    case "waiting":
+    case "paused":
+      return 1;
+    case "starting":
+      return 2;
+    case "completed":
+      return 3;
+    case "failed":
+      return 4;
+    case "stopped":
+      return 5;
+    case "unknown":
+      return 6;
+  }
+}
+var OPERATOR_INACTIVE_RUN_STATUSES, TERMINAL_RUN_STATUSES2, RUNTIME_ACTIVE_STATUSES, ACTIVE_RUN_STATUSES, KNOWN_RUN_STATUS;
+var init_run_status = __esm(() => {
+  OPERATOR_INACTIVE_RUN_STATUSES = new Set([
+    "completed",
+    "complete",
+    "done",
+    "success",
+    "succeeded",
+    "passed",
+    "failed",
+    "failure",
+    "error",
+    "errored",
+    "stopped",
+    "cancelled",
+    "canceled",
+    "aborted",
+    "abort",
+    "merged",
+    "closed",
+    "skipped",
+    "needs-attention",
+    "needs_attention"
+  ]);
+  TERMINAL_RUN_STATUSES2 = ["completed", "failed", "stopped"];
+  RUNTIME_ACTIVE_STATUSES = new Set([
+    "created",
+    "preparing",
+    "running",
+    "validating",
+    "reviewing",
+    "closing-out"
+  ]);
+  ACTIVE_RUN_STATUSES = [
+    "created",
+    "queued",
+    "preparing",
+    "running",
+    "waiting-approval",
+    "waiting-user-input",
+    "paused",
+    "validating",
+    "reviewing",
+    "closing-out",
+    "needs-attention"
+  ];
+  KNOWN_RUN_STATUS = Object.fromEntries([...ACTIVE_RUN_STATUSES, ...TERMINAL_RUN_STATUSES2].map((status) => [status, true]));
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/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 summarizeRunError(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/run-plugin/src/read-model/read-model-backend/projection.ts
+var exports_projection = {};
+__export(exports_projection, {
+  selectRunProjection: () => selectRunProjection,
+  runRecordsFromCollab: () => runRecordsFromCollab,
+  runRecordFromRegistryEntry: () => runRecordFromRegistryEntry,
+  resolveRunJoinTarget: () => resolveRunJoinTarget,
+  resolveJoinTarget: () => resolveJoinTarget,
+  readSessionRunEntries: () => readSessionRunEntries,
+  listRuns: () => listRuns,
+  listRunProjections: () => listRunProjections,
+  getRunProjection: () => getRunProjection,
+  getRun: () => getRun,
+  discoveryDiagnosticRunRecord: () => discoveryDiagnosticRunRecord
+});
+import { existsSync, readFileSync } from "fs";
+import { isAbsolute, relative, resolve } from "path";
+import { RUN_DISCOVERY, RUN_REGISTRY_BACKBONE } from "@rig/contracts";
+import { loadCapabilityForRoot as loadCapabilityForRoot2 } from "@rig/core/capability-loaders";
+import { defineCapability as defineCapability2 } from "@rig/core/capability";
+function registryEntryFromCollab(collab) {
+  const record = collab;
+  return {
+    roomId: collab.sessionId,
+    title: collab.title,
+    status: record.registryStatus ?? (collab.stale ? "stale" : "running"),
+    startedAt: collab.startedAt ?? null,
+    heartbeatAt: collab.updatedAt ?? null,
+    sessionPath: collab.sessionPath ?? null,
+    cwd: collab.cwd ?? null,
+    joinLink: collab.joinLink ?? null,
+    webLink: collab.webLink ?? null,
+    relayUrl: collab.relayUrl ?? null,
+    stale: collab.stale,
+    repo: collab.selectedRepo ?? null,
+    ...collab.pid === undefined ? {} : { pid: collab.pid },
+    projection: record.registryProjection ?? null
+  };
+}
+function readSessionRunEntries(sessionPath) {
+  if (!sessionPath || !existsSync(sessionPath))
+    return [];
+  try {
+    return parseSessionRunEntries(readFileSync(sessionPath, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function parseSessionRunEntries(raw) {
+  const entries = [];
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    try {
+      const parsed = JSON.parse(line);
+      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 } : {}
+      });
+    } catch {
+      continue;
+    }
+  }
+  return entries;
+}
+function stringOrNull(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function objectRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function payloadString(payload, keys) {
+  if (!payload || typeof payload !== "object")
+    return null;
+  const record = payload;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  return null;
+}
+function payloadOptions(payload) {
+  if (!payload || typeof payload !== "object")
+    return;
+  const record = payload;
+  const options = Array.isArray(record.options) ? record.options : Array.isArray(record.choices) ? record.choices : null;
+  const values = options?.filter((value) => typeof value === "string" && value.trim().length > 0) ?? [];
+  return values.length > 0 ? values : undefined;
+}
+function inboxRequest(request, kind) {
+  const fallback = kind === "approval" ? "Approval requested" : "Input requested";
+  const body = payloadString(request.payload, ["body", "description", "detail", "details"]);
+  const options = payloadOptions(request.payload);
+  return {
+    requestId: request.requestId,
+    kind,
+    title: payloadString(request.payload, ["title", "message", "reason", "prompt", "summary"]) ?? fallback,
+    ...body !== undefined ? { body } : {},
+    ...options ? { options } : {},
+    requestedAt: request.requestedAt ?? null,
+    source: "run"
+  };
+}
+function inboxFromProjection(projection) {
+  return [
+    ...projection.pendingApprovals.map((request) => inboxRequest(request, "approval")),
+    ...projection.pendingUserInputs.map((request) => inboxRequest(request, "input"))
+  ].sort((a, b) => (Date.parse(a.requestedAt ?? "") || 0) - (Date.parse(b.requestedAt ?? "") || 0));
+}
+function isProjectPath(projectRoot, cwd) {
+  const root = resolve(projectRoot);
+  const candidate = resolve(cwd);
+  const pathFromRoot = relative(root, candidate);
+  return pathFromRoot === "" || !pathFromRoot.startsWith("../") && pathFromRoot !== ".." && !isAbsolute(pathFromRoot);
+}
+function sourceFromEntry(projectRoot, projection, entry) {
+  const candidates = [
+    stringOrNull(projection.collabCwd),
+    stringOrNull(projection.cwd),
+    stringOrNull(entry.cwd),
+    stringOrNull(projection.worktreePath)
+  ].filter((cwd) => cwd !== null);
+  return candidates.some((cwd) => isProjectPath(projectRoot, cwd)) ? "local" : "remote";
+}
+function pendingRequests(value, fallbackKind) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((item) => {
+    const record = objectRecord(item);
+    const requestId = stringOrNull(record?.requestId) ?? stringOrNull(record?.id);
+    if (!record || !requestId)
+      return [];
+    return [{
+      requestId,
+      requestKind: stringOrNull(record.requestKind) ?? stringOrNull(record.kind) ?? fallbackKind,
+      actionId: stringOrNull(record.actionId),
+      payload: "payload" in record ? record.payload : record,
+      requestedAt: stringOrNull(record.requestedAt) ?? stringOrNull(record.at) ?? ""
+    }];
+  });
+}
+function emptyFoldedProjection(runId, projection, toRunStatus) {
+  const projectionRecord = projection;
+  const nestedProjection = objectRecord(projectionRecord.projection);
+  const pendingApprovals = pendingRequests(nestedProjection?.pendingApprovals ?? projectionRecord.pendingApprovals, "approval");
+  const pendingUserInputs = pendingRequests(nestedProjection?.pendingUserInputs ?? nestedProjection?.pendingInputs ?? projectionRecord.pendingUserInputs ?? (Array.isArray(projectionRecord.pendingInputs) ? projectionRecord.pendingInputs : undefined), "user-input");
+  const nestedRecord = objectRecord(nestedProjection?.record);
+  const nestedFolded = nestedProjection;
+  return {
+    ...EMPTY_PROJECTION,
+    ...nestedFolded ?? {},
+    record: {
+      ...nestedRecord ?? {},
+      runId,
+      ...projection.taskId ? { taskId: projection.taskId } : {},
+      ...projection.title ? { title: projection.title } : {},
+      ...projection.startedAt ? { startedAt: projection.startedAt } : {},
+      ...projection.updatedAt ? { updatedAt: projection.updatedAt } : {},
+      ...projection.completedAt ? { completedAt: projection.completedAt } : {},
+      ...projection.sessionPath ? { sessionPath: projection.sessionPath } : {},
+      ...projection.worktreePath ? { worktreePath: projection.worktreePath } : {},
+      ...projection.prUrl ? { prUrl: projection.prUrl } : {}
+    },
+    status: toRunStatus(projection.status) ?? toRunStatus(nestedProjection?.status),
+    pendingApprovals,
+    pendingUserInputs,
+    steeringCount: projection.steeringCount ?? numberOrNull(nestedProjection?.steeringCount) ?? 0,
+    stallCount: projection.stallCount ?? numberOrNull(nestedProjection?.stallCount) ?? 0,
+    lastEventAt: projection.updatedAt ?? stringOrNull(nestedProjection?.lastEventAt)
+  };
+}
+function foldedProjectionForRun(runId, projection, sessionPath, toRunStatus) {
+  const registryFolded = emptyFoldedProjection(runId, projection, toRunStatus);
+  const sessionEntries = readSessionRunEntries(sessionPath);
+  if (sessionEntries.length === 0)
+    return { projection: registryFolded, hasSessionEntries: false };
+  const sessionFolded = foldRunSessionEntries(sessionEntries, runId);
+  if (sessionFolded.lastSeq === 0)
+    return { projection: registryFolded, hasSessionEntries: false };
+  return {
+    projection: {
+      ...registryFolded,
+      ...sessionFolded,
+      record: {
+        ...registryFolded.record,
+        ...sessionFolded.record,
+        runId
+      },
+      status: sessionFolded.status ?? registryFolded.status,
+      lastEventAt: sessionFolded.lastEventAt ?? registryFolded.lastEventAt
+    },
+    hasSessionEntries: true
+  };
+}
+function runRecordFromRegistryEntry(projectRoot, entry, toRunStatus) {
+  const projection = entry.projection && typeof entry.projection === "object" ? entry.projection : {};
+  const projectionRecord = projection;
+  const runId = stringOrNull(projection.runId) ?? entry.roomId;
+  const sessionPath = stringOrNull(projection.sessionPath) ?? stringOrNull(entry.sessionPath) ?? null;
+  const foldedResult = foldedProjectionForRun(runId, projection, sessionPath, toRunStatus);
+  const folded = foldedResult.projection;
+  const pushedStatus = folded.status ?? toRunStatus(projection.status) ?? toRunStatus(entry.status);
+  const status = entry.stale ? pushedStatus && isTerminalRunStatus(pushedStatus) ? pushedStatus : "stale" : pushedStatus ?? "running";
+  const collabCwd = stringOrNull(projection.collabCwd) ?? stringOrNull(projection.cwd) ?? stringOrNull(entry.cwd) ?? stringOrNull(projection.worktreePath);
+  const pendingApprovals = foldedResult.hasSessionEntries ? folded.pendingApprovals.length : numberOrNull(projectionRecord.pendingApprovals) ?? folded.pendingApprovals.length;
+  const pendingInputs = foldedResult.hasSessionEntries ? folded.pendingUserInputs.length : numberOrNull(projectionRecord.pendingInputs) ?? folded.pendingUserInputs.length;
+  return {
+    runId,
+    taskId: stringOrNull(projection.taskId),
+    title: stringOrNull(projection.title) ?? entry.title,
+    status,
+    source: sourceFromEntry(projectRoot, projection, entry),
+    live: !entry.stale,
+    stale: entry.stale,
+    startedAt: stringOrNull(projection.startedAt) ?? entry.startedAt ?? null,
+    updatedAt: stringOrNull(projection.updatedAt) ?? entry.heartbeatAt ?? null,
+    completedAt: stringOrNull(projection.completedAt),
+    joinLink: stringOrNull(projection.joinLink) ?? entry.joinLink ?? null,
+    webLink: stringOrNull(projection.webLink) ?? entry.webLink ?? null,
+    relayUrl: stringOrNull(projection.relayUrl) ?? entry.relayUrl ?? null,
+    sessionPath,
+    prUrl: stringOrNull(projection.prUrl),
+    worktreePath: stringOrNull(projection.worktreePath) ?? collabCwd,
+    pendingApprovals,
+    pendingInputs,
+    steeringCount: projection.steeringCount ?? folded.steeringCount ?? 0,
+    stallCount: projection.stallCount ?? folded.stallCount ?? 0,
+    errorSummary: stringOrNull(projection.errorSummary) ?? summarizeRunError(folded),
+    timeline: Array.isArray(projection.timeline) ? [...projection.timeline] : [...timelineEntriesFromCustomEntries([])],
+    inbox: inboxFromProjection(folded),
+    collabCwd: collabCwd ?? null,
+    projection: folded
+  };
+}
+function runRecordsFromCollab(projectRoot, collabs, toRunStatus) {
+  return sortByRecency(collabs.map((collab) => runRecordFromRegistryEntry(projectRoot, registryEntryFromCollab(collab), toRunStatus)).filter((record) => record !== null));
+}
+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;
+  });
+}
+function discoveryDiagnosticRunRecord(projectRoot, error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  const runId = DISCOVERY_DIAGNOSTIC_RUN_ID;
+  const projection = {
+    ...EMPTY_PROJECTION,
+    record: { runId, title: "Registry discovery unavailable" },
+    status: "needs-attention",
+    stallCount: 1
+  };
+  return {
+    runId,
+    taskId: null,
+    title: "Registry discovery unavailable",
+    status: "needs-attention",
+    source: "remote",
+    live: false,
+    stale: true,
+    startedAt: null,
+    updatedAt: null,
+    completedAt: null,
+    joinLink: null,
+    webLink: null,
+    relayUrl: null,
+    sessionPath: null,
+    prUrl: null,
+    worktreePath: null,
+    pendingApprovals: 0,
+    pendingInputs: 0,
+    steeringCount: 0,
+    stallCount: 1,
+    errorSummary: `registry discovery unavailable: ${detail}`,
+    timeline: [],
+    inbox: [],
+    collabCwd: null,
+    projection
+  };
+}
+async function listRunProjections(projectRoot, filter = {}) {
+  try {
+    const discovery = await loadCapabilityForRoot2(projectRoot, RunDiscoveryCap);
+    if (!discovery)
+      return [discoveryDiagnosticRunRecord(projectRoot, "run discovery capability unavailable")];
+    const backbone = await loadCapabilityForRoot2(projectRoot, RunRegistryBackboneCap);
+    if (!backbone)
+      return [discoveryDiagnosticRunRecord(projectRoot, "run registry backbone capability unavailable")];
+    const collabs = await discovery.listActiveRunCollab(projectRoot, filter, { isRuntimeActiveStatus });
+    return runRecordsFromCollab(projectRoot, collabs, backbone.registryStatusToRunStatus);
+  } catch (error) {
+    return [discoveryDiagnosticRunRecord(projectRoot, error)];
+  }
+}
+function selectRunProjection(runs, runId) {
+  const exactRun = runs.find((run) => run.runId === runId);
+  if (exactRun)
+    return exactRun;
+  const exactTask = runs.find((run) => run.taskId === runId);
+  if (exactTask)
+    return exactTask;
+  const prefixMatches = runs.filter((run) => run.runId.startsWith(runId));
+  if (prefixMatches.length === 1)
+    return prefixMatches[0] ?? null;
+  if (prefixMatches.length > 1) {
+    const matches = prefixMatches.map((run) => run.runId).join(", ");
+    throw new Error(`Ambiguous run id prefix "${runId}" matched ${prefixMatches.length} runs: ${matches}`);
+  }
+  return runs.find((run) => run.runId === DISCOVERY_DIAGNOSTIC_RUN_ID) ?? null;
+}
+async function getRunProjection(projectRoot, runId, filter = {}) {
+  const runs = await listRunProjections(projectRoot, filter);
+  return selectRunProjection(runs, runId);
+}
+async function resolveRunJoinTarget(projectRoot, runId, filter = {}) {
+  const run = await getRunProjection(projectRoot, runId, filter);
+  if (!run || !run.joinLink)
+    return null;
+  return { runId: run.runId, taskId: run.taskId, joinLink: run.joinLink, cwd: run.collabCwd ?? run.sessionPath, stale: run.stale };
+}
+var RunDiscoveryCap, RunRegistryBackboneCap, EMPTY_PROJECTION, DISCOVERY_DIAGNOSTIC_RUN_ID = "__registry_discovery_error__", listRuns, getRun, resolveJoinTarget;
+var init_projection = __esm(() => {
+  init_session_journal();
+  init_run_status();
+  RunDiscoveryCap = defineCapability2(RUN_DISCOVERY);
+  RunRegistryBackboneCap = defineCapability2(RUN_REGISTRY_BACKBONE);
+  EMPTY_PROJECTION = foldRunSessionEntries([], "");
+  listRuns = listRunProjections;
+  getRun = getRunProjection;
+  resolveJoinTarget = resolveRunJoinTarget;
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/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,
+    kind: kind === "approvals" ? "approval" : "input"
+  }));
+}
+function matchesFilters(run, filters) {
+  if (filters.run && run.runId !== filters.run)
+    return false;
+  if (filters.task && run.taskId !== filters.task && run.runId !== filters.task)
+    return false;
+  return true;
+}
+async function listInboxRecords(input, kind, filters = {}, deps = {}) {
+  const runs = await (deps.listRuns ?? listRuns)(input.projectRoot);
+  return runs.filter((run) => matchesFilters(run, filters)).flatMap((run) => recordsFromRun(run, kind));
+}
+var init_inbox = __esm(() => {
+  init_projection();
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/inspect.ts
+import { RIG_RUN_LOG_ENTRY } from "@rig/contracts";
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function firstString2(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim().length > 0)
+      return value;
+  }
+  return null;
+}
+function stringifyLogPayload(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  const record = asRecord(value);
+  if (!record)
+    return null;
+  const direct = firstString2(record, ["line", "message", "text", "content", "output", "summary", "detail"]);
+  if (direct)
+    return direct;
+  try {
+    return JSON.stringify(record);
+  } catch {
+    return String(record);
+  }
+}
+function logLineFromValue(value) {
+  const record = asRecord(value);
+  if (!record)
+    return stringifyLogPayload(value);
+  const direct = firstString2(record, ["line", "message", "text", "content", "output", "summary", "detail"]);
+  if (direct)
+    return direct;
+  if ("payload" in record)
+    return stringifyLogPayload(record.payload);
+  if ("data" in record)
+    return stringifyLogPayload(record.data);
+  return stringifyLogPayload(record);
+}
+function logLineFromSessionEntry(entry) {
+  if (entry.type !== "custom" || entry.customType !== RIG_RUN_LOG_ENTRY)
+    return null;
+  return logLineFromValue(entry.data);
+}
+function logLinesFromProjection(projection) {
+  const projected = projection;
+  const lines = [];
+  for (const key of ["logs", "logEntries", "journalLogs", "runLogs"]) {
+    const entries = projected[key];
+    if (!Array.isArray(entries))
+      continue;
+    for (const entry of entries) {
+      const line = logLineFromValue(entry);
+      if (line !== null)
+        lines.push(line);
+    }
+  }
+  return lines;
+}
+function extractRunLogs(run, deps = {}) {
+  const projectedLines = logLinesFromProjection(run.projection);
+  if (projectedLines.length > 0)
+    return projectedLines;
+  return (deps.readSessionRunEntries ?? readSessionRunEntries)(run.sessionPath).map(logLineFromSessionEntry).filter((line) => line !== null);
+}
+function summarizeRunFailures(run) {
+  const failures = [];
+  const useful = summarizeRunError(run.projection);
+  if (useful)
+    failures.push(`${run.runId}: ${useful}`);
+  if (run.status === "failed" || run.projection.status === "failed")
+    failures.push(`${run.runId}: run status failed`);
+  for (const phase of run.projection.closeoutPhases) {
+    if (phase.outcome === "failed")
+      failures.push(`${run.runId}: closeout ${phase.phase} failed${phase.detail ? ` \u2014 ${phase.detail}` : ""}`);
+  }
+  for (const anomaly of run.projection.anomalies) {
+    failures.push(`${run.runId}: anomaly ${anomaly.kind}${anomaly.detail ? ` \u2014 ${anomaly.detail}` : ""}`);
+  }
+  return failures;
+}
+function runInspectSummaryRows(runs, options = {}) {
+  const attachable = runs.filter((run) => Boolean(run.joinLink && !run.stale)).length;
+  const pendingInbox = options.pendingInbox ?? runs.reduce((total, run) => total + run.pendingApprovals + run.pendingInputs, 0);
+  return [
+    { id: "title", label: "Inspect", currentValue: "runtime", heading: true, description: "session/runtime inspection rows from @rig/client" },
+    { id: "inspect:sessions", label: "RUNS", currentValue: String(runs.length), heading: true, description: `${attachable} attachable OMP collab links` },
+    { id: "inspect:cwd", label: "PROJECT ROOT", currentValue: options.projectRoot ?? "", heading: true, description: "selected target/project root used by Rig chrome" },
+    { id: "inspect:inbox", label: "INBOX", currentValue: String(pendingInbox), values: ["open"], description: "pending run gates; open Inbox to resolve" },
+    { id: "inspect:runs", label: "RUNS", currentValue: String(runs.length), values: ["open"], description: "open Runs to inspect individual run detail, logs, and attach controls" },
+    { id: "inspect:audit", label: "AUDIT", currentValue: "unavailable", heading: true, description: "CLI inspect audit has no cockpit equivalent; use rig inspect audit" }
+  ];
+}
+var init_inspect = __esm(() => {
+  init_projection();
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/stats.ts
+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 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 computeStats(projectRootOrRuns, options = {}) {
+  const sinceMs = options.since ? options.since.getTime() : null;
+  const allRuns = typeof projectRootOrRuns === "string" ? await (options.listRuns ?? (await Promise.resolve().then(() => (init_projection(), exports_projection))).listRuns)(projectRootOrRuns) : projectRootOrRuns;
+  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;
+  let approvalsApproved = 0;
+  let approvalsRejected = 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.projection.pendingApprovals.length;
+    for (const approval of run.projection.resolvedApprovals) {
+      if (approval.decision === "approve")
+        approvalsApproved += 1;
+      if (approval.decision === "reject")
+        approvalsRejected += 1;
+    }
+  }
+  const approvalsRequested = approvalsPending + approvalsApproved + approvalsRejected;
+  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,
+    approvalsApproved,
+    approvalsRejected,
+    approvalsPending
+  };
+}
+var init_stats = __esm(() => {
+  init_run_status();
+  init_run_status();
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/index.ts
+var init_read_model_backend = __esm(() => {
+  init_projection();
+  init_guard();
+  init_inbox();
+  init_inspect();
+  init_run_status();
+  init_stats();
+});
+
+// packages/run-plugin/src/read-model/read-model-service.ts
+var exports_read_model_service = {};
+__export(exports_read_model_service, {
+  runReadModelService: () => runReadModelService
+});
+import {
+  RUN_REGISTRY_BACKBONE as RUN_REGISTRY_BACKBONE2
+} from "@rig/contracts";
+import { defineCapability as defineCapability3 } from "@rig/core/capability";
+import { requireInstalledCapability } from "@rig/core/capability-loaders";
+function registryBackbone() {
+  return requireInstalledCapability(RunRegistryBackboneCap2, "RUN_REGISTRY_BACKBONE capability unavailable: the run-worker autohost installs it before building registry projections; ensure @rig/transport-plugin is installed.");
+}
+function discoveryFilter(filter) {
+  return filter ?? {};
+}
+function requestedKinds(kind) {
+  if (kind === "approval")
+    return ["approvals"];
+  if (kind === "input")
+    return ["inputs"];
+  return ["approvals", "inputs"];
+}
+function sourceMatches(run, source) {
+  return !source || source === "all" || run.source === source;
+}
+function failureSummaries(run) {
+  return summarizeRunFailures(run).map((summary) => ({ kind: "run", summary }));
+}
+function inboxRecord(record) {
+  return {
+    runId: record.runId,
+    taskId: record.taskId,
+    requestId: record.requestId,
+    kind: record.kind,
+    status: record.status,
+    title: record.prompt,
+    prompt: record.prompt,
+    requestedAt: record.requestedAt,
+    payload: record.payload,
+    source: "run"
+  };
+}
+async function listedRuns(input) {
+  const runs = await listRuns(input.projectRoot, discoveryFilter(input.discoveryFilter));
+  return runs.filter((run) => {
+    if (input.taskId && run.taskId !== input.taskId && run.runId !== input.taskId)
+      return false;
+    return sourceMatches(run, input.source);
+  });
+}
+async function selectedRun(input) {
+  return getRun(input.projectRoot, input.id, discoveryFilter(input.discoveryFilter));
+}
+async function representativeRun(input) {
+  const runs = await listedRuns({
+    projectRoot: input.projectRoot,
+    taskId: input.taskId,
+    discoveryFilter: input.discoveryFilter
+  });
+  for (const run of runs)
+    return run;
+  return selectedRun({ projectRoot: input.projectRoot, id: input.taskId, discoveryFilter: input.discoveryFilter });
+}
+async function readDetails(input) {
+  const run = await selectedRun(input);
+  if (!run)
+    return null;
+  const pendingInbox = run.inbox;
+  const inboxCounts = {
+    approvals: run.pendingApprovals,
+    inputs: run.pendingInputs,
+    total: run.pendingApprovals + run.pendingInputs
+  };
+  const sessionEntries = run.sessionPath ? readSessionRunEntries(run.sessionPath) : undefined;
+  return {
+    run,
+    projection: run.projection,
+    pendingInbox,
+    inboxCounts,
+    sourceTask: null,
+    ...sessionEntries ? { sessionEntries } : {},
+    failures: failureSummaries(run),
+    logs: input.includeLogs ? extractRunLogs(run) : []
+  };
+}
+async function inboxRecords(input) {
+  const out = [];
+  for (const kind of requestedKinds(input.kind)) {
+    const records = await listInboxRecords({ projectRoot: input.projectRoot }, kind, { ...input.runId ? { run: input.runId } : {}, ...input.taskId ? { task: input.taskId } : {} }, { listRuns: (projectRoot) => listedRuns({ projectRoot, discoveryFilter: input.discoveryFilter }) });
+    out.push(...records.map(inboxRecord));
+  }
+  return out;
+}
+function classify(run) {
+  const classification = classifyRun(run);
+  return {
+    ...classification,
+    role: runStatusColorRole(run),
+    rank: statusRank(run)
+  };
+}
+function normalizeStageName(value) {
+  const key = value?.toLowerCase().replace(/[_\s]+/g, "-");
+  switch (key) {
+    case "connect":
+    case "collab-host-started":
+      return "Connect";
+    case "github-sync":
+    case "github":
+    case "running-reflection":
+      return "GitHub-sync";
+    case "created":
+    case "queued":
+    case "prepare":
+    case "preparing":
+      return "Prepare";
+    case "launch":
+    case "starting":
+    case "booting":
+    case "running":
+    case "paused":
+      return "Launch";
+    case "plan":
+    case "planning":
+      return "Plan";
+    case "implement":
+    case "implementation":
+      return "Implement";
+    case "validate":
+    case "validating":
+      return "Validate";
+    case "commit":
+      return "Commit";
+    case "push":
+    case "pr-opened":
+    case "open-pr":
+      return "Open-PR";
+    case "pr-review-merge":
+    case "review":
+    case "reviewing":
+    case "review-ci":
+      return "Review/CI";
+    case "merge":
+      return "Merge";
+    case "closing-out":
+    case "completed":
+    case "complete":
+    case "waiting-approval":
+    case "waiting-input":
+    case "waiting-user-input":
+    case "needs-attention":
+    case "failed":
+    case "stopped":
+      return "Complete/Needs-attention/Failed";
+    default:
+      return null;
+  }
+}
+function stageStatusFromRunStatus(value) {
+  const key = value?.toLowerCase().replace(/[_\s]+/g, "-");
+  switch (key) {
+    case "failed":
+      return "failed";
+    case "needs-attention":
+      return "needs-attention";
+    case "stopped":
+      return "stopped";
+    case "paused":
+      return "paused";
+    case "waiting-approval":
+      return "waiting-approval";
+    case "waiting-input":
+      return "waiting-input";
+    case "waiting-user-input":
+      return "waiting-user-input";
+    case "running":
+    case "starting":
+    case "booting":
+    case "started":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return "running";
+    default:
+      return "completed";
+  }
+}
+function terminalStageStatus(classification) {
+  if (classification.isNeedsAttention)
+    return "needs-attention";
+  switch (classification.phase) {
+    case "completed":
+      return "completed";
+    case "failed":
+      return "failed";
+    case "stopped":
+      return "stopped";
+    case "paused":
+      return "paused";
+    default:
+      return classification.isTerminal ? "completed" : null;
+  }
+}
+function projectRunStages(run) {
+  const classification = classify(run);
+  const statuses = new Map;
+  const details = new Map;
+  for (const stage of RUN_DETAIL_STAGES)
+    statuses.set(stage, "pending");
+  for (const history of run.projection.statusHistory ?? []) {
+    const stage = normalizeStageName(history.to);
+    if (stage) {
+      statuses.set(stage, stageStatusFromRunStatus(history.to));
+      if (history.reason)
+        details.set(stage, history.reason);
+    }
+  }
+  for (const entry of run.timeline ?? []) {
+    const stage = normalizeStageName(entry.stage ?? entry.type);
+    if (!stage)
+      continue;
+    statuses.set(stage, stageStatusFromRunStatus(entry.status ?? entry.type));
+    if (entry.detail)
+      details.set(stage, entry.detail);
+  }
+  for (const phase of run.projection.closeoutPhases ?? []) {
+    const stage = normalizeStageName(phase.phase);
+    if (!stage)
+      continue;
+    statuses.set(stage, phase.outcome === "failed" ? "failed" : phase.outcome === "completed" ? "completed" : "running");
+    if (phase.detail)
+      details.set(stage, phase.detail);
+  }
+  const terminalStatus = terminalStageStatus(classification);
+  if (terminalStatus) {
+    statuses.set("Complete/Needs-attention/Failed", terminalStatus);
+  }
+  return RUN_DETAIL_STAGES.map((stage) => ({
+    id: `stage:${stage}`,
+    label: stage,
+    currentValue: statuses.get(stage) ?? "pending",
+    description: details.get(stage) ?? "rig.run timeline / closeout projection"
+  }));
+}
+function buildRegistryProjection(input) {
+  const folded = projectRunFromSession(input.entries, input.runId);
+  const timeline = latestTimelineEntriesFromCustomEntries(input.entries, input.timelineLimit ?? REGISTRY_PROJECTION_TIMELINE_LIMIT);
+  const cwd = input.cwd ?? process.cwd();
+  const collabCwd = input.collabCwd ?? cwd;
+  const dispatchHandle = input.dispatchHandle?.trim() || null;
+  return {
+    runId: input.runId,
+    taskId: typeof folded.record.taskId === "string" ? folded.record.taskId : input.taskId ?? null,
+    title: typeof folded.record.title === "string" ? folded.record.title : input.title,
+    status: registryBackbone().coerceRegistryStatus(folded.status, "running"),
+    source: "local",
+    startedAt: typeof folded.record.startedAt === "string" ? folded.record.startedAt : null,
+    updatedAt: folded.lastEventAt ?? (typeof folded.record.updatedAt === "string" ? folded.record.updatedAt : new Date().toISOString()),
+    completedAt: typeof folded.record.completedAt === "string" ? folded.record.completedAt : null,
+    joinLink: input.joinLink ?? null,
+    webLink: input.webLink ?? null,
+    relayUrl: input.relayUrl ?? null,
+    sessionPath: typeof folded.record.sessionPath === "string" ? folded.record.sessionPath : input.sessionPath ?? null,
+    prUrl: typeof folded.record.prUrl === "string" ? folded.record.prUrl : null,
+    worktreePath: typeof folded.record.worktreePath === "string" ? folded.record.worktreePath : cwd,
+    collabCwd,
+    cwd,
+    dispatchHandle,
+    pendingApprovals: folded.pendingApprovals.length,
+    pendingInputs: folded.pendingUserInputs.length,
+    steeringCount: folded.steeringCount,
+    stallCount: folded.stallCount,
+    ...typeof folded.record.errorText === "string" ? { errorSummary: folded.record.errorText } : { errorSummary: null },
+    timeline: [...timeline]
+  };
+}
+var REGISTRY_PROJECTION_TIMELINE_LIMIT = 100, RunRegistryBackboneCap2, RUN_DETAIL_STAGES, runReadModelService;
+var init_read_model_service = __esm(() => {
+  init_session_journal();
+  init_reconcile();
+  init_run_format();
+  init_read_model_backend();
+  RunRegistryBackboneCap2 = defineCapability3(RUN_REGISTRY_BACKBONE2);
+  RUN_DETAIL_STAGES = [
+    "Connect",
+    "GitHub-sync",
+    "Prepare",
+    "Launch",
+    "Plan",
+    "Implement",
+    "Validate",
+    "Commit",
+    "Open-PR",
+    "Review/CI",
+    "Merge",
+    "Complete/Needs-attention/Failed"
+  ];
+  runReadModelService = {
+    async listRuns(input) {
+      return listedRuns(input);
+    },
+    async getRepresentativeRun(input) {
+      return representativeRun(input);
+    },
+    async getRun(input) {
+      return selectedRun({ projectRoot: input.projectRoot, id: input.selector.id, discoveryFilter: input.discoveryFilter });
+    },
+    async getRunProjection(input) {
+      const run = await selectedRun({ projectRoot: input.projectRoot, id: input.runId, discoveryFilter: input.discoveryFilter });
+      return run?.projection ?? null;
+    },
+    buildSessionProjection(input) {
+      return projectRunFromSession(input.entries, input.runId);
+    },
+    buildRegistryProjection,
+    async getRunDetails(input) {
+      return readDetails({
+        projectRoot: input.projectRoot,
+        id: input.selector.id,
+        includeLogs: input.includeLogs,
+        discoveryFilter: input.discoveryFilter
+      });
+    },
+    async inspectRun(input) {
+      const details = await readDetails({
+        projectRoot: input.projectRoot,
+        id: input.selector.id,
+        includeLogs: input.includeLogs,
+        discoveryFilter: input.discoveryFilter
+      });
+      if (!details)
+        return null;
+      return {
+        details,
+        classification: classify(details.run),
+        rows: runInspectSummaryRows([details.run], { projectRoot: input.projectRoot, pendingInbox: details.inboxCounts.total })
+      };
+    },
+    listInboxRecords: inboxRecords,
+    async getInboxCounts(input) {
+      const records = await inboxRecords(input);
+      const approvals = records.filter((record) => record.kind === "approval").length;
+      const inputs = records.filter((record) => record.kind === "input").length;
+      return { approvals, inputs, total: approvals + inputs };
+    },
+    async getStats(input) {
+      const since = input.since ? new Date(input.since) : null;
+      const runs = input.runs ?? await listedRuns({ projectRoot: input.projectRoot, discoveryFilter: input.discoveryFilter });
+      return computeStats(runs, { since });
+    },
+    async getInspectRows(input) {
+      const runs = input.runs ?? await listedRuns({ projectRoot: input.projectRoot, discoveryFilter: input.discoveryFilter });
+      return runInspectSummaryRows(runs, { projectRoot: input.projectRoot, pendingInbox: input.pendingInbox ?? null });
+    },
+    isRuntimeActiveStatus,
+    isOperatorActiveRunStatus,
+    classifyRun: classify,
+    projectRunStages,
+    formatRunList,
+    formatRunCard,
+    formatRunStatus,
+    formatSubmittedRun,
+    formatInboxList,
+    reconcileActiveRuns: (input) => reconcileActiveRuns(input)
+  };
+});
+
+// packages/run-plugin/src/read-model/stats-command.ts
+var exports_stats_command = {};
+__export(exports_stats_command, {
+  parseSinceOption: () => parseSinceOption,
+  formatStatsRows: () => formatStatsRows,
+  executeStats: () => executeStats
+});
+import { RUN_READ_MODEL } from "@rig/contracts";
+import { defineCapability as defineCapability4 } from "@rig/core/capability";
+import { requireCapabilityForRoot } from "@rig/core/capability-loaders";
+import { CliError, requireNoExtraArgs, takeOption } from "@rig/std-shared/cli-args";
+import { formatStatsTable, printFormattedOutput } from "@rig/std-shared/cli-format";
+function parseSinceOption(value, now = new Date) {
+  if (!value?.trim())
+    return null;
+  const trimmed = value.trim();
+  const relative2 = trimmed.match(/^(\d+)d$/i);
+  if (relative2?.[1]) {
+    const days = Number.parseInt(relative2[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 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(stats2) {
+  return [
+    ["window", stats2.since ? `since ${stats2.since}` : "all runs"],
+    ["total runs", stats2.totalRuns],
+    ["completed", `${stats2.completedRuns} (${formatRatePercent(stats2.completionRate)})`],
+    ["failed", `${stats2.failedRuns} (${formatRatePercent(stats2.failureRate)})`],
+    ["needs attention", `${stats2.needsAttentionRuns} (${formatRatePercent(stats2.needsAttentionRate)})`],
+    ["median run time", formatDuration(stats2.medianCompletionMs)],
+    ["steering", stats2.steeringTotal],
+    ["stalls", stats2.stallTotal],
+    ["pending approvals", stats2.approvalsPending]
+  ];
+}
+async function executeStats(context, args, deps = {}) {
+  const list = [...args];
+  const [first = "show", ...rest] = list;
+  const command = first.startsWith("-") ? "show" : first;
+  const commandArgs = first.startsWith("-") ? list : rest;
+  if (command === "help") {
+    printFormattedOutput(`Usage: ${STATS_USAGE}`);
+    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, STATS_USAGE);
+  const since = parseSinceOption(sinceResult.value);
+  const readModel = await requireCapabilityForRoot(context.projectRoot, RunReadModelCap, "RUN_READ_MODEL capability unavailable for this project root: load @rig/run-plugin (standard bundle).");
+  const details = await readModel.getStats({
+    projectRoot: context.projectRoot,
+    since: since ? since.toISOString() : null,
+    ...deps.listRuns ? { runs: await deps.listRuns(context.projectRoot) } : {}
+  });
+  if ((context.outputMode ?? "text") === "text")
+    printFormattedOutput(formatStatsTable(formatStatsRows(details)));
+  return { ok: true, group: "stats", command, details };
+}
+var DAY_MS, STATS_USAGE = "rig stats [show] [--since <7d|30d|ISO date>]", RunReadModelCap;
+var init_stats_command = __esm(() => {
+  DAY_MS = 24 * 60 * 60 * 1000;
+  RunReadModelCap = defineCapability4(RUN_READ_MODEL);
+});
+
+// packages/run-plugin/src/read-model/inspect-command.ts
+var exports_inspect_command = {};
+__export(exports_inspect_command, {
+  executeInspect: () => executeInspect
+});
+import { RUN_READ_MODEL as RUN_READ_MODEL2, TASK_CLI_DATA_CAPABILITY } from "@rig/contracts";
+import { defineCapability as defineCapability5 } from "@rig/core/capability";
+import { requireCapabilityForRoot as requireCapabilityForRoot2 } from "@rig/core/capability-loaders";
+import { CliError as CliError2, requireNoExtraArgs as requireNoExtraArgs2, requireOption, takeOption as takeOption2 } from "@rig/std-shared/cli-args";
+import { printFormattedOutput as printFormattedOutput2 } from "@rig/std-shared/cli-format";
+function inspectHelpText() {
+  return [
+    `Usage: ${INSPECT_USAGE}`,
+    "",
+    "Commands:",
+    "  logs --task <id>              Print log lines from a projected run for a task.",
+    "  artifact --task <id> --file <name>",
+    "                                Preview a single task artifact.",
+    "  artifacts --task <id>         List task artifacts.",
+    "  run-logs --run <id>           Print log lines from a run journal.",
+    "  runs                          List projected runs.",
+    "  diff --task <id>              List files changed by a task.",
+    "  graph [--task <id>]           Print the task dependency graph.",
+    "  failures --task <id>          Print run read-model failure summaries for a task."
+  ].join(`
+`);
+}
+function printInspectHelp() {
+  printFormattedOutput2(inspectHelpText());
+}
+function toRunLike(run, classification) {
+  return {
+    runId: run.runId,
+    taskId: run.taskId,
+    title: run.title,
+    status: classification?.status ?? run.status,
+    runStatus: classification?.runStatus,
+    statusPhase: classification?.phase,
+    statusRole: classification?.role,
+    statusRank: classification?.rank,
+    isActive: classification?.isActive,
+    isTerminal: classification?.isTerminal,
+    isNeedsAttention: classification?.isNeedsAttention,
+    source: run.source,
+    live: run.live,
+    stale: run.stale,
+    startedAt: run.startedAt,
+    updatedAt: run.updatedAt,
+    completedAt: run.completedAt,
+    joinLink: run.joinLink,
+    prUrl: run.prUrl,
+    pendingApprovals: run.pendingApprovals,
+    pendingInputs: run.pendingInputs,
+    steeringCount: run.steeringCount,
+    stallCount: run.stallCount
+  };
+}
+function requireRunId(value, usage) {
+  if (!value || !value.trim())
+    throw new CliError2(`${usage} requires a run id.`, 2, { hint: "Run `rig inspect runs` to find run ids." });
+  return value.trim();
+}
+async function loadRunReadModel(projectRoot) {
+  return requireCapabilityForRoot2(projectRoot, RunReadModelCap2, "RUN_READ_MODEL capability unavailable for this project root: load @rig/run-plugin (standard bundle).");
+}
+async function listRunRecords(projectRoot, deps) {
+  return deps.listRunProjections ? deps.listRunProjections(projectRoot) : (await loadRunReadModel(projectRoot)).listRuns({ projectRoot });
+}
+async function getRunRecord(projectRoot, runId, deps) {
+  return deps.getRunProjection ? deps.getRunProjection(projectRoot, runId) : (await loadRunReadModel(projectRoot)).getRun({ projectRoot, selector: { id: runId, kind: "any" } });
+}
+async function getRunDetails(projectRoot, runId, deps, options = {}) {
+  return deps.getRunDetails ? deps.getRunDetails(projectRoot, runId, options) : (await loadRunReadModel(projectRoot)).getRunDetails({ projectRoot, selector: { id: runId, kind: "any" }, ...options.includeLogs === undefined ? {} : { includeLogs: options.includeLogs } });
+}
+async function runsForTaskId(projectRoot, taskId, deps) {
+  try {
+    if (!deps.listRunProjections) {
+      const runs = await (await loadRunReadModel(projectRoot)).listRuns({ projectRoot, taskId });
+      if (runs.length > 0)
+        return runs;
+    } else {
+      const runs = await listRunRecords(projectRoot, deps);
+      const filtered = runs.filter((run2) => run2.taskId === taskId || run2.runId === taskId);
+      if (filtered.length > 0)
+        return filtered;
+    }
+  } catch {}
+  const run = await getRunRecord(projectRoot, taskId, deps);
+  return run ? [run] : [];
+}
+async function representativeRunForTaskId(projectRoot, taskId, deps) {
+  if (deps.listRunProjections) {
+    const runs = await runsForTaskId(projectRoot, taskId, deps);
+    for (const run of runs)
+      return run;
+    return null;
+  }
+  return (await loadRunReadModel(projectRoot)).getRepresentativeRun({ projectRoot, taskId, purpose: "inspect" });
+}
+function failureLine(failure) {
+  return failure.detail ? `${failure.summary} \u2014 ${failure.detail}` : failure.summary;
+}
+async function executeLogs(context, args, deps) {
+  const taskResult = takeOption2(args, "--task");
+  requireNoExtraArgs2(taskResult.rest, "rig inspect logs --task <id>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect logs --task <id>");
+  const projection = await representativeRunForTaskId(context.projectRoot, taskId, deps);
+  if (!projection)
+    throw new CliError2(`No projected runs found for task ${taskId}.`, 1, { hint: "Run `rig run list` to confirm the run journal is discoverable." });
+  const details = await getRunDetails(context.projectRoot, projection.runId, deps, { includeLogs: true });
+  const lines = [...details?.logs ?? []];
+  if (context.outputMode === "text") {
+    if (lines.length === 0)
+      console.log(`No log entries found for task ${taskId}.`);
+    else
+      for (const line of lines)
+        console.log(line);
+  }
+  return { ok: true, group: "inspect", command: "logs", details: { taskId, runId: projection.runId, count: lines.length, lines } };
+}
+async function executeArtifact(context, args, deps) {
+  const taskResult = takeOption2(args, "--task");
+  const fileResult = takeOption2(taskResult.rest, "--file");
+  requireNoExtraArgs2(fileResult.rest, "rig inspect artifact --task <id> --file <name>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect artifact --task <id> --file <name>");
+  const filename = fileResult.value?.trim();
+  if (!filename)
+    throw new CliError2("rig inspect artifact --task <id> --file <name> requires an artifact file name.", 2);
+  const preview = await (deps.taskArtifactRead ?? (await taskCliData(context.projectRoot)).taskArtifactRead)(context.projectRoot, filename, { taskId, maxBytes: 64 * 1024 });
+  if (context.outputMode === "text") {
+    console.log(preview.contents);
+    if (preview.truncated)
+      console.log(`
+[truncated at ${preview.maxBytes} bytes; artifact is ${preview.sizeBytes} bytes]`);
+  }
+  return { ok: true, group: "inspect", command: "artifact", details: { taskId, file: filename, ...preview } };
+}
+async function executeRunLogs(context, args, deps) {
+  const runResult = takeOption2(args, "--run");
+  requireNoExtraArgs2(runResult.rest, "rig inspect run-logs --run <id>");
+  const runId = requireRunId(runResult.value, "rig inspect run-logs --run <id>");
+  const projection = await getRunRecord(context.projectRoot, runId, deps);
+  if (!projection)
+    throw new CliError2(`Run not found: ${runId}`, 2, { hint: "Run `rig inspect runs` to see runs." });
+  const details = await getRunDetails(context.projectRoot, projection.runId, deps, { includeLogs: true });
+  const lines = [...details?.logs ?? []];
+  if (context.outputMode === "text") {
+    if (lines.length === 0)
+      console.log(`No log entries found for run ${projection.runId}.`);
+    else
+      for (const line of lines)
+        console.log(line);
+  }
+  return { ok: true, group: "inspect", command: "run-logs", details: { runId: projection.runId, taskId: projection.taskId, count: lines.length, lines } };
+}
+async function executeRuns(context, args, deps) {
+  requireNoExtraArgs2(args, "rig inspect runs");
+  let formatted;
+  if (deps.listRunProjections) {
+    formatted = (await listRunRecords(context.projectRoot, deps)).map((run) => toRunLike(run));
+  } else {
+    const readModel = await loadRunReadModel(context.projectRoot);
+    const runs = await readModel.listRuns({ projectRoot: context.projectRoot });
+    formatted = runs.map((run) => toRunLike(run, readModel.classifyRun(run)));
+  }
+  if (context.outputMode === "text")
+    printFormattedOutput2(formatRunList(formatted));
+  return { ok: true, group: "inspect", command: "runs", details: { runs: formatted } };
+}
+async function executeArtifacts(context, args, deps) {
+  const taskResult = takeOption2(args, "--task");
+  requireNoExtraArgs2(taskResult.rest, "rig inspect artifacts --task <id>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect artifacts --task <id>");
+  if (context.outputMode === "text")
+    await (deps.taskArtifacts ?? (await taskCliData(context.projectRoot)).taskArtifacts)(context.projectRoot, taskId);
+  return { ok: true, group: "inspect", command: "artifacts", details: { taskId, printed: context.outputMode === "text" } };
+}
+async function executeDiff(context, args, deps) {
+  const taskResult = takeOption2(args, "--task");
+  requireNoExtraArgs2(taskResult.rest, "rig inspect diff --task <id>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect diff --task <id>");
+  const files = (deps.changedFilesForTask ?? (await taskCliData(context.projectRoot)).changedFilesForTask)(context.projectRoot, taskId, true);
+  if (context.outputMode === "text")
+    for (const file of files)
+      console.log(file);
+  return { ok: true, group: "inspect", command: "diff", details: { taskId, files } };
+}
+async function executeGraph(context, args, deps) {
+  const taskResult = takeOption2(args, "--task");
+  requireNoExtraArgs2(taskResult.rest, "rig inspect graph [--task <id>]");
+  if (context.outputMode === "text")
+    await (deps.taskDeps ?? (await taskCliData(context.projectRoot)).taskDeps)(context.projectRoot, taskResult.value);
+  return { ok: true, group: "inspect", command: "graph", details: { taskId: taskResult.value ?? null, printed: context.outputMode === "text" } };
+}
+async function executeFailures(context, args, deps) {
+  const taskResult = takeOption2(args, "--task");
+  requireNoExtraArgs2(taskResult.rest, "rig inspect failures --task <id>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect failures --task <id>");
+  const runs = await runsForTaskId(context.projectRoot, taskId, deps);
+  const failures = (await Promise.all(runs.map(async (run) => (await getRunDetails(context.projectRoot, run.runId, deps))?.failures ?? []))).flat().map(failureLine);
+  if (context.outputMode === "text") {
+    if (failures.length === 0)
+      console.log(`No failures recorded for task ${taskId}.`);
+    else
+      for (const failure of failures)
+        console.log(failure);
+  }
+  return { ok: true, group: "inspect", command: "failures", details: { taskId, count: failures.length, failures } };
+}
+function executeAudit(args) {
+  requireNoExtraArgs2(args, "rig inspect audit");
+  throw new CliError2("rig inspect audit cannot read the controlled-command audit trail yet: current code only writes audit JSONL and exposes no supported reader API.", 2, { hint: "Use the OMP session history for operator audit context until a controlled-bash audit reader is added." });
+}
+async function executeInspect(context, args, deps = {}) {
+  const [command = "failures", ...rest] = args;
+  if (command === "--help" || command === "-h" || command === "help") {
+    if (context.outputMode === "text")
+      printInspectHelp();
+    return { ok: true, group: "inspect", command: "help" };
+  }
+  switch (command) {
+    case "logs":
+      return executeLogs(context, rest, deps);
+    case "artifact":
+      return executeArtifact(context, rest, deps);
+    case "artifacts":
+      return executeArtifacts(context, rest, deps);
+    case "run-logs":
+      return executeRunLogs(context, rest, deps);
+    case "runs":
+      return executeRuns(context, rest, deps);
+    case "diff":
+      return executeDiff(context, rest, deps);
+    case "graph":
+      return executeGraph(context, rest, deps);
+    case "failures":
+      return executeFailures(context, rest, deps);
+    case "audit":
+      return executeAudit(rest);
+    default:
+      throw new CliError2(`Unknown inspect command: ${command}`, 1, { hint: "Run `rig inspect --help` to list inspect commands." });
+  }
+}
+var RunReadModelCap2, TaskCliDataCap, taskCliData = (projectRoot) => requireCapabilityForRoot2(projectRoot, TaskCliDataCap, "CLI task-data capability unavailable: load @rig/tasks-plugin (default bundle)."), INSPECT_USAGE = "rig inspect <logs|artifact|artifacts|run-logs|runs|failures|graph|diff>";
+var init_inspect_command = __esm(() => {
+  init_run_format();
+  RunReadModelCap2 = defineCapability5(RUN_READ_MODEL2);
+  TaskCliDataCap = defineCapability5(TASK_CLI_DATA_CAPABILITY);
+});
+
+// packages/run-plugin/src/read-model/runs-screen.ts
+var exports_runs_screen = {};
+__export(exports_runs_screen, {
+  createRunsBoardView: () => createRunsBoardView
+});
+import {
+  DRONE_WIDTH,
+  RIG_SPINNER_FRAMES,
+  accent as accent2,
+  bold,
+  ink,
+  ink2,
+  ink3,
+  ink4,
+  phaseGlyph,
+  red,
+  renderDroneFrame,
+  statusRoleColor
+} from "@rig/std-shared/board-theme";
+function createRunsBoardView(host, deps) {
+  const { truncateToWidth, matchesKey } = deps;
+  let runs = [];
+  let selected = 0;
+  let loading = true;
+  let error = null;
+  let tick = 0;
+  let filter = "";
+  let sortMode = "active";
+  function visibleRuns() {
+    const query = filter.trim().toLowerCase();
+    const filtered = query ? runs.filter((run) => run.runId.toLowerCase().includes(query) || run.status.toLowerCase().includes(query) || run.title.toLowerCase().includes(query)) : [...runs];
+    if (sortMode === "active") {
+      return filtered.map((run, index) => ({ run, index })).sort((a, b) => a.run.rank - b.run.rank || a.index - b.index).map((entry) => entry.run);
+    }
+    if (sortMode === "status") {
+      return filtered.map((run, index) => ({ run, index })).sort((a, b) => a.run.status.localeCompare(b.run.status) || a.index - b.index).map((entry) => entry.run);
+    }
+    return filtered;
+  }
+  function clampSelection() {
+    selected = Math.max(0, Math.min(selected, Math.max(0, visibleRuns().length - 1)));
+  }
+  function moveSelection(delta) {
+    const visible = visibleRuns();
+    if (visible.length === 0)
+      return;
+    selected = Math.max(0, Math.min(visible.length - 1, selected + delta));
+  }
+  function selectedRun2() {
+    return visibleRuns()[selected] ?? null;
+  }
+  function setFilter(next) {
+    filter = next;
+    clampSelection();
+  }
+  function cycleSort() {
+    sortMode = sortMode === "active" ? "recent" : sortMode === "recent" ? "status" : "active";
+    clampSelection();
+    return sortMode;
+  }
+  function droneBoardLines(width, message, messageWidth) {
+    const spinner = RIG_SPINNER_FRAMES[tick % RIG_SPINNER_FRAMES.length];
+    if (width < DRONE_WIDTH + 4) {
+      return ["", ` ${accent2(spinner)} ${ink3(message)}`, ""];
+    }
+    const pad2 = " ".repeat(Math.max(0, Math.floor((width - DRONE_WIDTH) / 2)));
+    const msgPad = " ".repeat(Math.max(0, Math.floor((width - messageWidth) / 2)));
+    return [
+      "",
+      ...renderDroneFrame(tick).map((line) => pad2 + line),
+      "",
+      `${msgPad}${accent2(spinner)} ${ink3(message)}`,
+      ""
+    ];
+  }
+  function renderLines(width) {
+    if (loading) {
+      return droneBoardLines(width, "contacting the fleet\u2026", 24);
+    }
+    if (error) {
+      return ["", ` ${red("runs unavailable:")} ${ink2(error)}`, ""];
+    }
+    const visible = visibleRuns();
+    if (runs.length === 0) {
+      return droneBoardLines(width, "no runs yet \u2014 n picks a task and launches one", 44);
+    }
+    if (visible.length === 0) {
+      return ["", ` ${ink2("no runs match")} ${accent2(`/${filter}`)} ${ink3("\u2014 esc clears the filter")}`, ""];
+    }
+    const start = Math.max(0, Math.min(selected - Math.floor(MAX_VISIBLE / 2), visible.length - MAX_VISIBLE));
+    const window = visible.slice(start, start + MAX_VISIBLE);
+    const lines = window.map((run, index) => {
+      const isSelected = start + index === selected;
+      const color = statusRoleColor(run.role);
+      const dot = color(phaseGlyph(run.phase));
+      const id = run.runId.slice(0, 8);
+      const status = color(run.status.padEnd(16));
+      const title = truncateToWidth(run.title, Math.max(8, width - 36));
+      const row = ` ${dot} ${isSelected ? bold(ink(id)) : ink3(id)}  ${status} ${isSelected ? ink(title) : ink2(title)}`;
+      return isSelected ? accent2("\u258C") + row : " " + row;
+    });
+    const meta = [];
+    if (visible.length > MAX_VISIBLE)
+      meta.push(`${selected + 1}/${visible.length}`);
+    if (filter)
+      meta.push(`filter: ${filter}`);
+    meta.push(`sort: ${sortMode}`);
+    lines.push(ink4(`   ${meta.join("  \xB7  ")}`));
+    return ["", ...lines, ""];
+  }
+  function handleInput(data) {
+    const enc = (value) => encodeURIComponent(value);
+    if (matchesKey(data, "up") || data === "k") {
+      moveSelection(-1);
+      host.requestRender();
+      return true;
+    }
+    if (matchesKey(data, "down") || data === "j") {
+      moveSelection(1);
+      host.requestRender();
+      return true;
+    }
+    if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+      const run = selectedRun2();
+      if (run)
+        host.act(`run-detail:${enc(run.runId)}`);
+      return true;
+    }
+    if (data === "a") {
+      const run = selectedRun2();
+      if (run)
+        host.attach(run.runId);
+      return true;
+    }
+    if (data === "s") {
+      const run = selectedRun2();
+      if (run)
+        host.openSteer(run.runId);
+      return true;
+    }
+    if (data === "p") {
+      const run = selectedRun2();
+      if (run) {
+        host.setNotice(`pause requested for ${run.runId.slice(0, 8)}\u2026`);
+        host.act(`run-pause:${enc(run.runId)}`);
+      }
+      return true;
+    }
+    if (data === "u") {
+      const run = selectedRun2();
+      if (run) {
+        host.setNotice(`resume requested for ${run.runId.slice(0, 8)}\u2026`);
+        host.act(`run-resume:${enc(run.runId)}`);
+      }
+      return true;
+    }
+    if (data === "x") {
+      const run = selectedRun2();
+      if (run) {
+        host.setNotice(`stop requested for ${run.runId.slice(0, 8)}\u2026`);
+        host.act(`run-stop:${enc(run.runId)}`);
+      }
+      return true;
+    }
+    if (data === "n") {
+      host.navigate("tasks");
+      return true;
+    }
+    if (data === "/") {
+      host.openSearch(filter, setFilter);
+      return true;
+    }
+    if (data === "o") {
+      const mode = cycleSort();
+      host.setNotice(`sorted: ${mode}`);
+      host.requestRender();
+      return true;
+    }
+    if (matchesKey(data, "escape")) {
+      if (filter) {
+        setFilter("");
+        host.requestRender();
+        return true;
+      }
+      return false;
+    }
+    return false;
+  }
+  return {
+    render(width) {
+      return renderLines(width).map((line) => truncateToWidth(line, Math.max(10, width - 1)));
+    },
+    handleInput,
+    setBoard(board) {
+      if (board.kind !== "runs")
+        return;
+      const previous = selectedRun2()?.runId;
+      runs = [...board.runs];
+      if (previous) {
+        const index = visibleRuns().findIndex((run) => run.runId === previous);
+        if (index >= 0)
+          selected = index;
+      }
+      clampSelection();
+      loading = false;
+      error = null;
+    },
+    setError(next) {
+      error = next;
+    },
+    setTick(next) {
+      tick = next;
+    },
+    invalidate() {}
+  };
+}
+var MAX_VISIBLE = 16;
+var init_runs_screen = () => {};
+
+// packages/run-plugin/src/read-model/plugin.ts
+import { defineCapability as defineCapability6 } from "@rig/core/capability";
+import { loadCapabilityForRoot as loadCapabilityForRoot3 } from "@rig/core/capability-loaders";
+import { definePlugin } from "@rig/core/config";
+import {
+  RIG_COCKPIT_PANEL_SLOT,
+  RUN_IDENTITY_ENV,
+  RUN_READ_MODEL as RUN_READ_MODEL3,
+  RUN_SESSION_JOURNAL,
+  TASK_IO_SERVICE_CAPABILITY,
+  TASK_PROJECTION_CAPABILITY_ID
+} from "@rig/contracts";
+var RUN_READ_MODEL_PLUGIN_NAME = "@rig/run-plugin";
+var RunReadModelCap3 = defineCapability6(RUN_READ_MODEL3);
+var RunSessionJournalCap = defineCapability6(RUN_SESSION_JOURNAL);
+var RunIdentityEnvCap = defineCapability6(RUN_IDENTITY_ENV);
+var TaskIoCap = defineCapability6(TASK_IO_SERVICE_CAPABILITY);
+var TaskProjectionCap = defineCapability6(TASK_PROJECTION_CAPABILITY_ID);
+async function resolveDiscoveryFilter(projectRoot, identityContext) {
+  const identityEnv = await loadCapabilityForRoot3(projectRoot, RunIdentityEnvCap);
+  return (identityContext && identityEnv ? identityEnv.resolveRigIdentityFilter(identityContext) : null) ?? {};
+}
+async function produceRunsBoard(context) {
+  const { projectRoot, identityContext, runs: providedRuns, runClassifications } = context ?? {};
+  if (!projectRoot)
+    return { kind: "runs", runs: [] };
+  const service = (await Promise.resolve().then(() => (init_read_model_service(), exports_read_model_service))).runReadModelService;
+  const runs = providedRuns ?? await service.listRuns({ projectRoot, discoveryFilter: await resolveDiscoveryFilter(projectRoot, identityContext) });
+  const rows = runs.map((run) => {
+    const classification = runClassifications?.get(run.runId) ?? service.classifyRun(run);
+    return {
+      runId: run.runId,
+      status: classification.status,
+      role: classification.role,
+      phase: classification.phase,
+      rank: classification.rank,
+      title: run.title
+    };
+  });
+  return { kind: "runs", runs: rows };
+}
+var statsCommand = {
+  id: `${RUN_READ_MODEL_PLUGIN_NAME}:stats`,
+  family: "stats",
+  description: "Inspect run statistics.",
+  projectRequired: true,
+  run: async (context, args) => (await Promise.resolve().then(() => (init_stats_command(), exports_stats_command))).executeStats(context, [...args]),
+  helpDoc: {
+    name: "stats",
+    summary: "Legacy automation-only metrics over old run records; not the OMP live UX.",
+    usage: ["rig stats [show] [--since <7d|30d|ISO date>]"],
+    commands: [
+      { command: "show [--since <window>]", description: "Legacy automation-only: totals, completion/failure rates, run time, steering, stalls, approvals.", primary: true }
+    ],
+    examples: [
+      "rig stats --json # legacy automation only"
+    ],
+    next: ["For normal UX, use the OMP Runs screen."]
+  }
+};
+var inspectCommand = {
+  id: `${RUN_READ_MODEL_PLUGIN_NAME}:inspect`,
+  family: "inspect",
+  description: "Inspect live/project Rig state.",
+  projectRequired: false,
+  run: async (context, args) => (await Promise.resolve().then(() => (init_inspect_command(), exports_inspect_command))).executeInspect(context, [...args]),
+  helpDoc: {
+    name: "inspect",
+    summary: "Legacy automation-only artifact/log inspection; normal UX is OMP session history.",
+    usage: ["rig inspect <logs|artifact|artifacts|run-logs|runs|failures|graph|diff> [options]"],
+    commands: [
+      { command: "logs --task <id>", description: "Legacy automation-only: latest old run log for a task.", primary: true },
+      { command: "run-logs --run <id>", description: "Legacy automation-only: log lines for a specific run.", primary: true },
+      { command: "runs", description: "Legacy automation-only: list projected runs." },
+      { command: "artifact --task <id> --file <name>", description: "Legacy automation-only: preview one completion artifact." },
+      { command: "artifacts --task <id>", description: "Legacy automation-only: list completion artifacts.", primary: true },
+      { command: "diff --task <id>", description: "Legacy automation-only: list task changed files." },
+      { command: "failures --task <id>", description: "Legacy automation-only: recorded failures for a task.", primary: true },
+      { command: "graph [--task <id>]", description: "Legacy automation-only: task dependency graph." }
+    ],
+    next: ["For normal UX, use the OMP Runs screen and OMP session history."]
+  }
+};
+var runReadModelPlugin = definePlugin({
+  name: RUN_READ_MODEL_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  effects: { readsFiles: true, contributesCliCommands: true, contributesPanels: true },
+  contributes: {
+    capabilities: [
+      RunReadModelCap3.provide(async () => (await Promise.resolve().then(() => (init_read_model_service(), exports_read_model_service))).runReadModelService, {
+        title: "Run read-model service",
+        description: "List, inspect, summarize, and classify canonical run session projections for operator surfaces."
+      }),
+      RunSessionJournalCap.provide(async () => (await Promise.resolve().then(() => (init_session_journal(), exports_session_journal))).runSessionJournalCodec, {
+        title: "Run session-journal codec",
+        description: "Fold run-session entries into projections, extract timelines, and parse control sentinels."
+      })
+    ],
+    cliCommands: [statsCommand, inspectCommand],
+    panels: [
+      {
+        id: "runs",
+        slot: RIG_COCKPIT_PANEL_SLOT,
+        title: "Runs",
+        description: "Dispatched Rig runs and live OMP collaborative sessions.",
+        produceBoard: produceRunsBoard,
+        createView: async (host) => {
+          const { truncateToWidth, matchesKey } = await import("@oh-my-pi/pi-tui");
+          return (await Promise.resolve().then(() => (init_runs_screen(), exports_runs_screen))).createRunsBoardView(host, { truncateToWidth, matchesKey });
+        },
+        screen: {
+          title: "Runs",
+          navOrder: 2,
+          navLabel: "RUNS",
+          navDescription: "attach to dispatched Rig runs and live OMP collaborative sessions",
+          shortcutKey: "r",
+          shortcutDescription: "Rig runs"
+        }
+      }
+    ]
+  }
+});
+function createRunReadModelPlugin() {
+  return runReadModelPlugin;
+}
+export {
+  runReadModelPlugin,
+  createRunReadModelPlugin,
+  RUN_READ_MODEL_PLUGIN_NAME
+};