@h-rig/run-worker 0.0.6-alpha.155 → 0.0.6-alpha.156

package/dist/src/plugin.js

@@ -0,0 +1,851 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/run-worker/src/journal.ts
+import { createJournalSessionProvider } from "@rig/kernel/journal-session-provider";
+import { RunSessionJournal } from "@rig/runtime/control-plane/run-session-writer";
+async function createRunJournal(sessionManager, runId) {
+  try {
+    const journal = new RunSessionJournal(sessionManager, runId);
+    const kernel = createJournalSessionProvider({
+      runId,
+      store: {
+        appendCustomEntry: (customType, data) => sessionManager.appendCustomEntry(customType, data),
+        getEntries: () => sessionManager.getEntries?.() ?? sessionManager.getBranch?.() ?? []
+      }
+    });
+    return {
+      kernel,
+      appendStatus: journal.appendStatus.bind(journal),
+      appendTimeline: journal.appendTimeline.bind(journal),
+      appendCloseoutPhase: journal.appendCloseoutPhase.bind(journal),
+      appendApprovalResolved: journal.appendApprovalResolved.bind(journal),
+      appendInputResolved: journal.appendInputResolved.bind(journal),
+      appendStall: journal.appendStall.bind(journal)
+    };
+  } catch (error) {
+    console.warn(`[rig-run] RunSessionJournal unavailable; run-state arming deferred: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+var init_journal = () => {};
+
+// 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 {}
+}
+var init_notifications = () => {};
+
+// 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 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;
+});
+
+// packages/run-worker/src/stall.ts
+function timestampMs(value) {
+  if (value === null || value === undefined)
+    return null;
+  const ms = value instanceof Date ? value.getTime() : typeof value === "number" ? value : Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+}
+function computeRunStall(input) {
+  const lastActivityAt = timestampMs(input.lastActivityAt);
+  const now = timestampMs(input.now);
+  if (lastActivityAt === null || now === null || input.thresholdMs <= 0)
+    return false;
+  return now - lastActivityAt >= input.thresholdMs;
+}
+function appendRunStallDetected(journal, detail = RUN_PROCESS_STALL_DETAIL) {
+  if (!journal)
+    return false;
+  try {
+    journal.appendStall({ detail });
+    return true;
+  } catch (error) {
+    console.warn(`[rig-run] stall-detected append failed: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  }
+}
+function startRunProcessStallMonitor(opts) {
+  if (!opts.journal)
+    return () => {};
+  let stallDetected = opts.alreadyStalled === true;
+  const thresholdMs = opts.thresholdMs ?? TRACKED_RUN_STALL_MS;
+  const now = opts.now ?? (() => Date.now());
+  const timer = setInterval(() => {
+    if (stallDetected)
+      return;
+    if (!computeRunStall({ lastActivityAt: opts.lastActivityAt(), now: now(), thresholdMs }))
+      return;
+    stallDetected = true;
+    appendRunStallDetected(opts.journal);
+  }, opts.intervalMs ?? RUN_PROCESS_STALL_SWEEP_MS);
+  if (typeof timer.unref === "function")
+    timer.unref();
+  return () => clearInterval(timer);
+}
+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";
+function customEntries(entries) {
+  const customs = [];
+  for (const entry of entries) {
+    if (entry.type === "custom")
+      customs.push(entry);
+  }
+  return customs;
+}
+function rigProjectRoot() {
+  return process.env.PROJECT_RIG_ROOT?.trim() || process.env.RIG_HOST_PROJECT_ROOT?.trim() || process.cwd();
+}
+function registryBaseUrl() {
+  return resolveRegistryBaseUrl(rigProjectRoot());
+}
+function rigRelayUrl() {
+  return resolveRelayUrl();
+}
+var init_utils = () => {};
+
+// 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";
+function syntheticRegistryOwner(namespaceKey) {
+  const githubUserId = namespaceKey.startsWith("gh:") ? namespaceKey.slice(3) : namespaceKey;
+  return {
+    githubUserId: githubUserId || "anonymous",
+    login: "anonymous",
+    namespaceKey
+  };
+}
+async function reflectStoppedRunTaskSource(input) {
+  const taskId = input.taskId?.trim();
+  if (!taskId)
+    return false;
+  const reason = input.reason?.trim();
+  await (input.updateLifecycle ?? updateRunTaskSourceLifecycle)(input.projectRoot, {
+    runId: input.runId,
+    taskId,
+    sourceTask: input.sourceTask,
+    worktreePath: input.worktreePath,
+    logRoot: input.logRoot,
+    sessionPath: input.sessionPath
+  }, "cancelled", reason ? `Rig stopped by operator: ${reason}` : "Rig stopped by operator.");
+  return true;
+}
+function registryRunProjection(input) {
+  const timeline = input.timeline ?? latestTimelineEntriesFromCustomEntries(input.entries, REGISTRY_PROJECTION_TIMELINE_LIMIT);
+  return {
+    runId: input.runId,
+    taskId: typeof input.folded.record.taskId === "string" ? input.folded.record.taskId : null,
+    title: typeof input.folded.record.title === "string" ? input.folded.record.title : input.title,
+    status: coerceRegistryStatus(input.folded.status, "running"),
+    source: "local",
+    startedAt: typeof input.folded.record.startedAt === "string" ? input.folded.record.startedAt : null,
+    updatedAt: input.folded.lastEventAt ?? (typeof input.folded.record.updatedAt === "string" ? input.folded.record.updatedAt : new Date().toISOString()),
+    completedAt: typeof input.folded.record.completedAt === "string" ? input.folded.record.completedAt : null,
+    joinLink: input.joinLink ?? null,
+    webLink: input.webLink ?? null,
+    relayUrl: input.relayUrl ?? null,
+    sessionPath: typeof input.folded.record.sessionPath === "string" ? input.folded.record.sessionPath : input.sessionPath ?? null,
+    prUrl: typeof input.folded.record.prUrl === "string" ? input.folded.record.prUrl : null,
+    worktreePath: typeof input.folded.record.worktreePath === "string" ? input.folded.record.worktreePath : process.cwd(),
+    collabCwd: process.cwd(),
+    cwd: process.cwd(),
+    dispatchHandle: process.env.RIG_RUN_ID?.trim() ?? null,
+    pendingApprovals: input.folded.pendingApprovals.length,
+    pendingInputs: input.folded.pendingUserInputs.length,
+    steeringCount: input.folded.steeringCount,
+    stallCount: input.folded.stallCount,
+    ...typeof input.folded.record.errorText === "string" ? { errorSummary: input.folded.record.errorText } : { errorSummary: null },
+    timeline: [...timeline]
+  };
+}
+function textFromContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return null;
+  const text = content.map((part) => part && typeof part === "object" && ("text" in part) && typeof part.text === "string" ? part.text : "").filter(Boolean).join(`
+`).trim();
+  return text || null;
+}
+function textFromSessionEntry(entry) {
+  if (!entry || typeof entry !== "object")
+    return null;
+  const record = entry;
+  if (record.type === "custom_message")
+    return textFromContent(record.content);
+  if (record.type === "message")
+    return textFromAgentMessage(record.message);
+  return null;
+}
+function textFromAgentMessage(message) {
+  if (!message || typeof message !== "object")
+    return null;
+  return textFromContent(message.content);
+}
+function detectRunControlText(text, runId) {
+  const stop = parseStopSentinel(text, runId);
+  if (stop)
+    return { kind: "stop", reason: stop.reason };
+  if (parsePauseSentinel(text, runId))
+    return { kind: "pause" };
+  if (parseResumeSentinel(text, runId))
+    return { kind: "resume" };
+  const resolution = parseInboxResolutionSentinel(text, runId);
+  if (resolution)
+    return { kind: "inbox", resolution };
+  return null;
+}
+async function maybeStartRunProcessAutohost(api, ctx) {
+  if (process.env.RIG_RUN_PROCESS !== "1")
+    return null;
+  const envRunId = process.env.RIG_RUN_ID?.trim();
+  if (!envRunId)
+    throw new Error("RIG_RUN_ID is required when RIG_RUN_PROCESS=1");
+  const sessionManagerRunId = typeof ctx.sessionManager.getSessionId === "function" ? ctx.sessionManager.getSessionId().trim() : "";
+  const runId = sessionIdFromSessionFile(ctx.sessionManager.getSessionFile()) || sessionManagerRunId;
+  if (!runId)
+    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, {
+    entrypoint: "run-worker",
+    ...journal ? { journal: journal.kernel } : {}
+  });
+  if (!ctx.hasUI)
+    return null;
+  const collab = ctx.collab;
+  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 panelRegistry = await loadWorkerPanelRegistry(projectRoot);
+  let runProjection = projectRunFromSession(customEntries(ctx.sessionManager.getBranch()), runId);
+  const taskIdAtStart = process.env.RIG_TASK_ID?.trim() || runProjection.record.taskId;
+  const runDisplayTitle = (() => {
+    const base = process.env.RIG_RUN_TITLE?.trim() || `Rig run ${runId}`;
+    return taskIdAtStart && !base.includes(taskIdAtStart) ? `[${taskIdAtStart}] ${base}` : base;
+  })();
+  collab?.stopHost;
+  let closeoutStarted = false;
+  let forcedSteerUsed = false;
+  let lastRunActivityAt = Date.now();
+  const markRunActivity = () => {
+    lastRunActivityAt = Date.now();
+  };
+  let runRegistryHeartbeat = null;
+  let runRegistryRoomId = null;
+  let workerProjectionConnection = null;
+  let workerProjectionFiber = null;
+  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 });
+  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;
+  let pendingPause = false;
+  let pendingStopReason;
+  let cachedProjectionParts = null;
+  const currentProjectionParts = () => {
+    const branch = ctx.sessionManager.getBranch();
+    const lastBranchEntry = branch.at(-1);
+    const lastBranchObject = lastBranchEntry && typeof lastBranchEntry === "object" ? lastBranchEntry : null;
+    if (!cachedProjectionParts || cachedProjectionParts.branchLength !== branch.length || cachedProjectionParts.lastBranchEntry !== lastBranchObject) {
+      const entries = customEntries(branch);
+      cachedProjectionParts = {
+        branchLength: branch.length,
+        lastBranchEntry: lastBranchObject,
+        entries,
+        folded: projectRunFromSession(entries, runId),
+        timeline: latestTimelineEntriesFromCustomEntries(entries, REGISTRY_PROJECTION_TIMELINE_LIMIT)
+      };
+    }
+    runProjection = cachedProjectionParts.folded;
+    return { entries: cachedProjectionParts.entries, folded: cachedProjectionParts.folded, timeline: cachedProjectionParts.timeline };
+  };
+  const buildCurrentRegistryProjection = (links = runRegistryLinks) => {
+    const { entries, folded, timeline } = currentProjectionParts();
+    return registryRunProjection({
+      runId,
+      folded,
+      entries,
+      title: runDisplayTitle,
+      joinLink: links.joinLink,
+      webLink: links.webLink,
+      relayUrl: links.relayUrl,
+      sessionPath: ctx.sessionManager.getSessionFile(),
+      timeline
+    });
+  };
+  let lastRigPanelsSnapshotJson = "";
+  const publishRigPanelsSnapshot = async () => {
+    const appendCustomMessageEntry = ctx.sessionManager.appendCustomMessageEntry?.bind(ctx.sessionManager);
+    if (!appendCustomMessageEntry)
+      return;
+    const { folded } = currentProjectionParts();
+    const producerContext = {
+      projectRoot,
+      runId,
+      folded,
+      taskIdAtStart,
+      runDisplayTitle
+    };
+    const payloadEntries = await Promise.all(panelRegistry.producers.map(async (producer) => {
+      try {
+        const payload = await produceWorkerPanelPayload(producer, producerContext);
+        return payload === undefined ? null : [producer.id, payload];
+      } catch (error) {
+        console.error(`[rig-run] panel-producer-failed panel=${producer.id} ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+      }
+    }));
+    const payloads = Object.fromEntries(payloadEntries.filter((entry) => entry !== null));
+    const registrations = panelRegistry.registrations.map((panel) => ({
+      id: panel.id,
+      slot: panel.slot,
+      title: panel.title,
+      capabilityId: panel.capabilityId,
+      description: panel.description,
+      badge: panel.badge,
+      disabled: panel.disabled
+    }));
+    const activePanel = registrations.find((panel) => panel.id === RIG_SUPERVISOR_PANEL_ID2)?.id ?? registrations.find((panel) => !panel.disabled)?.id ?? registrations[0]?.id ?? null;
+    const frameBody = {
+      kind: "snapshot",
+      activePanel,
+      registrations,
+      payloads
+    };
+    const serialized = JSON.stringify(frameBody);
+    if (serialized === lastRigPanelsSnapshotJson)
+      return;
+    lastRigPanelsSnapshotJson = serialized;
+    appendCustomMessageEntry(RIG_PANELS_CUSTOM_MESSAGE_TYPE, "", false, { ...frameBody, updatedAt: new Date().toISOString() }, "agent");
+  };
+  const publishRigPanelsSnapshotBestEffort = () => {
+    publishRigPanelsSnapshot().catch((error) => {
+      console.error(`[rig-run] panel-snapshot-publish-failed ${error instanceof Error ? error.message : String(error)}`);
+    });
+  };
+  const pushWorkerProjection = (links = runRegistryLinks) => {
+    if (!workerProjectionConnection)
+      return;
+    workerProjectionConnection.push(buildCurrentRegistryProjection(links));
+  };
+  const publishRunProjection = async (status) => {
+    const projection = buildCurrentRegistryProjection();
+    if (workerProjectionConnection)
+      workerProjectionConnection.push(projection);
+    if (runRegistry && runRegistryRoomId) {
+      await runRegistry.heartbeatRoom(runRegistryRoomId, status, projection).catch((err) => console.error(`[rig-run] registry-heartbeat-failed ${err instanceof Error ? err.message : String(err)}`));
+    }
+    publishRigPanelsSnapshotBestEffort();
+  };
+  const stopRunRegistry = (opts = {}) => {
+    if (runRegistryHeartbeat) {
+      clearInterval(runRegistryHeartbeat);
+      runRegistryHeartbeat = null;
+    }
+    if (workerProjectionFiber) {
+      Effect.runFork(Fiber.interrupt(workerProjectionFiber));
+      workerProjectionFiber = null;
+    }
+    if (workerProjectionConnection) {
+      workerProjectionConnection.close();
+      workerProjectionConnection = null;
+    }
+    if ((opts.removeRoom ?? true) && runRegistry && runRegistryRoomId) {
+      runRegistry.removeRoom(runRegistryRoomId).catch(() => {});
+    }
+  };
+  const stopRunStallMonitor = startRunProcessStallMonitor({
+    journal,
+    lastActivityAt: () => lastRunActivityAt,
+    alreadyStalled: runProjection.stallCount > 0
+  });
+  const appendRunStatus = (status, reason, force = false) => {
+    journal?.appendStatus(status, { actor: OPERATOR_ACTOR, reason, force });
+  };
+  const applyInboxResolution = (resolution) => {
+    if (resolution.kind === "approval") {
+      journal?.appendApprovalResolved({
+        requestId: resolution.requestId,
+        decision: resolution.decision,
+        ...resolution.note !== undefined ? { note: resolution.note } : {},
+        actor: OPERATOR_ACTOR
+      });
+      journal?.appendTimeline({ type: "inbox-resolution", kind: "approval", requestId: resolution.requestId, decision: resolution.decision });
+      return;
+    }
+    journal?.appendInputResolved({ requestId: resolution.requestId, answers: resolution.answers, actor: OPERATOR_ACTOR });
+    journal?.appendTimeline({ type: "inbox-resolution", kind: "input", requestId: resolution.requestId });
+  };
+  const applyRunControlText = (text) => {
+    const control = detectRunControlText(text, runId);
+    if (!control)
+      return;
+    markRunActivity();
+    if (control.kind === "pause") {
+      pendingPause = true;
+      return;
+    }
+    if (control.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";
+      return;
+    }
+    applyInboxResolution(control.resolution);
+  };
+  const processRunControlMessages = () => {
+    for (const entry of ctx.sessionManager.getEntries?.() ?? []) {
+      const entryObject = entry && typeof entry === "object" ? entry : null;
+      const id = entryObject && typeof entryObject.id === "string" ? entryObject.id : null;
+      if (id && processedControlEntryIds.has(id))
+        continue;
+      if (!id && entryObject && processedControlEntryObjects.has(entryObject))
+        continue;
+      const text = textFromSessionEntry(entry);
+      if (id)
+        processedControlEntryIds.add(id);
+      else if (entryObject)
+        processedControlEntryObjects.add(entryObject);
+      if (text)
+        applyRunControlText(text);
+    }
+  };
+  let fatalTerminalPublishing = false;
+  const publishFatalTerminal = (error) => {
+    if (fatalTerminalPublishing)
+      return;
+    fatalTerminalPublishing = true;
+    const detail = error instanceof Error ? error.message : String(error);
+    journal?.appendStatus("failed", { actor: { kind: "agent" }, errorText: detail, force: true });
+    publishRunProjection("failed").catch((publishError) => {
+      console.error(`[rig-run] fatal-terminal-publish-failed ${publishError instanceof Error ? publishError.message : String(publishError)}`);
+    }).finally(() => {
+      stopRunStallMonitor();
+      stopRunRegistry({ removeRoom: false });
+      process.exitCode = 1;
+      setTimeout(() => process.exit(1), 0);
+    });
+  };
+  process.once("uncaughtException", publishFatalTerminal);
+  process.once("unhandledRejection", publishFatalTerminal);
+  const handlePanelAction = async (input) => {
+    if (input.actionId !== RIG_RUN_STOP_PANEL_ACTION2 && input.actionId !== "stop-supervisor") {
+      throw new Error(`Unsupported Rig panel action: ${input.actionId}`);
+    }
+    pendingStopReason = `operator ${input.from.name} requested stop`;
+    journal?.appendTimeline({ type: "interrupted", stage: "panel-action", status: "running", detail: pendingStopReason });
+    ctx.abort();
+    await publishRunProjection("running");
+  };
+  const startRunCollabHost = async () => {
+    try {
+      const projection = await startHost.call(collab, {
+        title: runDisplayTitle,
+        ...identity?.owner ? { owner: identity.owner } : {},
+        ...identity?.selectedRepo ? { selectedRepo: identity.selectedRepo } : {},
+        relayUrl: rigRelayUrl(),
+        onPanelAction: handlePanelAction
+      });
+      const roomId = projection.sessionId?.trim() || runId;
+      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() };
+      const timeline = {
+        type: "collab-host-started",
+        roomId,
+        joinLink: projection.joinLink,
+        webLink: projection.webLink,
+        relayUrl: projection.relayUrl
+      };
+      journal?.appendTimeline(timeline);
+      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) {
+        try {
+          runRegistryRoomId = roomId;
+          const initialProjection = buildCurrentRegistryProjection();
+          await runRegistry.registerRoom({
+            roomId,
+            owner: runRegistryOwner,
+            repo: runRegistryRepo,
+            title: runDisplayTitle,
+            status: "running",
+            joinLink: projection.joinLink ?? "",
+            webLink: projection.webLink ?? "",
+            relayUrl: projection.relayUrl ?? rigRelayUrl(),
+            startedAt: new Date().toISOString(),
+            cwd: process.cwd(),
+            sessionPath: ctx.sessionManager.getSessionFile() ?? undefined,
+            pid: process.pid,
+            projection: initialProjection
+          });
+          workerProjectionConnection = 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()))));
+          journal?.appendTimeline({ type: "registry-registered", roomId });
+          console.log(`[rig-run] registry-registered roomId=${roomId}`);
+          runRegistryHeartbeat = setInterval(() => {
+            const heartbeatProjection = buildCurrentRegistryProjection();
+            runRegistry.heartbeatRoom(roomId, coerceRegistryStatus(heartbeatProjection.status, "running"), heartbeatProjection).catch((err) => console.error(`[rig-run] registry-heartbeat-failed ${err instanceof Error ? err.message : String(err)}`));
+          }, 15000);
+          if (typeof runRegistryHeartbeat.unref === "function")
+            runRegistryHeartbeat.unref();
+        } catch (error) {
+          console.error(`[rig-run] registry-register-failed ${error instanceof Error ? error.message : String(error)}`);
+          ctx.ui.notify("Rig run could not register to the discovery registry; it may not appear in Runs.", "warning");
+        }
+      }
+      return true;
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("Collab host session id mismatch:")) {
+        publishFatalTerminal(error);
+        return false;
+      }
+      console.error(`[rig-run] collab-host-start-failed ${error instanceof Error ? error.message : String(error)}`);
+      ctx.ui.notify("Rig run collab host could not reach the relay; session remains local.", "warning");
+      return true;
+    }
+  };
+  journal?.appendTimeline({ type: "stage", stage: "Connect", status: "running", detail: "run process session_start" });
+  journal?.appendTimeline({ type: "stage", stage: "Prepare", status: "completed", detail: "run process prepared" });
+  journal?.appendStatus("running", { actor: { kind: "agent" }, reason: "run process session started", force: true });
+  if (!await startRunCollabHost())
+    return null;
+  if (taskIdAtStart) {
+    journal?.appendTimeline({ type: "stage", stage: "GitHub-sync", status: "running", detail: "reflecting rig:running to task source" });
+    try {
+      await updateRunTaskSourceLifecycle(projectRoot, {
+        runId,
+        taskId: taskIdAtStart,
+        sourceTask: runProjection.record.sourceTask,
+        worktreePath: process.cwd(),
+        logRoot: runProjection.record.logRoot ?? null,
+        sessionPath: runProjection.record.sessionPath ?? null
+      }, "running", "Rig started work on this task.");
+      journal?.appendTimeline({ type: "stage", stage: "GitHub-sync", status: "completed", detail: "reflected running" });
+    } catch (error) {
+      journal?.appendTimeline({ type: "stage", stage: "GitHub-sync", status: "failed", detail: error instanceof Error ? error.message : String(error) });
+      console.error(`[rig-run] running-reflection-failed ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const steerPi = async (message) => {
+    journal?.appendTimeline({ type: "closeout-steer", message });
+    api.sendUserMessage(message, { deliverAs: "steer" });
+  };
+  const agentEnd = async (event) => {
+    markRunActivity();
+    processRunControlMessages();
+    for (const message of event.messages) {
+      const text = textFromAgentMessage(message);
+      if (text)
+        applyRunControlText(text);
+    }
+    const aborted = event.messages.some((message) => message.role === "assistant" && message.stopReason === "aborted");
+    if (pendingStopReason !== undefined) {
+      const reason = pendingStopReason ?? "operator requested stop";
+      pendingStopReason = undefined;
+      closeoutStarted = true;
+      journal?.appendTimeline({ type: "interrupted", stage: "stopped", status: "stopped", detail: reason });
+      journal?.appendStatus("stopped", { actor: OPERATOR_ACTOR, reason, force: true });
+      if (taskIdAtStart) {
+        journal?.appendTimeline({ type: "stage", stage: "Task-source", status: "running", detail: "reflecting operator stop to task source" });
+        try {
+          await reflectStoppedRunTaskSource({
+            projectRoot,
+            runId,
+            taskId: taskIdAtStart,
+            sourceTask: runProjection.record.sourceTask,
+            worktreePath: process.cwd(),
+            logRoot: runProjection.record.logRoot ?? null,
+            sessionPath: runProjection.record.sessionPath ?? null,
+            reason
+          });
+          journal?.appendTimeline({ type: "stage", stage: "Task-source", status: "completed", detail: "reflected operator stop" });
+        } catch (error) {
+          const detail = error instanceof Error ? error.message : String(error);
+          journal?.appendTimeline({ type: "stage", stage: "Task-source", status: "failed", detail });
+          console.error(`[rig-run] stopped-reflection-failed ${detail}`);
+        }
+      }
+      await publishRunProjection("stopped");
+      stopRunStallMonitor();
+      stopRunRegistry({ removeRoom: false });
+      process.exitCode = 0;
+      setTimeout(() => process.exit(0), 0);
+      return;
+    }
+    if (aborted) {
+      if (pendingPause) {
+        pendingPause = false;
+        appendRunStatus("paused", "operator paused run", true);
+        journal?.appendTimeline({ type: "interrupted", stage: "paused", status: "paused", detail: "operator paused run; parked for native collab resume" });
+        await publishRunProjection("paused");
+        return;
+      }
+      journal?.appendTimeline({ type: "interrupted", stage: "aborted", status: "running", detail: "operator interrupted run without a Rig control sentinel" });
+      return;
+    }
+    if (closeoutStarted)
+      return;
+    if (process.env.RIG_RUN_FORCE_STEER_ONCE === "1" && !forcedSteerUsed) {
+      forcedSteerUsed = true;
+      journal?.appendTimeline({ type: "force-steer-once-started" });
+      await steerPi("now reply with the word FIXED");
+      journal?.appendTimeline({ type: "force-steer-once-completed" });
+    }
+    closeoutStarted = true;
+    runProjection = projectRunFromSession(customEntries(ctx.sessionManager.getBranch()), runId);
+    const taskId = process.env.RIG_TASK_ID?.trim() || runProjection.record.taskId;
+    if (!taskId) {
+      const reason = "missing task id for closeout";
+      journal?.appendTimeline({ type: "closeout-skipped", reason: "missing-task-id" });
+      journal?.appendStatus("failed", { actor: { kind: "agent" }, reason, errorText: reason, force: true });
+      await publishRunProjection("failed");
+      stopRunStallMonitor();
+      stopRunRegistry({ removeRoom: false });
+      process.exitCode = 1;
+      setTimeout(() => process.exit(1), 0);
+      return;
+    }
+    const { command, gitCommand } = createEnvCloseoutRunners(process.env);
+    let closeoutStatusAdvanced = false;
+    try {
+      await runPipelineCloseout({
+        projectRoot,
+        runId,
+        taskId,
+        branch: runProjection.record.branch ?? `rig/${taskId}-${runId}`,
+        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 });
+          await publishRunProjection("validating");
+        },
+        kernelJournal: journal?.kernel ?? null,
+        journalPhase: async (phase, outcome, detail) => {
+          journal?.appendCloseoutPhase({ phase, outcome, detail: detail ?? null });
+          if (!closeoutStatusAdvanced && phase !== "queued" && outcome === "started") {
+            closeoutStatusAdvanced = true;
+            journal?.appendStatus("closing-out", { actor: { kind: "agent" }, reason: "validation passed; running closeout automation", force: true });
+            await publishRunProjection("closing-out");
+          }
+        },
+        reflect: async (status, summary, opts) => {
+          await updateRunTaskSourceLifecycle(projectRoot, {
+            runId,
+            taskId,
+            sourceTask: runProjection.record.sourceTask,
+            worktreePath: process.cwd(),
+            logRoot: runProjection.record.logRoot ?? null,
+            sessionPath: runProjection.record.sessionPath ?? null
+          }, status, summary, opts);
+        }
+      });
+      journal?.appendStatus("completed", { actor: { kind: "agent" }, reason: "closeout completed" });
+      await publishRunProjection("completed");
+      await dispatchRunNotifications(projectRoot, runId, taskId, "completed", "closeout completed");
+      stopRunStallMonitor();
+      stopRunRegistry({ removeRoom: false });
+      process.exitCode = 0;
+      setTimeout(() => process.exit(0), 0);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      const status = error instanceof CloseoutValidationError ? "needs-attention" : "failed";
+      journal?.appendStatus(status, { actor: { kind: "agent" }, errorText: detail, force: true });
+      await publishRunProjection(status);
+      await dispatchRunNotifications(projectRoot, runId, taskId, "failed", detail);
+      stopRunStallMonitor();
+      stopRunRegistry({ removeRoom: false });
+      process.exitCode = 1;
+      setTimeout(() => process.exit(1), 0);
+    }
+  };
+  const handleRunActivity = () => {
+    markRunActivity();
+    processRunControlMessages();
+  };
+  return { beforeAgentStart: handleRunActivity, messageStart: handleRunActivity, agentEnd };
+}
+async function maybeStartSpikeAutohost(ctx) {
+  if (process.env.RIG_SPIKE_AUTOHOST !== "1")
+    return;
+  const relayUrl = process.env.RIG_SPIKE_RELAY?.trim();
+  if (!relayUrl)
+    throw new Error("RIG_SPIKE_RELAY is required when RIG_SPIKE_AUTOHOST=1");
+  const collab = ctx.collab;
+  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);
+  await startHost.call(collab, {
+    relayUrl,
+    title: "Rig detached PTY spike",
+    ...identity?.owner ? { owner: identity.owner } : {},
+    ...identity?.selectedRepo ? { selectedRepo: identity.selectedRepo } : {}
+  });
+}
+var REGISTRY_PROJECTION_TIMELINE_LIMIT = 100, OPERATOR_ACTOR;
+var init_autohost = __esm(() => {
+  init_journal();
+  init_notifications();
+  init_stall();
+  init_panel_plugin();
+  init_utils();
+  OPERATOR_ACTOR = { kind: "operator" };
+});
+
+// packages/run-worker/src/extension.ts
+var exports_extension = {};
+__export(exports_extension, {
+  default: () => rigWorkerExtension,
+  __rigRunWorkerTest: () => __rigRunWorkerTest,
+  __rigExtensionTest: () => __rigExtensionTest
+});
+function rigWorkerExtension(api) {
+  let hooks = null;
+  api.on("session_start", async (_event, ctx) => {
+    hooks = await maybeStartRunProcessAutohost(api, ctx);
+    await maybeStartSpikeAutohost(ctx);
+  });
+  api.on("before_agent_start", () => {
+    hooks?.beforeAgentStart();
+  });
+  api.on("message_start", () => {
+    hooks?.messageStart();
+  });
+  api.on("agent_end", async (event) => {
+    await hooks?.agentEnd(event);
+  });
+}
+var __rigRunWorkerTest, __rigExtensionTest;
+var init_extension = __esm(() => {
+  init_autohost();
+  init_stall();
+  __rigRunWorkerTest = {
+    computeRunStall,
+    appendRunStallDetected,
+    detectRunControlText
+  };
+  __rigExtensionTest = __rigRunWorkerTest;
+});
+
+// packages/run-worker/src/plugin.ts
+import { definePlugin } from "@rig/core/config";
+var runWorkerPlugin = definePlugin({
+  name: "@rig/run-worker",
+  version: "0.0.0-alpha.1",
+  contributes: {
+    sessionExtensions: [
+      {
+        id: "rig:run-worker",
+        description: "Rig run lifecycle worker (plan\u2192implement\u2192validate\u2192commit\u2192PR\u2192merge\u2192closeout).",
+        install: async (api) => {
+          const { default: rigWorkerExtension2 } = await Promise.resolve().then(() => (init_extension(), exports_extension));
+          rigWorkerExtension2(api);
+        }
+      }
+    ]
+  }
+});
+function createRunWorkerPlugin() {
+  return runWorkerPlugin;
+}
+export {
+  runWorkerPlugin,
+  createRunWorkerPlugin
+};