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

package/dist/src/autohost.js

@@ -1,29 +1,631 @@
 // @bun
 // 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,
+  RUN_CLOSEOUT_CAPABILITY,
+  TASK_DATA_SERVICE_CAPABILITY
+} from "@rig/contracts";
+import { Duration, Effect as Effect2, Fiber, Stream as Stream2 } from "effect";
+import { defineCapability as defineCapability2 } from "@rig/core/capability";
+import { requireInstalledCapability, loadCapabilityForRoot } from "@rig/core/capability-loaders";
+import { resolveOwnerNamespaceKey } from "@rig/core/remote-config";
 
-// 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/host-kernel.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } 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 (!existsSync(path))
+    return false;
+  const source = readFileSync(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 = resolve(projectRoot);
+  const env = options.env ?? process.env;
+  const errors = [];
+  let dotenvLoaded = false;
+  let configLoaded = false;
+  try {
+    dotenvLoaded = hydrateDotenv(resolve(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)]
+  });
+}
+
+// packages/run-worker/src/local-run-changes.ts
+import { existsSync as existsSync2, mkdirSync, watch } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import { Effect, Queue, Stream } from "effect";
+function findNearestGitCheckoutRoot(startDir) {
+  let current = resolve2(startDir);
+  for (;; ) {
+    if (existsSync2(resolve2(current, ".git")))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function resolveCheckoutRoot(projectRoot) {
+  const normalizedProjectRoot = resolve2(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve2(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 = resolve2(resolveCheckoutRoot(projectRoot), ".worktrees");
+  if (!existsSync2(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" });
+
+// packages/run-worker/src/notify-cap.ts
+import { NOTIFY_SERVICE_CAPABILITY } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+var NotifyCap = defineCapability(NOTIFY_SERVICE_CAPABILITY);
+async function resolveNotifyService(projectRoot) {
+  const { host } = await resolvePluginHost(projectRoot);
+  return NotifyCap.resolve(host);
+}
+
+// packages/run-worker/src/notifications.ts
+async function dispatchRunNotifications(projectRoot, runId, taskId, outcome, detail) {
+  try {
+    const notifier = await resolveNotifyService(projectRoot);
+    if (!notifier)
+      return;
+    const event = { runId, type: `run.${outcome}`, timestamp: new Date().toISOString(), payload: { taskId, detail } };
+    await Promise.race([
+      notifier.notify(event),
+      new Promise((resolveCap) => setTimeout(resolveCap, 5000))
+    ]);
+  } catch {}
+}
+
+// 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";
+var RIG_PANELS_CUSTOM_MESSAGE_TYPE = "rig-panels";
+var PANEL_PRODUCER_TIMEOUT_MS = 2000;
+async function produceWorkerPanelPayload(producer, context) {
+  if (!producer.produce)
+    return;
+  let timeout;
+  try {
+    return await Promise.race([
+      Promise.resolve(producer.produce(context)),
+      new Promise((resolve3) => {
+        timeout = setTimeout(() => resolve3(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)
+  };
+}
+
+// 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";
+var decodeRunJournalEvent = Schema.decodeUnknownSync(RunJournalEvent);
+var RUN_STATUS_TRANSITIONS = {
+  created: ["queued", "preparing", "running", "failed", "stopped"],
+  queued: ["preparing", "running", "failed", "stopped"],
+  preparing: ["queued", "running", "needs-attention", "failed", "stopped"],
+  running: [
+    "queued",
+    "waiting-approval",
+    "waiting-user-input",
+    "paused",
+    "validating",
+    "reviewing",
+    "closing-out",
+    "needs-attention",
+    "completed",
+    "failed",
+    "stopped"
+  ],
+  "waiting-approval": ["running", "needs-attention", "failed", "stopped"],
+  "waiting-user-input": ["running", "needs-attention", "failed", "stopped"],
+  paused: ["running", "failed", "stopped"],
+  validating: ["running", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+  reviewing: ["running", "validating", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+  "closing-out": ["running", "needs-attention", "completed", "failed", "stopped"],
+  "needs-attention": ["queued", "preparing", "running", "closing-out", "completed", "failed", "stopped"],
+  completed: [],
+  failed: ["queued", "preparing", "running", "closing-out"],
+  stopped: ["queued", "preparing", "running", "closing-out"]
+};
+var TERMINAL_RUN_STATUSES = ["completed", "failed", "stopped"];
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+function canTransitionRunStatus(from, to) {
+  if (from === null)
+    return true;
+  if (from === to)
+    return true;
+  return RUN_STATUS_TRANSITIONS[from].includes(to);
+}
+function 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 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,24 +644,7 @@ async function createRunJournal(sessionManager, runId) {
   }
 }
 
-// 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)
-      return;
-    const event = { runId, type: `run.${outcome}`, timestamp: new Date().toISOString(), payload: { taskId, detail } };
-    await Promise.race([
-      dispatchEventToTargets(event, config.targets),
-      new Promise((resolveCap) => setTimeout(resolveCap, 5000))
-    ]);
-  } catch {}
-}
-
 // packages/run-worker/src/constants.ts
-var RUN_PROCESS_STEER_TIMEOUT_MS = 10 * 60 * 1000;
 var TRACKED_RUN_STALL_MS = 20 * 60 * 1000;
 var RUN_PROCESS_STALL_SWEEP_MS = 60 * 1000;
 var 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.";
@@ -108,43 +693,9 @@ function startRunProcessStallMonitor(opts) {
   return () => clearInterval(timer);
 }
 
-// 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";
-var RIG_PANELS_CUSTOM_MESSAGE_TYPE = "rig-panels";
-var PANEL_PRODUCER_TIMEOUT_MS = 2000;
-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)
-  };
-}
-
 // 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, resolveRelayUrl } from "@rig/core/remote-config";
 function customEntries(entries) {
   const customs = [];
   for (const entry of entries) {
@@ -164,6 +715,12 @@ function rigRelayUrl() {
 }
 
 // packages/run-worker/src/autohost.ts
+var TaskDataCap = defineCapability2(TASK_DATA_SERVICE_CAPABILITY);
+var PlacementTransportCap = defineCapability2(PLACEMENT_RUN_TRANSPORT);
+var RunIdentityEnvCap = defineCapability2(RUN_IDENTITY_ENV);
+var RunRegistryBackboneCap = defineCapability2(RUN_REGISTRY_BACKBONE);
+var RunCloseoutCap = defineCapability2(RUN_CLOSEOUT_CAPABILITY);
+var taskData = () => requireInstalledCapability(TaskDataCap, "task-data capability unavailable in run-exec autohost: ensure @rig/task-sources-plugin (default bundle) is installed.");
 function syntheticRegistryOwner(namespaceKey) {
   const githubUserId = namespaceKey.startsWith("gh:") ? namespaceKey.slice(3) : namespaceKey;
   return {
@@ -172,19 +729,44 @@ function syntheticRegistryOwner(namespaceKey) {
     namespaceKey
   };
 }
+var 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
+};
+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;
+}
 var REGISTRY_PROJECTION_TIMELINE_LIMIT = 100;
 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;
 }
@@ -266,8 +848,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 loadCapabilityForRoot(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)
@@ -276,7 +864,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 loadCapabilityForRoot(projectRoot, RunIdentityEnvCap);
+  const identity = identityEnv?.resolveRigIdentity(ctx) ?? null;
+  const registryBackbone = await loadCapabilityForRoot(projectRoot, RunRegistryBackboneCap);
   const panelRegistry = await loadWorkerPanelRegistry(projectRoot);
   let runProjection = projectRunFromSession(customEntries(ctx.sessionManager.getBranch()), runId);
   const taskIdAtStart = process.env.RIG_TASK_ID?.trim() || runProjection.record.taskId;
@@ -298,7 +888,7 @@ async function maybeStartRunProcessAutohost(api, ctx) {
   const runRegistryNamespace = identity?.owner?.namespaceKey ?? resolveOwnerNamespaceKey(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;
@@ -332,7 +922,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
     });
   };
@@ -346,7 +936,7 @@ async function maybeStartRunProcessAutohost(api, ctx) {
       projectRoot,
       runId,
       folded,
-      taskIdAtStart,
+      ...taskIdAtStart !== undefined ? { taskIdAtStart } : {},
       runDisplayTitle
     };
     const payloadEntries = await Promise.all(panelRegistry.producers.map(async (producer) => {
@@ -406,7 +996,7 @@ async function maybeStartRunProcessAutohost(api, ctx) {
       runRegistryHeartbeat = null;
     }
     if (workerProjectionFiber) {
-      Effect.runFork(Fiber.interrupt(workerProjectionFiber));
+      Effect2.runFork(Fiber.interrupt(workerProjectionFiber));
       workerProjectionFiber = null;
     }
     if (workerProjectionConnection) {
@@ -518,7 +1108,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,
@@ -530,10 +1120,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,
@@ -545,14 +1136,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(() => {
@@ -585,7 +1176,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,
@@ -678,10 +1269,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,
@@ -689,8 +1279,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 });
@@ -706,7 +1294,7 @@ async function maybeStartRunProcessAutohost(api, ctx) {
           }
         },
         reflect: async (status, summary, opts) => {
-          await updateRunTaskSourceLifecycle(projectRoot, {
+          await taskData().updateRunTaskSourceLifecycle(projectRoot, {
             runId,
             taskId,
             sourceTask: runProjection.record.sourceTask,
@@ -725,7 +1313,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);
@@ -751,7 +1339,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 loadCapabilityForRoot(rigProjectRoot(), RunIdentityEnvCap))?.resolveRigIdentity(ctx) ?? null;
   await startHost.call(collab, {
     relayUrl,
     title: "Rig detached PTY spike",