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

package/dist/src/read-model/read-model-backend/projection.js

@@ -0,0 +1,669 @@
+// @bun
+// packages/run-plugin/src/read-model/read-model-backend/projection.ts
+import { existsSync, readFileSync } from "fs";
+import { isAbsolute, relative, resolve } from "path";
+import { RUN_DISCOVERY, RUN_REGISTRY_BACKBONE } from "@rig/contracts";
+
+// packages/run-plugin/src/read-model/session-journal.ts
+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";
+var decodeRunJournalEvent = (value) => Schema.decodeUnknownSync(RunJournalEvent)(value);
+var 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"]
+};
+var TERMINAL_RUN_STATUSES = ["completed", "failed", "stopped"];
+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 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 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 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] : [];
+  });
+}
+
+// packages/run-plugin/src/read-model/read-model-backend/projection.ts
+import { loadCapabilityForRoot } from "@rig/core/capability-loaders";
+import { defineCapability } from "@rig/core/capability";
+
+// packages/run-plugin/src/read-model/read-model-backend/run-status.ts
+var 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"
+]);
+var TERMINAL_RUN_STATUSES2 = ["completed", "failed", "stopped"];
+var RUNTIME_ACTIVE_STATUSES = new Set([
+  "created",
+  "preparing",
+  "running",
+  "validating",
+  "reviewing",
+  "closing-out"
+]);
+var ACTIVE_RUN_STATUSES = [
+  "created",
+  "queued",
+  "preparing",
+  "running",
+  "waiting-approval",
+  "waiting-user-input",
+  "paused",
+  "validating",
+  "reviewing",
+  "closing-out",
+  "needs-attention"
+];
+var KNOWN_RUN_STATUS = Object.fromEntries([...ACTIVE_RUN_STATUSES, ...TERMINAL_RUN_STATUSES2].map((status) => [status, true]));
+function isRuntimeActiveStatus(status) {
+  return RUNTIME_ACTIVE_STATUSES.has(normalizeRunStatusToken(status));
+}
+function normalizeRunStatusToken(status) {
+  return String(status ?? "").trim().toLowerCase().replace(/[\s_]+/g, "-");
+}
+
+// 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 RunDiscoveryCap = defineCapability(RUN_DISCOVERY);
+var RunRegistryBackboneCap = defineCapability(RUN_REGISTRY_BACKBONE);
+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
+  };
+}
+var EMPTY_PROJECTION = foldRunSessionEntries([], "");
+var DISCOVERY_DIAGNOSTIC_RUN_ID = "__registry_discovery_error__";
+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 loadCapabilityForRoot(projectRoot, RunDiscoveryCap);
+    if (!discovery)
+      return [discoveryDiagnosticRunRecord(projectRoot, "run discovery capability unavailable")];
+    const backbone = await loadCapabilityForRoot(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 listRuns = listRunProjections;
+var getRun = getRunProjection;
+var resolveJoinTarget = resolveRunJoinTarget;
+export {
+  selectRunProjection,
+  runRecordsFromCollab,
+  runRecordFromRegistryEntry,
+  resolveRunJoinTarget,
+  resolveJoinTarget,
+  readSessionRunEntries,
+  listRuns,
+  listRunProjections,
+  getRunProjection,
+  getRun,
+  discoveryDiagnosticRunRecord
+};

package/dist/src/read-model/read-model-backend/run-status.d.ts

@@ -0,0 +1,27 @@
+import { type RunRecord, type RunStatus } from "@rig/contracts";
+export type RunClassificationPhase = "needs-attention" | "starting" | "active" | "waiting" | "paused" | "completed" | "failed" | "stopped" | "unknown";
+export type RunStatusColorRole = "success" | "action-yellow" | "active-cyan" | "failure" | "muted" | "neutral";
+export interface RunClassification {
+    readonly status: string;
+    readonly runStatus: RunStatus;
+    readonly phase: RunClassificationPhase;
+    readonly isActive: boolean;
+    readonly isTerminal: boolean;
+    readonly isNeedsAttention: boolean;
+    /** V51: read-model-owned recovery-affordance verdict (offered when failed). */
+    readonly offersRecovery: boolean;
+}
+export declare function isRuntimeActiveStatus(status: unknown): boolean;
+export declare function normalizeRunStatusToken(status: unknown): string;
+export declare function isOperatorActiveRunStatus(status: unknown): boolean;
+export declare function asRunStatus(status: string): RunStatus | null;
+export declare function statusColorRole(status: unknown): RunStatusColorRole;
+export declare function isNeedsAttention(run: RunRecord): boolean;
+export declare function classifyRun(run: RunRecord): RunClassification;
+export declare function runStatusText(run: RunRecord): string;
+export declare function runStatusColorRole(run: RunRecord): RunStatusColorRole;
+export declare function statusRank(run: RunRecord): number;
+export declare function canSteer(run: RunRecord): boolean;
+export declare function canStop(run: RunRecord): boolean;
+export declare function canPause(run: RunRecord): boolean;
+export declare function canResume(run: RunRecord): boolean;