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

package/dist/src/worker/extension.js

@@ -0,0 +1,881 @@
+// @bun
+// packages/run-plugin/src/worker/autohost.ts
+import {
+  PLACEMENT_RUN_TRANSPORT,
+  RIG_RUN_STOP_PANEL_ACTION as RIG_RUN_STOP_PANEL_ACTION2,
+  RUN_IDENTITY_ENV,
+  RUN_REGISTRY_BACKBONE,
+  LIFECYCLE_VERIFICATION_SERVICE,
+  RUN_READ_MODEL,
+  RUN_SESSION_JOURNAL,
+  RUN_SESSION_JOURNAL_WRITER,
+  TRANSPORT_CONFIG,
+  GITHUB_CLI,
+  GITHUB_TOKEN_RESOLVER,
+  REPO_CHANGE_SET,
+  REPO_GIT_WORKFLOW,
+  REPO_NATIVE_GIT,
+  TASK_ARTIFACTS,
+  TASK_SOURCE_REFLECTION,
+  TASK_STATE_STORE
+} from "@rig/contracts";
+import { Duration, Effect as Effect2, Fiber, Stream as Stream2 } from "effect";
+import { defineCapability as defineCapability2, defineServiceCapability } from "@rig/core/capability";
+import { installCapability, loadCapabilityForRoot, requireInstalledCapability } from "@rig/core/capability-loaders";
+import { adopt as adoptRunWorkerKernel } from "@rig/core/kernel-entrypoint";
+
+// packages/run-plugin/src/worker/local-run-changes.ts
+import { existsSync, mkdirSync, watch } from "fs";
+import { dirname, resolve } from "path";
+import { Effect, Queue, Stream } from "effect";
+function findNearestGitCheckoutRoot(startDir) {
+  let current = resolve(startDir);
+  for (;; ) {
+    if (existsSync(resolve(current, ".git")))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function resolveCheckoutRoot(projectRoot) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve(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 = resolve(resolveCheckoutRoot(projectRoot), ".worktrees");
+  if (!existsSync(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-plugin/src/worker/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-plugin/src/worker/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-plugin/src/worker/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((resolve2) => {
+        timeout = setTimeout(() => resolve2(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-plugin/src/worker/constants.ts
+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.";
+
+// packages/run-plugin/src/worker/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);
+}
+
+// packages/run-plugin/src/worker/utils.ts
+import { RIG_WORKFLOW_STATUS_CHANGED } from "@rig/contracts";
+import { rigProjectRootFromEnv } from "@rig/core/root-resolver";
+function customEntries(entries) {
+  const customs = [];
+  for (const entry of entries) {
+    if (entry.type === "custom")
+      customs.push(entry);
+  }
+  return customs;
+}
+
+// packages/run-plugin/src/worker/autohost.ts
+var GitHubCliCap = defineCapability2(GITHUB_CLI);
+var GitHubTokenResolverCap = defineCapability2(GITHUB_TOKEN_RESOLVER);
+var RepoChangeSetCap = defineCapability2(REPO_CHANGE_SET);
+var RepoGitWorkflowCap = defineCapability2(REPO_GIT_WORKFLOW);
+var RepoNativeGitCap = defineCapability2(REPO_NATIVE_GIT);
+var TaskArtifactsCap = defineCapability2(TASK_ARTIFACTS);
+var TaskStateStoreCap = defineCapability2(TASK_STATE_STORE);
+var PlacementTransportCap = defineCapability2(PLACEMENT_RUN_TRANSPORT);
+var RunIdentityEnvCap = defineCapability2(RUN_IDENTITY_ENV);
+var RunRegistryBackboneCap = defineCapability2(RUN_REGISTRY_BACKBONE);
+var RunReadModelCap = defineCapability2(RUN_READ_MODEL);
+var RunSessionJournalCap = defineCapability2(RUN_SESSION_JOURNAL);
+var RunSessionJournalWriterCap = defineCapability2(RUN_SESSION_JOURNAL_WRITER);
+var LifecycleVerificationServiceCap = defineServiceCapability(LIFECYCLE_VERIFICATION_SERVICE);
+var TransportConfigCap = defineCapability2(TRANSPORT_CONFIG);
+var TaskSourceReflectionCap = defineCapability2(TASK_SOURCE_REFLECTION);
+async function resolveRunRegistryNamespace(projectRoot, identityNamespaceKey) {
+  if (identityNamespaceKey)
+    return identityNamespaceKey;
+  const transportConfig = await loadCapabilityForRoot(projectRoot, TransportConfigCap);
+  return transportConfig?.resolveOwnerNamespaceKey({ projectRoot }) ?? "anonymous";
+}
+function syntheticRegistryOwner(namespaceKey) {
+  const githubUserId = namespaceKey.startsWith("gh:") ? namespaceKey.slice(3) : namespaceKey;
+  return {
+    githubUserId: githubUserId || "anonymous",
+    login: "anonymous",
+    namespaceKey
+  };
+}
+var REGISTRY_PROJECTION_TIMELINE_LIMIT = 100;
+var OPERATOR_ACTOR = { kind: "operator" };
+var REGISTRY_SECRET_LINK_FIELDS = new Set(["joinLink", "webLink"]);
+function sanitizeRegistryProjectionValue(value) {
+  if (Array.isArray(value))
+    return value.map(sanitizeRegistryProjectionValue);
+  if (!value || typeof value !== "object")
+    return value;
+  const sanitized = {};
+  for (const [key, child] of Object.entries(value)) {
+    sanitized[key] = REGISTRY_SECRET_LINK_FIELDS.has(key) ? null : sanitizeRegistryProjectionValue(child);
+  }
+  return sanitized;
+}
+function sanitizeRegistryProjection(projection) {
+  return sanitizeRegistryProjectionValue(projection);
+}
+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(codec, text, runId) {
+  const stop = codec.parseStopSentinel(text, runId);
+  if (stop)
+    return { kind: "stop", reason: stop.reason };
+  if (codec.parsePauseSentinel(text, runId))
+    return { kind: "pause" };
+  if (codec.parseResumeSentinel(text, runId))
+    return { kind: "resume" };
+  const resolution = codec.parseInboxResolutionSentinel(text, runId);
+  if (resolution)
+    return { kind: "inbox", resolution };
+  return null;
+}
+async function installIfResolved(projectRoot, capability) {
+  const impl = await loadCapabilityForRoot(projectRoot, capability);
+  if (impl)
+    installCapability(capability, impl);
+}
+async function installRunWorkerSemanticCapabilities(projectRoot) {
+  await installIfResolved(projectRoot, GitHubCliCap);
+  await installIfResolved(projectRoot, GitHubTokenResolverCap);
+  await installIfResolved(projectRoot, RepoChangeSetCap);
+  await installIfResolved(projectRoot, RepoGitWorkflowCap);
+  await installIfResolved(projectRoot, RepoNativeGitCap);
+  await installIfResolved(projectRoot, TaskArtifactsCap);
+  await installIfResolved(projectRoot, TaskStateStoreCap);
+}
+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 projectRoot = process.env.PROJECT_RIG_ROOT ?? process.cwd();
+  const sessionJournal = await loadCapabilityForRoot(projectRoot, RunSessionJournalCap);
+  if (!sessionJournal) {
+    throw new Error("RUN_SESSION_JOURNAL capability unavailable in run-worker autohost: ensure @rig/run-plugin (default bundle) is installed.");
+  }
+  installCapability(RunSessionJournalCap, sessionJournal);
+  const sessionManagerRunId = typeof ctx.sessionManager.getSessionId === "function" ? ctx.sessionManager.getSessionId().trim() : "";
+  const runId = sessionJournal.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.");
+  await installRunWorkerSemanticCapabilities(projectRoot);
+  const verificationService = await loadCapabilityForRoot(projectRoot, LifecycleVerificationServiceCap);
+  if (verificationService) {
+    installCapability(LifecycleVerificationServiceCap, verificationService);
+  }
+  const taskSourceReflectionService = await loadCapabilityForRoot(projectRoot, TaskSourceReflectionCap);
+  const journalWriter = await loadCapabilityForRoot(projectRoot, RunSessionJournalWriterCap);
+  if (!journalWriter) {
+    throw new Error("RUN_SESSION_JOURNAL_WRITER capability unavailable in run-worker autohost: ensure @rig/run-plugin is installed.");
+  }
+  installCapability(RunSessionJournalWriterCap, journalWriter);
+  const journal = await journalWriter.createRunJournal(ctx.sessionManager, runId);
+  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)
+    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 identityEnv = await loadCapabilityForRoot(projectRoot, RunIdentityEnvCap);
+  const identity = identityEnv?.resolveRigIdentity(ctx) ?? null;
+  const runReadModel = await loadCapabilityForRoot(projectRoot, RunReadModelCap);
+  if (!runReadModel) {
+    throw new Error("RUN_READ_MODEL capability unavailable in run-worker autohost: ensure @rig/run-plugin (default bundle) is installed.");
+  }
+  const registryBackbone = await loadCapabilityForRoot(projectRoot, RunRegistryBackboneCap);
+  if (registryBackbone)
+    installCapability(RunRegistryBackboneCap, registryBackbone);
+  const panelRegistry = await loadWorkerPanelRegistry(projectRoot);
+  let cachedProjectionParts = null;
+  const currentProjectionEntries = () => {
+    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
+      };
+    }
+    return cachedProjectionParts.entries;
+  };
+  let runProjection = runReadModel.buildSessionProjection({ runId, entries: currentProjectionEntries() });
+  const buildWorkerBootstrapProjection = () => {
+    runProjection = runReadModel.buildSessionProjection({ runId, entries: currentProjectionEntries() });
+    return runProjection;
+  };
+  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 projectRootForTransport = rigProjectRootFromEnv();
+  const transportConfig = await loadCapabilityForRoot(projectRootForTransport, TransportConfigCap);
+  const runRegistryNamespace = await resolveRunRegistryNamespace(projectRootForTransport, identity?.owner?.namespaceKey);
+  const runRegistryBaseUrl = transportConfig?.resolveRegistryBaseUrl({ projectRoot: projectRootForTransport }) ?? "";
+  const runRelayUrl = transportConfig?.resolveRelayUrl() ?? "";
+  const runRegistryOwner = identity?.owner ?? syntheticRegistryOwner(runRegistryNamespace);
+  const runRegistryRepo = identity?.selectedRepo ?? "";
+  const runRegistry = registryBackbone?.createRegistryClient({ baseUrl: runRegistryBaseUrl, 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;
+  let pendingPause = false;
+  let pendingStopReason;
+  const buildCurrentRegistryProjection = (links = runRegistryLinks) => {
+    const entries = currentProjectionEntries();
+    const cwd = process.cwd();
+    const projectionInput = {
+      runId,
+      entries,
+      title: runDisplayTitle,
+      taskId: taskIdAtStart ?? null,
+      joinLink: links.joinLink ?? null,
+      webLink: links.webLink ?? null,
+      relayUrl: links.relayUrl ?? null,
+      sessionPath: ctx.sessionManager.getSessionFile() ?? null,
+      cwd,
+      collabCwd: cwd,
+      dispatchHandle: process.env.RIG_RUN_ID?.trim() || null,
+      timelineLimit: REGISTRY_PROJECTION_TIMELINE_LIMIT
+    };
+    return sanitizeRegistryProjection(runReadModel.buildRegistryProjection(projectionInput));
+  };
+  let lastRigPanelsSnapshotJson = "";
+  const publishRigPanelsSnapshot = async () => {
+    const appendCustomMessageEntry = ctx.sessionManager.appendCustomMessageEntry?.bind(ctx.sessionManager);
+    if (!appendCustomMessageEntry)
+      return;
+    const folded = buildWorkerBootstrapProjection();
+    const producerContext = {
+      projectRoot,
+      runId,
+      folded,
+      ...taskIdAtStart !== undefined ? { 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 frameBody = {
+      kind: "snapshot",
+      activePanel: null,
+      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) {
+      Effect2.runFork(Fiber.interrupt(workerProjectionFiber));
+      workerProjectionFiber = null;
+    }
+    if (workerProjectionConnection) {
+      workerProjectionConnection.close();
+      workerProjectionConnection = null;
+    }
+    if ((opts.removeRoom ?? true) && registryBackbone && runRegistryRoomId) {
+      registryBackbone.removeRoom({ baseUrl: runRegistryBaseUrl, namespaceKey: runRegistryNamespace }, 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(sessionJournal, 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: runRelayUrl,
+        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 ?? null, webLink: projection.webLink ?? null, relayUrl: projection.relayUrl ?? runRelayUrl };
+      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 ? "(redacted)" : "(empty)"} relayUrl=${projection.relayUrl || "(empty)"}`);
+      ctx.ui.notify("Rig run collab host started.", "info");
+      publishRigPanelsSnapshotBestEffort();
+      if (!runRegistry || !registryBackbone) {
+        const detail = "Rig run discovery registry is unavailable.";
+        console.error(`[rig-run] registry-unavailable ${detail}`);
+        journal?.appendTimeline({ type: "registry-register-failed", status: "failed", detail });
+        ctx.ui.notify("Rig run discovery registry is unavailable; failing run.", "error");
+        publishFatalTerminal(new Error(detail));
+        return false;
+      }
+      if (runRegistry && registryBackbone) {
+        try {
+          runRegistryRoomId = roomId;
+          const initialProjection = buildCurrentRegistryProjection();
+          const sessionPath = ctx.sessionManager.getSessionFile();
+          await registryBackbone.registerRoom({ baseUrl: runRegistryBaseUrl, namespaceKey: runRegistryNamespace }, {
+            roomId,
+            owner: runRegistryOwner,
+            repo: runRegistryRepo,
+            title: runDisplayTitle,
+            status: "running",
+            joinLink: projection.joinLink ?? "",
+            webLink: projection.webLink ?? "",
+            relayUrl: projection.relayUrl ?? runRelayUrl,
+            startedAt: new Date().toISOString(),
+            cwd: process.cwd(),
+            ...sessionPath ? { sessionPath } : {},
+            pid: process.pid,
+            projection: initialProjection
+          });
+          workerProjectionConnection = registryBackbone.connectWorkerProjection({ baseUrl: runRegistryBaseUrl, 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 = 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(() => {
+            const heartbeatProjection = buildCurrentRegistryProjection();
+            runRegistry.heartbeatRoom(roomId, registryBackbone.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) {
+          const cause = error instanceof Error ? error.message : String(error);
+          const detail = `Rig run discovery registry registration failed: ${cause}`;
+          console.error(`[rig-run] registry-register-failed ${detail}`);
+          journal?.appendTimeline({ type: "registry-register-failed", status: "failed", detail });
+          ctx.ui.notify("Rig run could not register to the discovery registry; failing run.", "error");
+          publishFatalTerminal(new Error(detail));
+          return false;
+        }
+      }
+      return true;
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      console.error(`[rig-run] collab-host-start-failed ${detail}`);
+      ctx.ui.notify("Rig run collab host could not reach the relay; failing run.", "error");
+      publishFatalTerminal(error);
+      return false;
+    }
+  };
+  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 run start to task source" });
+    try {
+      await taskSourceReflectionService?.reflectRunStarted(projectRoot, {
+        runId,
+        taskId: taskIdAtStart,
+        ...runProjection.record.sourceTask !== undefined ? { sourceTask: runProjection.record.sourceTask } : {},
+        worktreePath: process.cwd(),
+        logRoot: runProjection.record.logRoot ?? null,
+        sessionPath: runProjection.record.sessionPath ?? null
+      });
+      journal?.appendTimeline({ type: "stage", stage: "GitHub-sync", status: "completed", detail: "reflected run start" });
+    } catch (error) {
+      journal?.appendTimeline({ type: "stage", stage: "GitHub-sync", status: "failed", detail: error instanceof Error ? error.message : String(error) });
+      console.error(`[rig-run] start-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 run stop to task source" });
+        try {
+          await taskSourceReflectionService?.reflectRunStopped(projectRoot, {
+            runId,
+            taskId: taskIdAtStart,
+            ...runProjection.record.sourceTask !== undefined ? { 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 run 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;
+    buildWorkerBootstrapProjection();
+    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;
+    }
+    let closeoutStatusAdvanced = false;
+    try {
+      await requireInstalledCapability(LifecycleVerificationServiceCap, "run-closeout capability unavailable in run-worker autohost: ensure @rig/lifecycle-plugin (default bundle) is installed.").closeout({
+        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,
+        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 taskSourceReflectionService?.updateRunTaskSourceLifecycle(projectRoot, {
+            runId,
+            taskId,
+            ...runProjection.record.sourceTask !== undefined ? { 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 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);
+      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 = (await loadCapabilityForRoot(rigProjectRootFromEnv(), RunIdentityEnvCap))?.resolveRigIdentity(ctx) ?? null;
+  await startHost.call(collab, {
+    relayUrl,
+    title: "Rig detached PTY spike",
+    ...identity?.owner ? { owner: identity.owner } : {},
+    ...identity?.selectedRepo ? { selectedRepo: identity.selectedRepo } : {}
+  });
+}
+
+// packages/run-plugin/src/worker/extension.ts
+var __rigRunWorkerTest = {
+  computeRunStall,
+  appendRunStallDetected,
+  detectRunControlText
+};
+var __rigExtensionTest = __rigRunWorkerTest;
+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);
+  });
+}
+export {
+  rigWorkerExtension as default,
+  __rigRunWorkerTest,
+  __rigExtensionTest
+};