@h-rig/run-worker 0.0.6-alpha.130

package/dist/src/index.js

@@ -0,0 +1,629 @@
+// @bun
+// packages/run-worker/src/autohost.ts
+import { latestTimelineEntriesFromCustomEntries, parseInboxResolutionSentinel, parsePauseSentinel, parseResumeSentinel, parseStopSentinel, sessionIdFromSessionFile } from "@rig/contracts";
+import { Duration, Effect, Fiber, Stream } from "effect";
+import { createEnvCloseoutRunners } from "@rig/runtime/control-plane/native/closeout-runners";
+import { CloseoutValidationError, runInProcessCloseout } from "@rig/runtime/control-plane/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";
+
+// packages/run-worker/src/journal.ts
+import { RunSessionJournal } from "@rig/runtime/control-plane/run-session-writer";
+async function createRunJournal(sessionManager, runId) {
+  try {
+    return new RunSessionJournal(sessionManager, runId);
+  } catch (error) {
+    console.warn(`[rig-run] RunSessionJournal unavailable; run-state arming deferred: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+
+// packages/run-worker/src/notifications.ts
+import { resolve } from "path";
+import { dispatchEventToTargets, loadNotificationConfig } from "@rig/runtime/control-plane/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.";
+
+// 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);
+}
+
+// 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();
+}
+
+// packages/run-worker/src/autohost.ts
+var REGISTRY_PROJECTION_TIMELINE_LIMIT = 100;
+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]
+  };
+}
+var OPERATOR_ACTOR = { kind: "operator" };
+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 runId = sessionIdFromSessionFile(ctx.sessionManager.getSessionFile()) ?? envRunId;
+  console.log(`[rig-run] session_start hasUI=${ctx.hasUI ? "true" : "false"}`);
+  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 journal = await createRunJournal(ctx.sessionManager, runId);
+  const projectRoot = process.env.PROJECT_RIG_ROOT ?? process.cwd();
+  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()) ?? null;
+  const runRegistry = runRegistryNamespace ? 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;
+  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
+    });
+  };
+  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)}`));
+    }
+  };
+  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 startRunCollabHost = async () => {
+    try {
+      const projection = await startHost.call(collab, {
+        title: runDisplayTitle,
+        ...identity?.owner ? { owner: identity.owner } : {},
+        ...identity?.selectedRepo ? { selectedRepo: identity.selectedRepo } : {},
+        relayUrl: rigRelayUrl()
+      });
+      runRegistryLinks = { joinLink: projection.joinLink, webLink: projection.webLink, relayUrl: projection.relayUrl ?? rigRelayUrl() };
+      const timeline = {
+        type: "collab-host-started",
+        roomId: projection.sessionId,
+        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");
+      if (runRegistry && identity?.owner) {
+        try {
+          runRegistryRoomId = projection.sessionId;
+          const initialProjection = buildCurrentRegistryProjection();
+          await runRegistry.registerRoom({
+            roomId: projection.sessionId,
+            owner: identity.owner,
+            repo: identity.selectedRepo ?? "",
+            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: projection.sessionId });
+          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: projection.sessionId });
+          console.log(`[rig-run] registry-registered roomId=${projection.sessionId}`);
+          runRegistryHeartbeat = setInterval(() => {
+            const heartbeatProjection = buildCurrentRegistryProjection();
+            runRegistry.heartbeatRoom(projection.sessionId, 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");
+        }
+      } else {
+        console.error(`[rig-run] registry-skip namespace=${runRegistryNamespace ? "set" : "MISSING"}`);
+        ctx.ui.notify("Rig run NOT registered (registry namespace missing) \u2014 it won't appear in Runs.", "warning");
+      }
+    } catch (error) {
+      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");
+    }
+  };
+  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 });
+  await startRunCollabHost();
+  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 });
+      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 runInProcessCloseout({
+        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");
+        },
+        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 } : {}
+  });
+}
+
+// packages/run-worker/src/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 {
+  timestampMs,
+  startRunProcessStallMonitor,
+  registryRunProjection,
+  maybeStartSpikeAutohost,
+  maybeStartRunProcessAutohost,
+  dispatchRunNotifications,
+  detectRunControlText,
+  rigWorkerExtension as default,
+  createRunJournal,
+  computeRunStall,
+  appendRunStallDetected,
+  __rigRunWorkerTest,
+  __rigExtensionTest,
+  TRACKED_RUN_STALL_MS,
+  RUN_PROCESS_STEER_TIMEOUT_MS,
+  RUN_PROCESS_STALL_SWEEP_MS,
+  RUN_PROCESS_STALL_DETAIL,
+  REGISTRY_PROJECTION_TIMELINE_LIMIT
+};

package/dist/src/journal.d.ts

@@ -0,0 +1,31 @@
+import type { ExtensionContext } from "@oh-my-pi/pi-coding-agent";
+import type { ApprovalDecision, RunActor, RunCloseoutPhase, RunCloseoutPhaseOutcome, RunStatus } from "@rig/contracts";
+export type RunJournal = {
+    appendStatus(to: RunStatus, opts?: {
+        reason?: string | null;
+        actor?: RunActor;
+        errorText?: string | null;
+        force?: boolean;
+    }): void;
+    appendTimeline(payload: unknown): void;
+    appendCloseoutPhase(input: {
+        phase: RunCloseoutPhase;
+        outcome: RunCloseoutPhaseOutcome;
+        detail?: string | null;
+    }): void;
+    appendApprovalResolved(input: {
+        requestId: string;
+        decision: ApprovalDecision;
+        note?: string | null;
+        actor: RunActor;
+    }): void;
+    appendInputResolved(input: {
+        requestId: string;
+        answers: Record<string, string>;
+        actor: RunActor;
+    }): void;
+    appendStall(input: {
+        detail: string;
+    }): void;
+};
+export declare function createRunJournal(sessionManager: ExtensionContext["sessionManager"], runId: string): Promise<RunJournal | null>;

package/dist/src/journal.js

@@ -0,0 +1,14 @@
+// @bun
+// packages/run-worker/src/journal.ts
+import { RunSessionJournal } from "@rig/runtime/control-plane/run-session-writer";
+async function createRunJournal(sessionManager, runId) {
+  try {
+    return new RunSessionJournal(sessionManager, runId);
+  } catch (error) {
+    console.warn(`[rig-run] RunSessionJournal unavailable; run-state arming deferred: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+export {
+  createRunJournal
+};

package/dist/src/notifications.d.ts

@@ -0,0 +1 @@
+export declare function dispatchRunNotifications(projectRoot: string, runId: string, taskId: string, outcome: "completed" | "failed", detail: string | null): Promise<void>;