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

package/dist/src/plugin.js

@@ -14,17 +14,408 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
 
-// packages/run-worker/src/journal.ts
-import { createJournalSessionProvider } from "@rig/kernel/journal-session-provider";
-import { RunSessionJournal } from "@rig/runtime/control-plane/run-session-writer";
+// 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 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 };
+}
+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 });
+  }
+}
+function isRunJournalEventInit(event) {
+  if (event === null || typeof event !== "object")
+    return false;
+  const type = event.type;
+  return typeof type === "string" && Object.hasOwn(CUSTOM_TYPE_FOR, type);
+}
+function createJournalSessionProvider(options) {
+  const now = options.now ?? (() => new Date);
+  const appendRunEvent = async (event, runId = options.runId) => {
+    options.store.appendCustomEntry(CUSTOM_TYPE_FOR[event.type], { ...event, runId, at: now().toISOString() });
+  };
+  const readEntries = () => asCustomEntries(options.store.getEntries());
+  const entriesForRun = (runId) => readEntries().filter((entry) => {
+    const data = entry.data;
+    if (data === null || typeof data !== "object")
+      return runId === options.runId;
+    const candidate = data.runId;
+    return candidate === undefined ? runId === options.runId : candidate === runId;
+  });
+  return {
+    runId: options.runId,
+    async append(event) {
+      if (isRunJournalEventInit(event))
+        await appendRunEvent(event);
+    },
+    appendRunEvent,
+    async recordPipeline(runId, pipeline) {
+      await appendRunEvent({ type: "pipeline-resolved", pipeline }, runId);
+    },
+    async recordStageOutcome(runId, outcome) {
+      await appendRunEvent({ type: "stage-outcome", outcome }, runId);
+    },
+    async read(runId) {
+      return entriesForRun(runId);
+    },
+    readEntries,
+    readProjection: () => foldRunSessionEntries(entriesForRun(options.runId), options.runId)
+  };
+}
 async function createRunJournal(sessionManager, runId) {
   try {
-    const journal = new RunSessionJournal(sessionManager, runId);
+    const writableSessionManager = sessionManager;
+    const journal = new RunSessionJournal(writableSessionManager, runId);
     const kernel = createJournalSessionProvider({
       runId,
       store: {
-        appendCustomEntry: (customType, data) => sessionManager.appendCustomEntry(customType, data),
+        appendCustomEntry: (customType, data) => writableSessionManager.appendCustomEntry(customType, data),
         getEntries: () => sessionManager.getEntries?.() ?? sessionManager.getBranch?.() ?? []
       }
     });
@@ -42,29 +433,1386 @@ async function createRunJournal(sessionManager, runId) {
     return null;
   }
 }
-var init_journal = () => {};
+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 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 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 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;
+  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-worker/src/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 } 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 [];
+  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 registryStatusAsRunStatus(status) {
+  if (status === "waiting-input")
+    return "waiting-user-input";
+  if (status === "starting")
+    return "preparing";
+  return typeof status === "string" ? asRunStatus(status) : 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) {
+  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: registryStatusAsRunStatus(projection.status) ?? registryStatusAsRunStatus(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 runRecordFromRegistryEntry(projectRoot, entry) {
+  const projection = entry.projection && typeof entry.projection === "object" ? entry.projection : {};
+  const runId = stringOrNull(projection.runId) ?? entry.roomId;
+  const folded = emptyFoldedProjection(runId, projection);
+  const pushedStatus = registryStatusAsRunStatus(projection.status) ?? folded.status ?? registryStatusAsRunStatus(entry.status);
+  const status = entry.stale ? pushedStatus && isTerminalRunStatus(pushedStatus) ? pushedStatus : "stale" : pushedStatus ?? "running";
+  const sessionPath = stringOrNull(projection.sessionPath) ?? stringOrNull(entry.sessionPath) ?? null;
+  const collabCwd = stringOrNull(projection.collabCwd) ?? stringOrNull(projection.cwd) ?? stringOrNull(entry.cwd) ?? stringOrNull(projection.worktreePath);
+  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: numberOrNull(projection.pendingApprovals) ?? folded.pendingApprovals.length,
+    pendingInputs: numberOrNull(projection.pendingInputs) ?? folded.pendingUserInputs.length,
+    steeringCount: projection.steeringCount ?? 0,
+    stallCount: projection.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) {
+  return sortByRecency(collabs.map((collab) => runRecordFromRegistryEntry(projectRoot, registryEntryFromCollab(collab))).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 collabs = await discovery.listActiveRunCollab(projectRoot, filter);
+    return runRecordsFromCollab(projectRoot, collabs);
+  } 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, EMPTY_PROJECTION, DISCOVERY_DIAGNOSTIC_RUN_ID = "__registry_discovery_error__", listRuns, getRun, resolveJoinTarget;
+var init_projection = __esm(() => {
+  init_session_journal();
+  init_run_status();
+  RunDiscoveryCap = defineCapability(RUN_DISCOVERY);
+  EMPTY_PROJECTION = foldRunSessionEntries([], "");
+  listRuns = listRunProjections;
+  getRun = getRunProjection;
+  resolveJoinTarget = resolveRunJoinTarget;
+});
+
+// packages/run-worker/src/read-model-backend/control.ts
+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"),
+    import("@oh-my-pi/pi-coding-agent/collab/protocol")
+  ]);
+  return { importRoomKey, seal, COLLAB_PROTO, packEnvelope, parseCollabLink };
+}
+function collabControlFrames(runId, control) {
+  switch (control.kind) {
+    case "steer":
+      return [{ t: "prompt", text: control.message }];
+    case "resume":
+      return [{ t: "prompt", text: `${buildResumeSentinel(runId)}
+Continue the run from where it paused.` }];
+    case "pause":
+      return [
+        { t: "prompt", text: `${buildPauseSentinel(runId)}
+Pause this run after the current interruption settles.` },
+        { t: "abort" }
+      ];
+    case "stop":
+      return [
+        { t: "prompt", text: `${buildStopSentinel(runId, control.reason)}
+Stop this run and do not continue after the interruption settles.` },
+        { t: "abort" }
+      ];
+  }
+}
+async function sendSealedCollabFrames(joinLink, frames, deps = {}) {
+  const { importRoomKey, seal, COLLAB_PROTO, packEnvelope, parseCollabLink } = await loadCollabControlDeps();
+  const parsed = parseCollabLink(joinLink);
+  if ("error" in parsed)
+    throw new Error(parsed.error);
+  if (!parsed.writeToken)
+    throw new Error("Run collab link is read-only; cannot send control.");
+  const key = await importRoomKey(parsed.key);
+  const WebSocketCtor = deps.WebSocket ?? WebSocket;
+  const ws = new WebSocketCtor(`${parsed.wsUrl}?role=guest`);
+  await new Promise((resolveOpen, rejectOpen) => {
+    ws.addEventListener("open", () => resolveOpen(), { once: true });
+    ws.addEventListener("error", () => rejectOpen(new Error("collab websocket error")), { once: true });
+  });
+  const hello = {
+    t: "hello",
+    proto: COLLAB_PROTO,
+    name: "rig-operator",
+    writeToken: Buffer.from(parsed.writeToken).toString("base64url")
+  };
+  ws.send(packEnvelope(0, await seal(key, hello)));
+  for (const frame of frames)
+    ws.send(packEnvelope(0, await seal(key, frame)));
+  try {
+    ws.close();
+  } catch {}
+}
+async function deliverRemoteRunControl(projectRoot, target, control, deps = {}) {
+  const record = typeof target === "string" ? await getRun(projectRoot, target) : target;
+  const runId = typeof target === "string" ? target : target.runId;
+  if (!record)
+    throw new Error(`Run not found: ${runId}`);
+  if (!record.joinLink)
+    throw new Error(`Run ${record.runId} has no writable collab join link.`);
+  await sendSealedCollabFrames(record.joinLink, collabControlFrames(record.runId, control), deps);
+}
+async function deliverRunControl(projectRoot, target, control, deps = {}) {
+  const record = typeof target === "string" ? await (deps.getRun ?? getRun)(projectRoot, target) : target;
+  const runId = typeof target === "string" ? target : target.runId;
+  if (!record)
+    throw new Error(`Run not found: ${runId}`);
+  if (!record.joinLink)
+    throw new Error(`Run ${record.runId} has no writable collab join link; attach interactively to ${control.kind}.`);
+  try {
+    await (deps.deliverRemote ?? deliverRemoteRunControl)(projectRoot, record, control);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : `Attach to ${control.kind} interactively: rig run attach ${record.runId}`;
+    throw new Error(`Could not ${control.kind} run ${record.runId}. ${detail}`);
+  }
+}
+var init_control = __esm(() => {
+  init_projection();
+});
+
+// packages/run-worker/src/read-model-backend/guard.ts
+var TERMINAL;
+var init_guard = __esm(() => {
+  TERMINAL = new Set(["completed", "failed", "stopped"]);
+});
+
+// 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";
+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;
+    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"
+  }));
+}
+async function listInboxRecords(context, kind, filters = {}, deps = {}) {
+  const projectRoot = typeof context === "string" ? context : context.projectRoot;
+  const runs = await (deps.listRuns ?? listRuns)(projectRoot);
+  const out = [];
+  for (const run of runs) {
+    if (filters.run && run.runId !== filters.run)
+      continue;
+    if (filters.task && run.taskId !== filters.task)
+      continue;
+    out.push(...recordsFromRun(run, kind));
+  }
+  return out;
+}
+function normalizedApprovalDecision(decision) {
+  return decision === "approved" || decision === "approve" ? "approve" : "reject";
+}
+function inputAnswers(answer) {
+  return typeof answer === "string" ? { answer } : answer;
+}
+function decisionText(runId, requestId, decision) {
+  if (decision.kind === "approval") {
+    const normalized = normalizedApprovalDecision(decision.decision);
+    const label = normalized === "approve" ? "approved" : "rejected";
+    return [
+      buildInboxResolutionSentinel(runId, { kind: "approval", requestId, decision: normalized, note: decision.note ?? null }),
+      `Rig inbox approval ${requestId} was ${label}.`,
+      decision.note ? `Operator note: ${decision.note}` : null,
+      "Continue using this approval decision."
+    ].filter((line) => Boolean(line)).join(`
+`);
+  }
+  const answers = inputAnswers(decision.answer);
+  return [
+    buildInboxResolutionSentinel(runId, { kind: "input", requestId, answers }),
+    `Rig inbox input ${requestId} was answered with:`,
+    JSON.stringify(answers),
+    "Continue using this input answer."
+  ].join(`
+`);
+}
+async function resolveInboxRequest(projectRoot, runId, requestId, decision, deps = {}) {
+  await (deps.deliverRunControl ?? deliverRunControl)(projectRoot, runId, { kind: "steer", message: decisionText(runId, requestId, decision) });
+}
+var init_inbox = __esm(() => {
+  init_control();
+  init_projection();
+});
+
+// packages/run-worker/src/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 firstString(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 = firstString(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 = firstString(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-worker/src/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;
+  for (const run of runs) {
+    const status = run.status || "unknown";
+    statusCounts[status] = (statusCounts[status] ?? 0) + 1;
+    if (status === "completed")
+      completedRuns += 1;
+    if (status === "failed")
+      failedRuns += 1;
+    if (isNeedsAttention(run))
+      needsAttentionRuns += 1;
+    const duration = completedDuration(run);
+    if (duration !== null)
+      completionDurations.push(duration);
+    steeringTotal += run.steeringCount;
+    stallTotal += run.stallCount;
+    approvalsPending += run.pendingApprovals;
+  }
+  const totalRuns = runs.length;
+  return {
+    since: options.since ? options.since.toISOString() : null,
+    totalRuns,
+    statusCounts,
+    completedRuns,
+    failedRuns,
+    needsAttentionRuns,
+    completionRate: rate(completedRuns, totalRuns),
+    failureRate: rate(failedRuns, totalRuns),
+    needsAttentionRate: rate(needsAttentionRuns, totalRuns),
+    medianCompletionMs: median(completionDurations),
+    steeringTotal,
+    steeringPerRun: totalRuns === 0 ? null : steeringTotal / totalRuns,
+    stallTotal,
+    approvalsRequested: approvalsPending,
+    approvalsApproved: 0,
+    approvalsRejected: 0,
+    approvalsPending
+  };
+}
+var init_stats = __esm(() => {
+  init_run_status();
+  init_run_status();
+});
+
+// packages/run-worker/src/read-model-backend/index.ts
+var init_read_model_backend = __esm(() => {
+  init_projection();
+  init_control();
+  init_guard();
+  init_inbox();
+  init_inspect();
+  init_run_status();
+  init_stats();
+});
+
+// packages/run-worker/src/read-model-service.ts
+var exports_read_model_service = {};
+__export(exports_read_model_service, {
+  runReadModelService: () => runReadModelService
+});
+import { RUN_REGISTRY_BACKBONE } from "@rig/contracts";
+import { loadCapabilityForRoot as loadCapabilityForRoot2 } from "@rig/core/capability-loaders";
+import { defineCapability as defineCapability2 } from "@rig/core/capability";
+import { resolveOwnerNamespaceKey, resolveRegistryBaseUrl } from "@rig/core/remote-config";
+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"
+  };
+}
+function inboxDecision(resolution) {
+  if (resolution.kind === "approval") {
+    return { kind: "approval", decision: resolution.decision, ...resolution.note === undefined ? {} : { note: resolution.note } };
+  }
+  return { kind: "input", answer: resolution.answers };
+}
+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 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)
+  };
+}
+async function controlTarget(input) {
+  const run = await selectedRun({ projectRoot: input.projectRoot, id: input.runId, discoveryFilter: input.discoveryFilter });
+  if (!run)
+    return null;
+  const canDeliver = Boolean(run.joinLink && !run.stale);
+  return {
+    runId: run.runId,
+    taskId: run.taskId,
+    sessionId: run.runId,
+    sessionPath: run.sessionPath,
+    joinLink: run.joinLink,
+    webLink: run.webLink,
+    relayUrl: run.relayUrl,
+    collabCwd: run.collabCwd,
+    live: run.live,
+    stale: run.stale,
+    canDeliver,
+    reason: canDeliver ? null : run.stale ? "run is stale" : "run has no join link"
+  };
+}
+async function removeRegistryEntry(projectRoot, runId) {
+  const namespaceKey = resolveOwnerNamespaceKey(projectRoot);
+  if (!namespaceKey)
+    return false;
+  try {
+    const registryBackbone = await loadCapabilityForRoot2(projectRoot, RunRegistryBackboneCap);
+    if (!registryBackbone)
+      return false;
+    await registryBackbone.createRegistryClient({ baseUrl: resolveRegistryBaseUrl(projectRoot), namespaceKey }).removeRoom(runId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var RunRegistryBackboneCap, runReadModelService;
+var init_read_model_service = __esm(() => {
+  init_read_model_backend();
+  RunRegistryBackboneCap = defineCapability2(RUN_REGISTRY_BACKBONE);
+  runReadModelService = {
+    async listRuns(input) {
+      return listedRuns(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;
+    },
+    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 resolveInboxRequest(input) {
+      const target = await controlTarget({ projectRoot: input.projectRoot, runId: input.runId, discoveryFilter: input.discoveryFilter });
+      if (!target) {
+        return {
+          runId: input.runId,
+          requestId: input.resolution.requestId,
+          kind: input.resolution.kind,
+          status: "not-found",
+          delivered: false,
+          detail: "run not found"
+        };
+      }
+      if (!target.canDeliver) {
+        return {
+          runId: target.runId,
+          requestId: input.resolution.requestId,
+          kind: input.resolution.kind,
+          status: "not-live",
+          delivered: false,
+          detail: target.reason ?? "run is not deliverable"
+        };
+      }
+      await resolveInboxRequest(input.projectRoot, target.runId, input.resolution.requestId, inboxDecision(input.resolution));
+      return {
+        runId: target.runId,
+        requestId: input.resolution.requestId,
+        kind: input.resolution.kind,
+        status: "resolved",
+        delivered: true
+      };
+    },
+    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 });
+    },
+    async deliverControl(input) {
+      const run = await selectedRun({ projectRoot: input.projectRoot, id: input.runId, discoveryFilter: input.discoveryFilter });
+      if (!run) {
+        return {
+          runId: input.runId,
+          kind: input.control.kind,
+          status: "not-found",
+          delivered: false,
+          detail: "run not found"
+        };
+      }
+      if (!run.joinLink) {
+        return {
+          runId: run.runId,
+          kind: input.control.kind,
+          status: "not-live",
+          delivered: false,
+          detail: `Run ${run.runId} has no writable collab join link.`
+        };
+      }
+      try {
+        await deliverRunControl(input.projectRoot, run, input.control);
+        return {
+          runId: run.runId,
+          kind: input.control.kind,
+          status: "delivered",
+          delivered: true
+        };
+      } catch (error) {
+        return {
+          runId: run.runId,
+          kind: input.control.kind,
+          status: "unsupported",
+          delivered: false,
+          detail: error instanceof Error ? error.message : String(error)
+        };
+      }
+    },
+    classifyRun: classify,
+    resolveControlTarget: controlTarget,
+    async removeRunRegistryEntry(input) {
+      return { runId: input.runId, removed: await removeRegistryEntry(input.projectRoot, input.runId) };
+    }
+  };
+});
+
+// packages/run-worker/src/host-kernel.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { applyConfigEnv } from "@rig/core/config-env";
+import { loadConfig } from "@rig/core/load-config";
+import { bootDefaultKernelIntoProcess } from "@rig/kernel-seed/boot-default";
+import { createPlacementTransportPlugin } from "@rig/kernel-seed/default-kernel";
+function unquoteDotenvValue(value) {
+  const trimmed = value.trim();
+  if (trimmed.length >= 2 && (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function hydrateDotenv(path, env) {
+  if (!existsSync2(path))
+    return false;
+  const source = readFileSync2(path, "utf8");
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const assignment = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
+    const equals = assignment.indexOf("=");
+    if (equals <= 0)
+      continue;
+    const key = assignment.slice(0, equals).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || env[key])
+      continue;
+    env[key] = unquoteDotenvValue(assignment.slice(equals + 1));
+  }
+  return true;
+}
+function createRunWorkerPlacementTransportPlugin(transport) {
+  return createPlacementTransportPlugin(transport);
+}
+async function hydrateRunWorkerProjectEnv(projectRoot, options = {}) {
+  const normalizedRoot = resolve2(projectRoot);
+  const env = options.env ?? process.env;
+  const errors = [];
+  let dotenvLoaded = false;
+  let configLoaded = false;
+  try {
+    dotenvLoaded = hydrateDotenv(resolve2(normalizedRoot, options.dotenvPath ?? ".env"), env);
+  } catch (error) {
+    errors.push(`dotenv: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  try {
+    applyConfigEnv(await loadConfig(normalizedRoot), env);
+    configLoaded = true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes("no rig.config"))
+      errors.push(`config: ${message}`);
+  }
+  return { projectRoot: normalizedRoot, dotenvLoaded, configLoaded, errors };
+}
+async function adoptRunWorkerKernel(root, options = {}) {
+  if (options.hydrateEnv === true && root !== undefined) {
+    await hydrateRunWorkerProjectEnv(root, options);
+  }
+  const bootInput = {
+    ...options.entrypoint !== undefined ? { entrypoint: options.entrypoint } : {},
+    ...options.journal !== undefined ? { journal: options.journal } : {}
+  };
+  if (options.transport === undefined)
+    return await bootDefaultKernelIntoProcess(bootInput);
+  return await bootDefaultKernelIntoProcess({
+    ...bootInput,
+    extraPlugins: [createRunWorkerPlacementTransportPlugin(options.transport)]
+  });
+}
+var init_host_kernel = () => {};
+
+// packages/run-worker/src/local-run-changes.ts
+import { existsSync as existsSync3, mkdirSync, watch } from "fs";
+import { dirname, resolve as resolve3 } from "path";
+import { Effect, Queue, Stream } from "effect";
+function findNearestGitCheckoutRoot(startDir) {
+  let current = resolve3(startDir);
+  for (;; ) {
+    if (existsSync3(resolve3(current, ".git")))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function resolveCheckoutRoot(projectRoot) {
+  const normalizedProjectRoot = resolve3(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve3(explicit);
+    const gitRoot = findNearestGitCheckoutRoot(explicitRoot);
+    if (gitRoot)
+      return gitRoot;
+    throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there or above it.`);
+  }
+  return findNearestGitCheckoutRoot(normalizedProjectRoot) ?? normalizedProjectRoot;
+}
+function isRelevantLocalRunChange(filename) {
+  if (filename === null || filename === undefined)
+    return true;
+  const raw = filename.toString();
+  if (!raw.trim())
+    return true;
+  const segments = raw.split(/[\\/]+/).filter(Boolean);
+  if (segments.some((segment) => segment === ".git" || segment === "node_modules" || segment === "build" || segment === "dist" || segment === "out" || segment === ".next" || segment === "coverage")) {
+    return false;
+  }
+  const rigIndex = segments.lastIndexOf(".rig");
+  if (rigIndex < 0)
+    return false;
+  const rigChild = segments[rigIndex + 1];
+  if (rigChild === "session")
+    return true;
+  return rigChild === "runtime-context.json" && segments[rigIndex + 2] === undefined;
+}
+var localRunChanges = (projectRoot) => Stream.callback((queue) => Effect.gen(function* () {
+  const worktreesRoot = resolve3(resolveCheckoutRoot(projectRoot), ".worktrees");
+  if (!existsSync3(worktreesRoot)) {
+    try {
+      mkdirSync(worktreesRoot, { recursive: true });
+    } catch {}
+  }
+  const watcher = watch(worktreesRoot, { recursive: true }, (_event, filename) => {
+    if (!isRelevantLocalRunChange(filename))
+      return;
+    Queue.offerUnsafe(queue, undefined);
+  });
+  watcher.on("error", () => {});
+  yield* Effect.addFinalizer(() => Effect.sync(() => watcher.close()));
+}), { bufferSize: 1, strategy: "sliding" });
+var init_local_run_changes = () => {};
+
+// packages/run-worker/src/notify-cap.ts
+import { NOTIFY_SERVICE_CAPABILITY } from "@rig/contracts";
+import { defineCapability as defineCapability3 } from "@rig/core/capability";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+async function resolveNotifyService(projectRoot) {
+  const { host } = await resolvePluginHost(projectRoot);
+  return NotifyCap.resolve(host);
+}
+var NotifyCap;
+var init_notify_cap = __esm(() => {
+  NotifyCap = defineCapability3(NOTIFY_SERVICE_CAPABILITY);
+});
 
 // packages/run-worker/src/notifications.ts
-import { resolve } from "path";
-import { dispatchEventToTargets, loadNotificationConfig } from "@rig/notifications-plugin/notifications";
 async function dispatchRunNotifications(projectRoot, runId, taskId, outcome, detail) {
   try {
-    const config = await loadNotificationConfig(resolve(projectRoot, ".rig", "notifications.json"));
-    if (config.targets.length === 0)
+    const notifier = await resolveNotifyService(projectRoot);
+    if (!notifier)
       return;
     const event = { runId, type: `run.${outcome}`, timestamp: new Date().toISOString(), payload: { taskId, detail } };
     await Promise.race([
-      dispatchEventToTargets(event, config.targets),
+      notifier.notify(event),
       new Promise((resolveCap) => setTimeout(resolveCap, 5000))
     ]);
   } catch {}
 }
-var init_notifications = () => {};
+var init_notifications = __esm(() => {
+  init_notify_cap();
+});
+
+// packages/run-worker/src/panel-plugin.ts
+import { createProjectPluginHost } from "@rig/core/project-plugins";
+import { RIG_CAPABILITY_PANEL_SLOT, RIG_RUN_STOP_PANEL_ACTION, RIG_SUPERVISOR_PANEL_ID } from "@rig/contracts";
+async function produceWorkerPanelPayload(producer, context) {
+  if (!producer.produce)
+    return;
+  let timeout;
+  try {
+    return await Promise.race([
+      Promise.resolve(producer.produce(context)),
+      new Promise((resolve4) => {
+        timeout = setTimeout(() => resolve4(undefined), PANEL_PRODUCER_TIMEOUT_MS);
+      })
+    ]);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function loadWorkerPanelRegistry(projectRoot) {
+  const { host } = await createProjectPluginHost(projectRoot, {
+    mode: "strict-config-only"
+  });
+  return {
+    registrations: host.listPanels().filter((registration) => registration.slot === RIG_CAPABILITY_PANEL_SLOT),
+    producers: host.listExecutablePanels().filter((registration) => registration.slot === RIG_CAPABILITY_PANEL_SLOT)
+  };
+}
+var RIG_PANELS_CUSTOM_MESSAGE_TYPE = "rig-panels", PANEL_PRODUCER_TIMEOUT_MS = 2000;
+var init_panel_plugin = () => {};
 
 // packages/run-worker/src/constants.ts
-var RUN_PROCESS_STEER_TIMEOUT_MS, TRACKED_RUN_STALL_MS, RUN_PROCESS_STALL_SWEEP_MS, RUN_PROCESS_STALL_DETAIL = "Run process made no OMP session progress for 20+ minutes; recording a stall so recovery can requeue or resume the session.";
+var TRACKED_RUN_STALL_MS, RUN_PROCESS_STALL_SWEEP_MS, RUN_PROCESS_STALL_DETAIL = "Run process made no OMP session progress for 20+ minutes; recording a stall so recovery can requeue or resume the session.";
 var init_constants = __esm(() => {
-  RUN_PROCESS_STEER_TIMEOUT_MS = 10 * 60 * 1000;
   TRACKED_RUN_STALL_MS = 20 * 60 * 1000;
   RUN_PROCESS_STALL_SWEEP_MS = 60 * 1000;
 });
@@ -116,43 +1864,9 @@ var init_stall = __esm(() => {
   init_constants();
 });
 
-// packages/run-worker/src/panel-plugin.ts
-import { createProjectPluginHost, projectPluginResolutionWarningMessages } from "@rig/core/project-plugins";
-import { RIG_CAPABILITY_PANEL_SLOT, RIG_RUN_STOP_PANEL_ACTION, RIG_SUPERVISOR_PANEL_ID } from "@rig/contracts";
-async function produceWorkerPanelPayload(producer, context) {
-  if (!producer.produce)
-    return;
-  let timeout;
-  try {
-    return await Promise.race([
-      Promise.resolve(producer.produce(context)),
-      new Promise((resolve2) => {
-        timeout = setTimeout(() => resolve2(undefined), PANEL_PRODUCER_TIMEOUT_MS);
-      })
-    ]);
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-async function loadWorkerPanelRegistry(projectRoot) {
-  const { host, resolved } = await createProjectPluginHost(projectRoot, {
-    mode: "strict-config-only",
-    surfaceName: "run-worker-panel-registry"
-  });
-  for (const message of projectPluginResolutionWarningMessages(resolved)) {
-    console.warn(`[rig-run] ${message}`);
-  }
-  return {
-    registrations: host.listPanels().filter((registration) => registration.slot === RIG_CAPABILITY_PANEL_SLOT),
-    producers: host.listExecutablePanels().filter((registration) => registration.slot === RIG_CAPABILITY_PANEL_SLOT)
-  };
-}
-var RIG_PANELS_CUSTOM_MESSAGE_TYPE = "rig-panels", PANEL_PRODUCER_TIMEOUT_MS = 2000;
-var init_panel_plugin = () => {};
-
 // packages/run-worker/src/utils.ts
-import { createWorkflowStatusChanged, RIG_WORKFLOW_STATUS_CHANGED } from "@rig/contracts";
-import { resolveRegistryBaseUrl, resolveRelayUrl } from "@rig/runtime/control-plane/remote-config";
+import { RIG_WORKFLOW_STATUS_CHANGED as RIG_WORKFLOW_STATUS_CHANGED2 } from "@rig/contracts";
+import { resolveRegistryBaseUrl as resolveRegistryBaseUrl2, resolveRelayUrl } from "@rig/core/remote-config";
 function customEntries(entries) {
   const customs = [];
   for (const entry of entries) {
@@ -165,27 +1879,29 @@ function rigProjectRoot() {
   return process.env.PROJECT_RIG_ROOT?.trim() || process.env.RIG_HOST_PROJECT_ROOT?.trim() || process.cwd();
 }
 function registryBaseUrl() {
-  return resolveRegistryBaseUrl(rigProjectRoot());
+  return resolveRegistryBaseUrl2(rigProjectRoot());
 }
 function rigRelayUrl() {
   return resolveRelayUrl();
 }
-var init_utils = () => {};
+var init_utils = __esm(() => {
+  init_session_journal();
+});
 
 // packages/run-worker/src/autohost.ts
-import { runPipelineCloseout } from "@rig/bundle-default-lifecycle/pipeline-closeout";
-import { adoptPlacementKernel } from "@rig/kernel/kernel-entrypoint";
-import { latestTimelineEntriesFromCustomEntries, parseInboxResolutionSentinel, parsePauseSentinel, parseResumeSentinel, parseStopSentinel, RIG_RUN_STOP_PANEL_ACTION as RIG_RUN_STOP_PANEL_ACTION2, RIG_SUPERVISOR_PANEL_ID as RIG_SUPERVISOR_PANEL_ID2, sessionIdFromSessionFile } from "@rig/contracts";
-import { Duration, Effect, Fiber, Stream } from "effect";
-import { createEnvCloseoutRunners } from "@rig/bundle-default-lifecycle/native/closeout-runners";
-import { CloseoutValidationError } from "@rig/bundle-default-lifecycle/native/in-process-closeout";
-import { projectRunFromSession } from "@rig/runtime/control-plane/run-session-projection";
-import { localRunChanges } from "@rig/runtime/control-plane/run-discovery-stream";
-import { updateRunTaskSourceLifecycle } from "@rig/runtime/control-plane/tasks/source-lifecycle";
-import { resolveOwnerNamespaceKey } from "@rig/runtime/control-plane/remote-config";
-import { resolveRigIdentity } from "@rig/runtime/control-plane/identity";
-import { connectWorkerProjection, createRegistryClient } from "@rig/relay-registry";
-import { coerceRegistryStatus } from "@rig/relay-registry/schema";
+import {
+  PLACEMENT_RUN_TRANSPORT,
+  RIG_RUN_STOP_PANEL_ACTION as RIG_RUN_STOP_PANEL_ACTION2,
+  RIG_SUPERVISOR_PANEL_ID as RIG_SUPERVISOR_PANEL_ID2,
+  RUN_IDENTITY_ENV,
+  RUN_REGISTRY_BACKBONE as RUN_REGISTRY_BACKBONE2,
+  RUN_CLOSEOUT_CAPABILITY,
+  TASK_DATA_SERVICE_CAPABILITY
+} from "@rig/contracts";
+import { Duration, Effect as Effect2, Fiber, Stream as Stream2 } from "effect";
+import { defineCapability as defineCapability4 } from "@rig/core/capability";
+import { requireInstalledCapability, loadCapabilityForRoot as loadCapabilityForRoot3 } from "@rig/core/capability-loaders";
+import { resolveOwnerNamespaceKey as resolveOwnerNamespaceKey2 } from "@rig/core/remote-config";
 function syntheticRegistryOwner(namespaceKey) {
   const githubUserId = namespaceKey.startsWith("gh:") ? namespaceKey.slice(3) : namespaceKey;
   return {
@@ -194,18 +1910,25 @@ function syntheticRegistryOwner(namespaceKey) {
     namespaceKey
   };
 }
+function coerceRegistryStatus(value, fallback) {
+  if (value === "starting")
+    return "preparing";
+  if (value === "waiting-input")
+    return "waiting-user-input";
+  return typeof value === "string" && REGISTRY_STATUS[value] ? value : fallback;
+}
 async function reflectStoppedRunTaskSource(input) {
   const taskId = input.taskId?.trim();
   if (!taskId)
     return false;
   const reason = input.reason?.trim();
-  await (input.updateLifecycle ?? updateRunTaskSourceLifecycle)(input.projectRoot, {
+  await (input.updateLifecycle ?? taskData().updateRunTaskSourceLifecycle)(input.projectRoot, {
     runId: input.runId,
     taskId,
-    sourceTask: input.sourceTask,
-    worktreePath: input.worktreePath,
-    logRoot: input.logRoot,
-    sessionPath: input.sessionPath
+    ...input.sourceTask !== undefined ? { sourceTask: input.sourceTask } : {},
+    ...input.worktreePath !== undefined ? { worktreePath: input.worktreePath } : {},
+    ...input.logRoot !== undefined ? { logRoot: input.logRoot } : {},
+    ...input.sessionPath !== undefined ? { sessionPath: input.sessionPath } : {}
   }, "cancelled", reason ? `Rig stopped by operator: ${reason}` : "Rig stopped by operator.");
   return true;
 }
@@ -286,8 +2009,14 @@ async function maybeStartRunProcessAutohost(api, ctx) {
     throw new Error("OMP session id is required when RIG_RUN_PROCESS=1; RIG_RUN_ID is only a dispatch handle.");
   const projectRoot = process.env.PROJECT_RIG_ROOT ?? process.cwd();
   const journal = await createRunJournal(ctx.sessionManager, runId);
-  await adoptPlacementKernel(projectRoot, {
+  const placementTransport = await loadCapabilityForRoot3(projectRoot, PlacementTransportCap);
+  if (!placementTransport) {
+    throw new Error("placement run transport capability unavailable: ensure @rig/transport-plugin is installed.");
+  }
+  await adoptRunWorkerKernel(projectRoot, {
     entrypoint: "run-worker",
+    hydrateEnv: true,
+    transport: placementTransport,
     ...journal ? { journal: journal.kernel } : {}
   });
   if (!ctx.hasUI)
@@ -296,7 +2025,9 @@ async function maybeStartRunProcessAutohost(api, ctx) {
   const startHost = collab?.startCollabHost ?? collab?.startHost;
   if (!startHost)
     throw new Error("OMP collab host facade is unavailable for Rig run process.");
-  const identity = resolveRigIdentity(ctx);
+  const identityEnv = await loadCapabilityForRoot3(projectRoot, RunIdentityEnvCap);
+  const identity = identityEnv?.resolveRigIdentity(ctx) ?? null;
+  const registryBackbone = await loadCapabilityForRoot3(projectRoot, RunRegistryBackboneCap2);
   const panelRegistry = await loadWorkerPanelRegistry(projectRoot);
   let runProjection = projectRunFromSession(customEntries(ctx.sessionManager.getBranch()), runId);
   const taskIdAtStart = process.env.RIG_TASK_ID?.trim() || runProjection.record.taskId;
@@ -315,10 +2046,10 @@ async function maybeStartRunProcessAutohost(api, ctx) {
   let runRegistryRoomId = null;
   let workerProjectionConnection = null;
   let workerProjectionFiber = null;
-  const runRegistryNamespace = identity?.owner?.namespaceKey ?? resolveOwnerNamespaceKey(rigProjectRoot()) ?? "anonymous";
+  const runRegistryNamespace = identity?.owner?.namespaceKey ?? resolveOwnerNamespaceKey2(rigProjectRoot()) ?? "anonymous";
   const runRegistryOwner = identity?.owner ?? syntheticRegistryOwner(runRegistryNamespace);
   const runRegistryRepo = identity?.selectedRepo ?? "";
-  const runRegistry = createRegistryClient({ baseUrl: registryBaseUrl(), namespaceKey: runRegistryNamespace });
+  const runRegistry = registryBackbone?.createRegistryClient({ baseUrl: registryBaseUrl(), namespaceKey: runRegistryNamespace }) ?? null;
   let runRegistryLinks = {};
   const processedControlEntryIds = new Set((ctx.sessionManager.getEntries?.() ?? []).map((entry) => entry && typeof entry === "object" && typeof entry.id === "string" ? entry.id : null).filter((id) => id !== null));
   const processedControlEntryObjects = new WeakSet;
@@ -352,7 +2083,7 @@ async function maybeStartRunProcessAutohost(api, ctx) {
       joinLink: links.joinLink,
       webLink: links.webLink,
       relayUrl: links.relayUrl,
-      sessionPath: ctx.sessionManager.getSessionFile(),
+      sessionPath: ctx.sessionManager.getSessionFile() ?? null,
       timeline
     });
   };
@@ -366,7 +2097,7 @@ async function maybeStartRunProcessAutohost(api, ctx) {
       projectRoot,
       runId,
       folded,
-      taskIdAtStart,
+      ...taskIdAtStart !== undefined ? { taskIdAtStart } : {},
       runDisplayTitle
     };
     const payloadEntries = await Promise.all(panelRegistry.producers.map(async (producer) => {
@@ -426,7 +2157,7 @@ async function maybeStartRunProcessAutohost(api, ctx) {
       runRegistryHeartbeat = null;
     }
     if (workerProjectionFiber) {
-      Effect.runFork(Fiber.interrupt(workerProjectionFiber));
+      Effect2.runFork(Fiber.interrupt(workerProjectionFiber));
       workerProjectionFiber = null;
     }
     if (workerProjectionConnection) {
@@ -460,26 +2191,26 @@ async function maybeStartRunProcessAutohost(api, ctx) {
     journal?.appendTimeline({ type: "inbox-resolution", kind: "input", requestId: resolution.requestId });
   };
   const applyRunControlText = (text) => {
-    const control = detectRunControlText(text, runId);
-    if (!control)
+    const control2 = detectRunControlText(text, runId);
+    if (!control2)
       return;
     markRunActivity();
-    if (control.kind === "pause") {
+    if (control2.kind === "pause") {
       pendingPause = true;
       return;
     }
-    if (control.kind === "resume") {
+    if (control2.kind === "resume") {
       pendingPause = false;
       pendingStopReason = undefined;
       appendRunStatus("running", "operator resumed run", true);
       publishRunProjection("running");
       return;
     }
-    if (control.kind === "stop") {
-      pendingStopReason = control.reason ?? "operator requested stop";
+    if (control2.kind === "stop") {
+      pendingStopReason = control2.reason ?? "operator requested stop";
       return;
     }
-    applyInboxResolution(control.resolution);
+    applyInboxResolution(control2.resolution);
   };
   const processRunControlMessages = () => {
     for (const entry of ctx.sessionManager.getEntries?.() ?? []) {
@@ -538,7 +2269,7 @@ async function maybeStartRunProcessAutohost(api, ctx) {
       if (roomId !== runId) {
         throw new Error(`Collab host session id mismatch: expected ${runId}, got ${roomId}`);
       }
-      runRegistryLinks = { joinLink: projection.joinLink, webLink: projection.webLink, relayUrl: projection.relayUrl ?? rigRelayUrl() };
+      runRegistryLinks = { joinLink: projection.joinLink ?? null, webLink: projection.webLink ?? null, relayUrl: projection.relayUrl ?? rigRelayUrl() };
       const timeline = {
         type: "collab-host-started",
         roomId,
@@ -550,10 +2281,11 @@ async function maybeStartRunProcessAutohost(api, ctx) {
       console.log(`[rig-run] collab-host-started joinLink=${projection.joinLink || "(empty)"} relayUrl=${projection.relayUrl || "(empty)"}`);
       ctx.ui.notify("Rig run collab host started.", "info");
       publishRigPanelsSnapshotBestEffort();
-      if (runRegistry) {
+      if (runRegistry && registryBackbone) {
         try {
           runRegistryRoomId = roomId;
           const initialProjection = buildCurrentRegistryProjection();
+          const sessionPath = ctx.sessionManager.getSessionFile();
           await runRegistry.registerRoom({
             roomId,
             owner: runRegistryOwner,
@@ -565,14 +2297,14 @@ async function maybeStartRunProcessAutohost(api, ctx) {
             relayUrl: projection.relayUrl ?? rigRelayUrl(),
             startedAt: new Date().toISOString(),
             cwd: process.cwd(),
-            sessionPath: ctx.sessionManager.getSessionFile() ?? undefined,
+            ...sessionPath ? { sessionPath } : {},
             pid: process.pid,
             projection: initialProjection
           });
-          workerProjectionConnection = connectWorkerProjection({ baseUrl: registryBaseUrl(), namespaceKey: runRegistryNamespace, runId: roomId });
+          workerProjectionConnection = registryBackbone.connectWorkerProjection({ baseUrl: registryBaseUrl(), namespaceKey: runRegistryNamespace, runId: roomId });
           workerProjectionConnection.ready.catch((err) => console.error(`[rig-run] worker-projection-degraded (heartbeat remains authoritative): ${err instanceof Error ? err.message : String(err)}`));
           pushWorkerProjection();
-          workerProjectionFiber = Effect.runFork(localRunChanges(projectRoot).pipe(Stream.debounce(Duration.millis(500)), Stream.runForEach(() => Effect.sync(() => pushWorkerProjection()))));
+          workerProjectionFiber = Effect2.runFork(localRunChanges(projectRoot).pipe(Stream2.debounce(Duration.millis(500)), Stream2.runForEach(() => Effect2.sync(() => pushWorkerProjection()))));
           journal?.appendTimeline({ type: "registry-registered", roomId });
           console.log(`[rig-run] registry-registered roomId=${roomId}`);
           runRegistryHeartbeat = setInterval(() => {
@@ -605,7 +2337,7 @@ async function maybeStartRunProcessAutohost(api, ctx) {
   if (taskIdAtStart) {
     journal?.appendTimeline({ type: "stage", stage: "GitHub-sync", status: "running", detail: "reflecting rig:running to task source" });
     try {
-      await updateRunTaskSourceLifecycle(projectRoot, {
+      await taskData().updateRunTaskSourceLifecycle(projectRoot, {
         runId,
         taskId: taskIdAtStart,
         sourceTask: runProjection.record.sourceTask,
@@ -698,10 +2430,9 @@ async function maybeStartRunProcessAutohost(api, ctx) {
       setTimeout(() => process.exit(1), 0);
       return;
     }
-    const { command, gitCommand } = createEnvCloseoutRunners(process.env);
     let closeoutStatusAdvanced = false;
     try {
-      await runPipelineCloseout({
+      await requireInstalledCapability(RunCloseoutCap, "run-closeout capability unavailable in run-worker autohost: ensure @rig/bundle-default-lifecycle (default bundle) is installed.")({
         projectRoot,
         runId,
         taskId,
@@ -709,8 +2440,6 @@ async function maybeStartRunProcessAutohost(api, ctx) {
         workspace: process.cwd(),
         artifactRoot: runProjection.record.artifactRoot ?? null,
         sourceTask: runProjection.record.sourceTask && typeof runProjection.record.sourceTask === "object" && !Array.isArray(runProjection.record.sourceTask) ? runProjection.record.sourceTask : null,
-        command,
-        gitCommand,
         steerPi,
         onValidationStart: async () => {
           journal?.appendStatus("validating", { actor: { kind: "agent" }, reason: "validating task before closeout", force: true });
@@ -726,7 +2455,7 @@ async function maybeStartRunProcessAutohost(api, ctx) {
           }
         },
         reflect: async (status, summary, opts) => {
-          await updateRunTaskSourceLifecycle(projectRoot, {
+          await taskData().updateRunTaskSourceLifecycle(projectRoot, {
             runId,
             taskId,
             sourceTask: runProjection.record.sourceTask,
@@ -745,7 +2474,7 @@ async function maybeStartRunProcessAutohost(api, ctx) {
       setTimeout(() => process.exit(0), 0);
     } catch (error) {
       const detail = error instanceof Error ? error.message : String(error);
-      const status = error instanceof CloseoutValidationError ? "needs-attention" : "failed";
+      const status = error instanceof Error && error.name === "CloseoutValidationError" ? "needs-attention" : "failed";
       journal?.appendStatus(status, { actor: { kind: "agent" }, errorText: detail, force: true });
       await publishRunProjection(status);
       await dispatchRunNotifications(projectRoot, runId, taskId, "failed", detail);
@@ -771,7 +2500,7 @@ async function maybeStartSpikeAutohost(ctx) {
   const startHost = collab?.startHost ?? collab?.startCollabHost;
   if (!startHost)
     throw new Error("OMP collab host facade is unavailable for detached PTY spike.");
-  const identity = resolveRigIdentity(ctx);
+  const identity = (await loadCapabilityForRoot3(rigProjectRoot(), RunIdentityEnvCap))?.resolveRigIdentity(ctx) ?? null;
   await startHost.call(collab, {
     relayUrl,
     title: "Rig detached PTY spike",
@@ -779,13 +2508,38 @@ async function maybeStartSpikeAutohost(ctx) {
     ...identity?.selectedRepo ? { selectedRepo: identity.selectedRepo } : {}
   });
 }
-var REGISTRY_PROJECTION_TIMELINE_LIMIT = 100, OPERATOR_ACTOR;
+var TaskDataCap, PlacementTransportCap, RunIdentityEnvCap, RunRegistryBackboneCap2, RunCloseoutCap, taskData = () => requireInstalledCapability(TaskDataCap, "task-data capability unavailable in run-exec autohost: ensure @rig/task-sources-plugin (default bundle) is installed."), REGISTRY_STATUS, REGISTRY_PROJECTION_TIMELINE_LIMIT = 100, OPERATOR_ACTOR;
 var init_autohost = __esm(() => {
-  init_journal();
+  init_host_kernel();
+  init_local_run_changes();
   init_notifications();
-  init_stall();
   init_panel_plugin();
+  init_session_journal();
+  init_stall();
   init_utils();
+  TaskDataCap = defineCapability4(TASK_DATA_SERVICE_CAPABILITY);
+  PlacementTransportCap = defineCapability4(PLACEMENT_RUN_TRANSPORT);
+  RunIdentityEnvCap = defineCapability4(RUN_IDENTITY_ENV);
+  RunRegistryBackboneCap2 = defineCapability4(RUN_REGISTRY_BACKBONE2);
+  RunCloseoutCap = defineCapability4(RUN_CLOSEOUT_CAPABILITY);
+  REGISTRY_STATUS = {
+    created: true,
+    queued: true,
+    preparing: true,
+    running: true,
+    "waiting-approval": true,
+    "waiting-user-input": true,
+    paused: true,
+    validating: true,
+    reviewing: true,
+    "closing-out": true,
+    "needs-attention": true,
+    completed: true,
+    failed: true,
+    stopped: true,
+    starting: true,
+    "waiting-input": true
+  };
   OPERATOR_ACTOR = { kind: "operator" };
 });
 
@@ -825,11 +2579,65 @@ var init_extension = __esm(() => {
 });
 
 // packages/run-worker/src/plugin.ts
+import { defineCapability as defineCapability5 } from "@rig/core/capability";
 import { definePlugin } from "@rig/core/config";
+import { RUN_READ_MODEL } from "@rig/contracts";
+async function installWorkerInboxIfPresent(parentPort) {
+  if (!parentPort)
+    return;
+  const { installWorkerInbox } = await import("@oh-my-pi/pi-utils/worker-host");
+  installWorkerInbox(parentPort);
+}
+var RunReadModelCap = defineCapability5(RUN_READ_MODEL);
+var RUN_WORKER_SEED_ENTRYPOINTS = [
+  {
+    id: "@rig/run-worker:stats-sync-worker",
+    workerArg: "__omp_worker_stats_sync",
+    description: "OMP stats sync self-exec worker.",
+    run: async () => {
+      const scope = globalThis;
+      const pending = [];
+      const buffer = (event) => {
+        pending.push(event);
+      };
+      scope.onmessage = buffer;
+      await import("@oh-my-pi/omp-stats/sync-worker");
+      const handler = scope.onmessage;
+      if (handler && handler !== buffer) {
+        for (const event of pending)
+          handler.call(scope, event);
+      }
+    }
+  },
+  {
+    id: "@rig/run-worker:tab-worker",
+    workerArg: "__omp_worker_tab",
+    description: "Browser tab tool self-exec worker.",
+    run: async ({ parentPort }) => {
+      await installWorkerInboxIfPresent(parentPort);
+      await import("@oh-my-pi/pi-coding-agent/tools/browser/tab-worker-entry");
+    }
+  },
+  {
+    id: "@rig/run-worker:js-eval-worker",
+    workerArg: "__omp_worker_js_eval",
+    description: "JavaScript eval tool self-exec worker.",
+    run: async ({ parentPort }) => {
+      await installWorkerInboxIfPresent(parentPort);
+      await import("@oh-my-pi/pi-coding-agent/eval/js/worker-entry");
+    }
+  }
+];
 var runWorkerPlugin = definePlugin({
   name: "@rig/run-worker",
   version: "0.0.0-alpha.1",
   contributes: {
+    capabilities: [
+      RunReadModelCap.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 target canonical run session projections for operator surfaces."
+      })
+    ],
     sessionExtensions: [
       {
         id: "rig:run-worker",
@@ -839,7 +2647,8 @@ var runWorkerPlugin = definePlugin({
           rigWorkerExtension2(api);
         }
       }
-    ]
+    ],
+    seedEntrypoints: RUN_WORKER_SEED_ENTRYPOINTS
   }
 });
 function createRunWorkerPlugin() {