@h-rig/run-worker 0.0.6-alpha.157 → 0.0.6-alpha.158

package/dist/src/{runs → read-model-backend}/index.js

@@ -16,7 +16,488 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// packages/run-worker/src/runs/diagnostics.ts
+// packages/run-worker/src/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,
+  RIG_WORKFLOW_STATUS_CHANGED,
+  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 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] : [];
+  });
+}
+function asCustomEntries(entries) {
+  return entries.filter((entry) => entry.type === "custom");
+}
+
+class RunSessionJournal {
+  sm;
+  runId;
+  constructor(sm, runId) {
+    this.sm = sm;
+    this.runId = runId;
+  }
+  #append(init) {
+    this.sm.appendCustomEntry(CUSTOM_TYPE_FOR[init.type], { ...init, at: new Date().toISOString() });
+  }
+  appendStatus(to, opts = {}) {
+    const from = foldRunSessionEntries(asCustomEntries(this.sm.getEntries()), this.runId).status;
+    if (!opts.force)
+      assertRunStatusTransition(from, to);
+    if (opts.errorText !== undefined)
+      this.#append({ type: "record-patch", patch: { errorText: opts.errorText } });
+    this.#append({
+      type: "status-changed",
+      from,
+      to,
+      ...opts.reason !== undefined ? { reason: opts.reason } : {},
+      ...opts.actor !== undefined ? { actor: opts.actor } : {}
+    });
+  }
+  appendTimeline(payload) {
+    this.#append({ type: "timeline-entry", payload });
+  }
+  appendCloseoutPhase(input) {
+    this.#append({
+      type: "closeout-phase",
+      phase: input.phase,
+      outcome: input.outcome,
+      ...input.detail !== undefined ? { detail: input.detail } : {}
+    });
+  }
+  appendApprovalResolved(input) {
+    this.#append({
+      type: "approval-resolved",
+      requestId: input.requestId,
+      decision: input.decision,
+      actor: input.actor,
+      ...input.note !== undefined ? { note: input.note } : {}
+    });
+  }
+  appendInputResolved(input) {
+    this.#append({ type: "input-resolved", requestId: input.requestId, answers: input.answers, actor: input.actor });
+  }
+  appendStall(input) {
+    this.#append({ type: "stall-detected", detail: input.detail });
+  }
+}
+var decodeRunJournalEvent, RUN_STATUS_TRANSITIONS, TERMINAL_RUN_STATUSES;
+var init_session_journal = __esm(() => {
+  decodeRunJournalEvent = Schema.decodeUnknownSync(RunJournalEvent);
+  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"];
+});
+
+// packages/run-worker/src/read-model-backend/run-status.ts
+import { OPERATOR_INACTIVE_RUN_STATUSES } from "@rig/contracts";
+function isTerminalRunStatus2(status) {
+  return TERMINAL_RUN_STATUSES2.includes(status);
+}
+function isActiveRunStatus(status) {
+  return !isTerminalRunStatus2(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);
+  return {
+    status,
+    phase: phaseForStatus(status, runStatus, isNeedsAttentionValue),
+    isActive: runStatus ? isActiveRunStatus(runStatus) : !isTerminal && status !== "unknown",
+    isTerminal,
+    isNeedsAttention: isNeedsAttentionValue
+  };
+}
+function runStatusText(run) {
+  return classifyRun(run).status;
+}
+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;
+  }
+}
+function isSteerableStatus(status) {
+  switch (status) {
+    case "needs-attention":
+    case "waiting-approval":
+    case "waiting-user-input":
+    case "paused":
+      return false;
+    default: {
+      const runStatus = asRunStatus(status);
+      return runStatus ? isActiveRunStatus(runStatus) : false;
+    }
+  }
+}
+function canSteer(run) {
+  const classification = classifyRun(run);
+  if (classification.phase === "active" || classification.phase === "starting")
+    return true;
+  return classification.isNeedsAttention && isSteerableStatus(classification.status);
+}
+function canStop(run) {
+  const classification = classifyRun(run);
+  return classification.isActive && !classification.isTerminal;
+}
+function canPause(run) {
+  const phase = classifyRun(run).phase;
+  return phase === "active" || phase === "starting";
+}
+function canResume(run) {
+  return classifyRun(run).phase === "paused";
+}
+var TERMINAL_RUN_STATUSES2, ACTIVE_RUN_STATUSES, KNOWN_RUN_STATUS;
+var init_run_status = __esm(() => {
+  TERMINAL_RUN_STATUSES2 = ["completed", "failed", "stopped"];
+  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-worker/src/read-model-backend/diagnostics.ts
 function normalizeString(value) {
   if (typeof value !== "string")
     return null;
@@ -63,13 +544,12 @@ function summarizeRunError(projection) {
   const nonGeneric = candidates.filter((candidate) => !isGenericRunFailure(candidate));
   return categorizeUsefulRunError(nonGeneric) ?? nonGeneric.at(-1) ?? normalizeString(projection.record.errorText);
 }
-var init_diagnostics = () => {};
 
-// packages/run-worker/src/runs/projection.ts
+// packages/run-worker/src/read-model-backend/projection.ts
 var exports_projection = {};
 __export(exports_projection, {
   selectRunProjection: () => selectRunProjection,
-  runRecordsFromRegistrySnapshot: () => runRecordsFromRegistrySnapshot,
+  runRecordsFromCollab: () => runRecordsFromCollab,
   runRecordFromRegistryEntry: () => runRecordFromRegistryEntry,
   resolveRunJoinTarget: () => resolveRunJoinTarget,
   resolveJoinTarget: () => resolveJoinTarget,
@@ -82,13 +562,28 @@ __export(exports_projection, {
 });
 import { existsSync, readFileSync } from "fs";
 import { isAbsolute, relative, resolve } from "path";
-import { Duration, Effect, Option, Stream } from "effect";
-import {
-  foldRunSessionEntries,
-  isTerminalRunStatus,
-  timelineEntriesFromCustomEntries
-} from "@rig/contracts";
-import { registrySnapshotStream } from "@rig/runtime/control-plane/discovery";
+import { RUN_DISCOVERY } from "@rig/contracts";
+import { loadCapabilityForRoot } from "@rig/core/capability-loaders";
+import { defineCapability } 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 [];
@@ -133,22 +628,7 @@ function registryStatusAsRunStatus(status) {
     return "waiting-user-input";
   if (status === "starting")
     return "preparing";
-  return typeof status === "string" && [
-    "created",
-    "queued",
-    "preparing",
-    "running",
-    "waiting-approval",
-    "waiting-user-input",
-    "paused",
-    "validating",
-    "reviewing",
-    "closing-out",
-    "needs-attention",
-    "completed",
-    "failed",
-    "stopped"
-  ].includes(status) ? status : null;
+  return typeof status === "string" ? asRunStatus(status) : null;
 }
 function payloadString(payload, keys) {
   if (!payload || typeof payload !== "object")
@@ -171,12 +651,14 @@ function payloadOptions(payload) {
 }
 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: payloadString(request.payload, ["body", "description", "detail", "details"]),
-    ...payloadOptions(request.payload) ? { options: payloadOptions(request.payload) } : {},
+    ...body !== undefined ? { body } : {},
+    ...options ? { options } : {},
     requestedAt: request.requestedAt ?? null,
     source: "run"
   };
@@ -285,8 +767,8 @@ function runRecordFromRegistryEntry(projectRoot, entry) {
     projection: folded
   };
 }
-function runRecordsFromRegistrySnapshot(projectRoot, snapshot) {
-  return sortByRecency(snapshot.entries.map((entry) => runRecordFromRegistryEntry(projectRoot, entry)).filter((record) => record !== null));
+function runRecordsFromCollab(projectRoot, collabs) {
+  return sortByRecency(collabs.map((collab) => runRecordFromRegistryEntry(projectRoot, registryEntryFromCollab(collab))).filter((record) => record !== null));
 }
 function sortByRecency(records) {
   return [...records].sort((a, b) => {
@@ -334,8 +816,11 @@ function discoveryDiagnosticRunRecord(projectRoot, error) {
 }
 async function listRunProjections(projectRoot, filter = {}) {
   try {
-    const snapshot = await Effect.runPromise(registrySnapshotStream(projectRoot, filter).pipe(Stream.runHead, Effect.timeout(Duration.seconds(15)), Effect.map(Option.getOrNull)));
-    return snapshot ? runRecordsFromRegistrySnapshot(projectRoot, snapshot) : [discoveryDiagnosticRunRecord(projectRoot, "registry discovery stream ended without a snapshot")];
+    const discovery = await loadCapabilityForRoot(projectRoot, RunDiscoveryCap);
+    if (!discovery)
+      return [discoveryDiagnosticRunRecord(projectRoot, "run discovery capability unavailable")];
+    const collabs = await discovery.listActiveRunCollab(projectRoot, filter);
+    return runRecordsFromCollab(projectRoot, collabs);
   } catch (error) {
     return [discoveryDiagnosticRunRecord(projectRoot, error)];
   }
@@ -366,18 +851,29 @@ async function resolveRunJoinTarget(projectRoot, runId, filter = {}) {
     return null;
   return { runId: run.runId, taskId: run.taskId, joinLink: run.joinLink, cwd: run.collabCwd ?? run.sessionPath, stale: run.stale };
 }
-var EMPTY_PROJECTION, DISCOVERY_DIAGNOSTIC_RUN_ID = "__registry_discovery_error__", listRuns, getRun, resolveJoinTarget;
+var RunDiscoveryCap, EMPTY_PROJECTION, DISCOVERY_DIAGNOSTIC_RUN_ID = "__registry_discovery_error__", listRuns, getRun, resolveJoinTarget;
 var init_projection = __esm(() => {
-  init_diagnostics();
+  init_session_journal();
+  init_run_status();
+  RunDiscoveryCap = defineCapability(RUN_DISCOVERY);
   EMPTY_PROJECTION = foldRunSessionEntries([], "");
   listRuns = listRunProjections;
   getRun = getRunProjection;
   resolveJoinTarget = resolveRunJoinTarget;
 });
 
-// packages/run-worker/src/runs/control.ts
+// packages/run-worker/src/read-model-backend/control.ts
 init_projection();
-import { buildPauseSentinel, buildResumeSentinel, buildStopSentinel } from "@rig/contracts";
+import { RIG_CONTROL_SENTINEL_END as RIG_CONTROL_SENTINEL_END2, RIG_PAUSE_SENTINEL as RIG_PAUSE_SENTINEL2, RIG_RESUME_SENTINEL as RIG_RESUME_SENTINEL2, RIG_STOP_SENTINEL as RIG_STOP_SENTINEL2, RIG_STOP_SENTINEL_END as RIG_STOP_SENTINEL_END2 } from "@rig/contracts";
+function buildPauseSentinel(runId) {
+  return `${RIG_PAUSE_SENTINEL2} runId=${runId} requestedBy=operator ${RIG_CONTROL_SENTINEL_END2}`;
+}
+function buildResumeSentinel(runId) {
+  return `${RIG_RESUME_SENTINEL2} runId=${runId} requestedBy=operator ${RIG_CONTROL_SENTINEL_END2}`;
+}
+function buildStopSentinel(runId, reason) {
+  return `${RIG_STOP_SENTINEL2} runId=${runId} reason=${reason} ${RIG_STOP_SENTINEL_END2}`;
+}
 async function loadCollabControlDeps() {
   const [{ importRoomKey, seal }, { COLLAB_PROTO, packEnvelope, parseCollabLink }] = await Promise.all([
     import("@oh-my-pi/pi-coding-agent/collab/crypto"),
@@ -406,9 +902,6 @@ Stop this run and do not continue after the interruption settles.` },
       ];
   }
 }
-function collabControlFrame(runId, control) {
-  return collabControlFrames(runId, control)[0];
-}
 async function sendSealedCollabFrames(joinLink, frames, deps = {}) {
   const { importRoomKey, seal, COLLAB_PROTO, packEnvelope, parseCollabLink } = await loadCollabControlDeps();
   const parsed = parseCollabLink(joinLink);
@@ -459,9 +952,8 @@ async function deliverRunControl(projectRoot, target, control, deps = {}) {
     throw new Error(`Could not ${control.kind} run ${record.runId}. ${detail}`);
   }
 }
-// packages/run-worker/src/runs/guard.ts
-import { TERMINAL_RUN_STATUSES } from "@rig/contracts";
-var TERMINAL = new Set(TERMINAL_RUN_STATUSES);
+// packages/run-worker/src/read-model-backend/guard.ts
+var TERMINAL = new Set(["completed", "failed", "stopped"]);
 function runBlocksNewRunForTask(run) {
   return run.live && !run.stale && !TERMINAL.has(run.status) && run.status !== "needs-attention" && run.status !== "needs_attention";
 }
@@ -479,9 +971,12 @@ async function assertNoActiveRunForTask(listRuns2, projectRoot, taskId) {
     throw new Error(`Task ${taskId} already has an active run: ${existing}. Attach instead: rig run attach ${existing} \u2014 or re-dispatch anyway with --force.`);
   }
 }
-// packages/run-worker/src/runs/inbox.ts
-import { buildInboxResolutionSentinel } from "@rig/contracts";
+// packages/run-worker/src/read-model-backend/inbox.ts
+import { RIG_CONTROL_SENTINEL_END as RIG_CONTROL_SENTINEL_END3, RIG_INBOX_RESOLUTION_SENTINEL as RIG_INBOX_RESOLUTION_SENTINEL2 } from "@rig/contracts";
 init_projection();
+function buildInboxResolutionSentinel(runId, payload) {
+  return `${RIG_INBOX_RESOLUTION_SENTINEL2} runId=${runId} data=${encodeURIComponent(JSON.stringify(payload))} requestedBy=operator ${RIG_CONTROL_SENTINEL_END3}`;
+}
 function promptFromPayload(payload, fallback) {
   if (payload && typeof payload === "object") {
     const record = payload;
@@ -578,9 +1073,8 @@ function decisionText(runId, requestId, decision) {
 async function resolveInboxRequest(projectRoot, runId, requestId, decision, deps = {}) {
   await (deps.deliverRunControl ?? deliverRunControl)(projectRoot, runId, { kind: "steer", message: decisionText(runId, requestId, decision) });
 }
-// packages/run-worker/src/runs/inspect.ts
+// packages/run-worker/src/read-model-backend/inspect.ts
 init_projection();
-init_diagnostics();
 import { RIG_RUN_LOG_ENTRY } from "@rig/contracts";
 function asRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -665,7 +1159,6 @@ function summarizeRunFailures(run) {
   }
   return failures;
 }
-var summarizeProjectionFailures = summarizeRunFailures;
 async function runsForTask(projectRoot, taskId, deps = {}) {
   const list = deps.listRuns ?? listRuns;
   try {
@@ -689,175 +1182,13 @@ function runInspectSummaryRows(runs, options = {}) {
     { id: "inspect:audit", label: "AUDIT", currentValue: "unavailable", heading: true, description: "CLI inspect audit has no cockpit equivalent; use rig inspect audit" }
   ];
 }
-// packages/run-worker/src/runs/run-status.ts
-import {
-  ACTIVE_RUN_STATUSES,
-  TERMINAL_RUN_STATUSES as TERMINAL_RUN_STATUSES2,
-  isActiveRunStatus,
-  isTerminalRunStatus as isTerminalRunStatus2,
-  normalizeRunStatusToken
-} from "@rig/contracts";
-var KNOWN_RUN_STATUS = Object.fromEntries([...ACTIVE_RUN_STATUSES, ...TERMINAL_RUN_STATUSES2].map((status) => [status, true]));
-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 "needs_attention":
-    case "waiting-approval":
-    case "waiting-user-input":
-    case "waiting-input":
-    case "waiting_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 "in-progress":
-    case "active":
-    case "booting":
-    case "validating":
-    case "reviewing":
-    case "closing-out":
-    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 runStatusColorRole(run) {
-  const classification = classifyRun(run);
-  return classification.isNeedsAttention && !classification.isTerminal ? "action-yellow" : statusColorRole(classification.status);
-}
-function isSteerableStatus(status) {
-  switch (status) {
-    case "needs-attention":
-    case "waiting-approval":
-    case "waiting-user-input":
-    case "paused":
-      return false;
-    default: {
-      const runStatus = asRunStatus(status);
-      return runStatus ? isActiveRunStatus(runStatus) : false;
-    }
-  }
-}
-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,
-    phase,
-    isActive: runStatus ? isActiveRunStatus(runStatus) : !isTerminal && status !== "unknown",
-    isTerminal,
-    isNeedsAttention: isNeedsAttentionValue
-  };
-}
-function runStatusText(run) {
-  return classifyRun(run).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;
-  }
-}
-function canSteer(run) {
-  const classification = classifyRun(run);
-  if (classification.phase === "active" || classification.phase === "starting")
-    return true;
-  return classification.isNeedsAttention && isSteerableStatus(classification.status);
-}
-function canStop(run) {
-  const classification = classifyRun(run);
-  return classification.isActive && !classification.isTerminal;
-}
-function canPause(run) {
-  const phase = classifyRun(run).phase;
-  return phase === "active" || phase === "starting";
-}
-function canResume(run) {
-  return classifyRun(run).phase === "paused";
-}
-// packages/run-worker/src/runs/stats.ts
+
+// packages/run-worker/src/read-model-backend/index.ts
+init_run_status();
+
+// packages/run-worker/src/read-model-backend/stats.ts
+init_run_status();
+init_run_status();
 function parseTimestamp(value) {
   if (!value)
     return null;
@@ -937,15 +1268,12 @@ async function computeStats(projectRootOrRuns, options = {}) {
     approvalsPending
   };
 }
-var computeRigStats = computeStats;
 
-// packages/run-worker/src/runs/index.ts
+// packages/run-worker/src/read-model-backend/index.ts
 init_projection();
-init_diagnostics();
 export {
   summarizeRunFailures,
   summarizeRunError,
-  summarizeProjectionFailures,
   stringifyLogPayload,
   statusRank,
   statusColorRole,
@@ -963,6 +1291,7 @@ export {
   readInboxCounts,
   rate,
   parseTimestamp,
+  normalizeRunStatusToken,
   median,
   logLinesFromProjection,
   logLineFromValue,
@@ -970,21 +1299,21 @@ export {
   listRuns,
   listInboxRecords,
   listInbox,
+  isOperatorActiveRunStatus,
   isNeedsAttention,
   getRun,
   extractRunLogs,
   deliverRunControl,
   deliverRemoteRunControl,
   computeStats,
-  computeRigStats,
   completedDuration,
   collabControlFrames,
-  collabControlFrame,
   classifyRun,
   canStop,
   canSteer,
   canResume,
   canPause,
   assertNoActiveRunForTask,
+  asRunStatus,
   activeRunByTaskId
 };