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

package/dist/src/worker/plugin.js

@@ -0,0 +1,1761 @@
+// @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);
+var __require = import.meta.require;
+
+// packages/run-plugin/src/worker/inbox-command.ts
+var exports_inbox_command = {};
+__export(exports_inbox_command, {
+  readPendingInboxCounts: () => readPendingInboxCounts,
+  listInboxRecords: () => listInboxRecords,
+  listInbox: () => listInbox,
+  executeInbox: () => executeInbox
+});
+import { RUN_CONTROL, RUN_READ_MODEL } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { requireCapabilityForRoot } from "@rig/core/capability-loaders";
+import { CliError, requireNoExtraArgs, takeOption } from "@rig/std-shared/cli-args";
+import { printFormattedOutput } from "@rig/std-shared/cli-format";
+async function loadRunControl(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, RunControlCap, "RUN_CONTROL capability unavailable for this project root: load @rig/run-plugin (standard bundle).");
+}
+async function loadRunReadModel(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, RunReadModelCap, "RUN_READ_MODEL capability unavailable for this project root: load @rig/run-plugin (standard bundle).");
+}
+function readModelKind(kind) {
+  return kind === "approvals" ? "approval" : "input";
+}
+async function listInboxRecords(context, kind, filters = {}, deps = {}) {
+  if (deps.listInbox)
+    return deps.listInbox(context.projectRoot, kind, filters);
+  const readModel = await loadRunReadModel(context.projectRoot);
+  return readModel.listInboxRecords({
+    projectRoot: context.projectRoot,
+    kind: readModelKind(kind),
+    ...filters.run ? { runId: filters.run } : {},
+    ...filters.task ? { taskId: filters.task } : {}
+  });
+}
+async function listInbox(context, kind, filters = {}, deps = {}) {
+  return listInboxRecords(context, kind, filters, deps);
+}
+async function readPendingInboxCounts(context, deps = {}) {
+  if (deps.getInboxCounts)
+    return deps.getInboxCounts(context.projectRoot);
+  try {
+    const counts = await (await loadRunReadModel(context.projectRoot)).getInboxCounts({ projectRoot: context.projectRoot, kind: "all" });
+    return { approvals: counts.approvals, inputs: counts.inputs };
+  } catch {
+    return null;
+  }
+}
+function resolutionAttachError(runId, verb, error) {
+  const target = runId ?? "<run-id>";
+  const detail = error instanceof Error ? error.message : String(error);
+  throw new CliError(`rig inbox ${verb} could not deliver a resolution from this one-shot command.`, 2, {
+    hint: `${detail}
+Attach to resolve interactively: rig run attach ${target}`
+  });
+}
+async function readInboxSnapshot(context, filters, deps) {
+  const [approvals, inputs] = await Promise.all([
+    listInbox(context, "approvals", filters, deps),
+    listInbox(context, "inputs", filters, deps)
+  ]);
+  return { approvals, inputs };
+}
+function renderInboxSnapshot(readModel, snapshot) {
+  console.clear();
+  console.log(`rig inbox \u2014 watching (Ctrl-C to stop) \u2014 ${new Date().toLocaleTimeString()}`);
+  printFormattedOutput(readModel.formatInboxList("approvals", snapshot.approvals.map((entry) => ({ ...entry }))));
+  printFormattedOutput(readModel.formatInboxList("inputs", snapshot.inputs.map((entry) => ({ ...entry }))));
+  if (snapshot.approvals.length === 0 && snapshot.inputs.length === 0)
+    console.log("Nothing pending.");
+}
+function sleep(ms) {
+  const { promise, resolve } = Promise.withResolvers();
+  setTimeout(resolve, ms);
+  return promise;
+}
+async function watchInbox(context, filters, deps) {
+  const snapshot = await readInboxSnapshot(context, filters, deps);
+  if (context.outputMode !== "text")
+    return { ok: true, group: "inbox", command: "watch", details: snapshot };
+  const readModel = await loadRunReadModel(context.projectRoot);
+  renderInboxSnapshot(readModel, snapshot);
+  while (true) {
+    await sleep(500);
+    renderInboxSnapshot(readModel, await readInboxSnapshot(context, filters, deps));
+  }
+}
+async function deliverInboxResolution(context, runId, resolution, deps) {
+  const result = deps.resolveInboxRequest ? await deps.resolveInboxRequest(context.projectRoot, runId, resolution) : await (await loadRunControl(context.projectRoot)).resolveInboxRequest({ projectRoot: context.projectRoot, runId, resolution });
+  if (!result.delivered)
+    throw new Error(result.detail ?? `Inbox request ${resolution.requestId} was not delivered.`);
+  return result;
+}
+async function executeInbox(context, args, deps = {}) {
+  const [command = "approvals", ...rest] = args;
+  const text = context.outputMode === "text";
+  switch (command) {
+    case "approvals":
+    case "inputs": {
+      const run = takeOption(rest, "--run");
+      const task = takeOption(run.rest, "--task");
+      requireNoExtraArgs(task.rest, `rig inbox ${command} [--run <id>] [--task <id>]`);
+      const kind = command === "approvals" ? "approvals" : "inputs";
+      const filters = { ...run.value ? { run: run.value } : {}, ...task.value ? { task: task.value } : {} };
+      const entries = await listInbox(context, kind, filters, deps);
+      if (text) {
+        const readModel = await loadRunReadModel(context.projectRoot);
+        printFormattedOutput(readModel.formatInboxList(kind, entries.map((entry) => ({ ...entry }))));
+      }
+      return { ok: true, group: "inbox", command, details: { entries } };
+    }
+    case "approve": {
+      const run = takeOption(rest, "--run");
+      const request = takeOption(run.rest, "--request");
+      const decision = takeOption(request.rest, "--decision");
+      requireNoExtraArgs(decision.rest, "rig inbox approve --run <id> --request <id> --decision approve|reject");
+      if (!run.value || !request.value)
+        throw new CliError("rig inbox approve requires --run and --request.", 2);
+      const rawDecision = (decision.value ?? "approve").trim().toLowerCase();
+      if (rawDecision !== "approve" && rawDecision !== "approved" && rawDecision !== "reject" && rawDecision !== "rejected")
+        throw new CliError("--decision must be approve or reject.", 2);
+      const normalizedDecision = rawDecision === "approved" ? "approve" : rawDecision === "rejected" ? "reject" : rawDecision;
+      try {
+        await deliverInboxResolution(context, run.value, { kind: "approval", requestId: request.value, decision: normalizedDecision }, deps);
+      } catch (error) {
+        resolutionAttachError(run.value, "approve", error);
+      }
+      if (text)
+        printFormattedOutput(`Resolved approval ${request.value} for run ${run.value}.`);
+      return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, decision: normalizedDecision } };
+    }
+    case "respond":
+    case "answer": {
+      const run = takeOption(rest, "--run");
+      const request = takeOption(run.rest, "--request");
+      const textResult = takeOption(request.rest, "--text");
+      const answerResult = takeOption(textResult.rest, "--answer");
+      requireNoExtraArgs(answerResult.rest, `rig inbox ${command} --run <id> --request <id> (--text|--answer) <answer>`);
+      if (textResult.value && answerResult.value)
+        throw new CliError("Pass only one of --text or --answer.", 2);
+      const answer = textResult.value ?? answerResult.value;
+      if (!run.value || !request.value || !answer)
+        resolutionAttachError(run.value, "respond", new Error(`rig inbox ${command} requires --run, --request, and --text/--answer.`));
+      try {
+        await deliverInboxResolution(context, run.value, { kind: "input", requestId: request.value, answers: { answer } }, deps);
+      } catch (error) {
+        resolutionAttachError(run.value, "respond", error);
+      }
+      if (text)
+        printFormattedOutput(`Sent response ${request.value} for run ${run.value}.`);
+      return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, responded: true } };
+    }
+    case "watch": {
+      const run = takeOption(rest, "--run");
+      const task = takeOption(run.rest, "--task");
+      requireNoExtraArgs(task.rest, "rig inbox watch [--run <id>] [--task <id>]");
+      const filters = { ...run.value ? { run: run.value } : {}, ...task.value ? { task: task.value } : {} };
+      return watchInbox(context, filters, deps);
+    }
+    default:
+      throw new CliError(`Unknown inbox command: ${command}`, 1, { hint: "Run `rig inbox --help` to list inbox commands." });
+  }
+}
+var RunControlCap, RunReadModelCap;
+var init_inbox_command = __esm(() => {
+  RunControlCap = defineCapability(RUN_CONTROL);
+  RunReadModelCap = defineCapability(RUN_READ_MODEL);
+});
+
+// packages/run-plugin/src/worker/session-journal-writer.ts
+var exports_session_journal_writer = {};
+__export(exports_session_journal_writer, {
+  runSessionJournalWriterService: () => runSessionJournalWriterService,
+  reconcileDeadPid: () => reconcileDeadPid,
+  createRunJournal: () => createRunJournal
+});
+import { defineCapability as defineCapability2 } from "@rig/core/capability";
+import { getInstalledCapability, installCapability, loadCapabilityForRoot } from "@rig/core/capability-loaders";
+import {
+  CUSTOM_TYPE_FOR,
+  RUN_SESSION_JOURNAL
+} from "@rig/contracts";
+function requireReadCodec() {
+  const codec = getInstalledCapability(RunSessionJournalCap);
+  if (!codec) {
+    throw new Error("RUN_SESSION_JOURNAL codec capability unavailable: the run-worker autohost / run-host preboot install it before binding the journal writer; ensure @rig/run-plugin (default bundle) is installed.");
+  }
+  return codec;
+}
+function asCustomEntries(entries) {
+  return entries.filter((entry) => Boolean(entry && typeof entry === "object" && entry.type === "custom"));
+}
+function dataRecord(entry) {
+  return entry.data && typeof entry.data === "object" && !Array.isArray(entry.data) ? entry.data : null;
+}
+function entryBelongsToRun(entry, runId, defaultRunId) {
+  const data = dataRecord(entry);
+  if (!data)
+    return runId === defaultRunId;
+  const candidate = data.runId;
+  return candidate === undefined ? runId === defaultRunId : candidate === runId;
+}
+function isRunJournalEventInit(event) {
+  if (event === null || typeof event !== "object")
+    return false;
+  const type = event.type;
+  return typeof type === "string" && Object.hasOwn(CUSTOM_TYPE_FOR, type);
+}
+function createJournalSessionProvider(options) {
+  const now = options.now ?? (() => new Date);
+  const appendRunEvent = async (event, runId = options.runId) => {
+    options.store.appendCustomEntry(CUSTOM_TYPE_FOR[event.type], { ...event, runId, at: now().toISOString() });
+  };
+  const readEntries = () => asCustomEntries(options.store.getEntries());
+  const entriesForRun = (runId) => readEntries().filter((entry) => entryBelongsToRun(entry, runId, options.runId));
+  const readProjection = () => {
+    const entries = entriesForRun(options.runId);
+    return requireReadCodec().projectRunFromSession(entries, options.runId);
+  };
+  return {
+    runId: options.runId,
+    async append(event) {
+      if (isRunJournalEventInit(event))
+        await appendRunEvent(event);
+    },
+    appendRunEvent,
+    async recordPipeline(runId, pipeline) {
+      await appendRunEvent({ type: "pipeline-resolved", pipeline }, runId);
+    },
+    async recordStageOutcome(runId, outcome) {
+      await appendRunEvent({ type: "stage-outcome", outcome }, runId);
+    },
+    async read(runId) {
+      return entriesForRun(runId);
+    },
+    readEntries,
+    readProjection
+  };
+}
+
+class RunSessionJournal {
+  sm;
+  runId;
+  readProjection;
+  constructor(sm, runId, readProjection) {
+    this.sm = sm;
+    this.runId = runId;
+    this.readProjection = readProjection;
+  }
+  #append(init) {
+    this.sm.appendCustomEntry(CUSTOM_TYPE_FOR[init.type], { ...init, at: new Date().toISOString() });
+  }
+  appendStatus(to, opts = {}) {
+    const from = this.readProjection().status;
+    if (!opts.force)
+      requireReadCodec().assertRunStatusTransition(from, to);
+    if (opts.errorText !== undefined)
+      this.#append({ type: "record-patch", patch: { errorText: opts.errorText } });
+    this.#append({
+      type: "status-changed",
+      from,
+      to,
+      ...opts.reason !== undefined ? { reason: opts.reason } : {},
+      ...opts.actor !== undefined ? { actor: opts.actor } : {}
+    });
+  }
+  appendTimeline(payload) {
+    this.#append({ type: "timeline-entry", payload });
+  }
+  appendCloseoutPhase(input) {
+    this.#append({
+      type: "closeout-phase",
+      phase: input.phase,
+      outcome: input.outcome,
+      ...input.detail !== undefined ? { detail: input.detail } : {}
+    });
+  }
+  appendApprovalResolved(input) {
+    this.#append({
+      type: "approval-resolved",
+      requestId: input.requestId,
+      decision: input.decision,
+      actor: input.actor,
+      ...input.note !== undefined ? { note: input.note } : {}
+    });
+  }
+  appendInputResolved(input) {
+    this.#append({ type: "input-resolved", requestId: input.requestId, answers: input.answers, actor: input.actor });
+  }
+  appendStall(input) {
+    this.#append({ type: "stall-detected", detail: input.detail });
+  }
+}
+async function createRunJournal(sessionManager, runId) {
+  try {
+    const writableSessionManager = sessionManager;
+    if (typeof writableSessionManager.appendCustomEntry !== "function")
+      return null;
+    const kernel = createJournalSessionProvider({
+      runId,
+      store: {
+        appendCustomEntry: (customType, data) => writableSessionManager.appendCustomEntry(customType, data),
+        getEntries: () => sessionManager.getEntries?.() ?? sessionManager.getBranch?.() ?? []
+      }
+    });
+    const journal = new RunSessionJournal(writableSessionManager, runId, kernel.readProjection);
+    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 writer unavailable; run-state arming deferred: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+async function reconcileDeadPid(input) {
+  if (!input.sessionPath.trim()) {
+    return { runId: input.runId, updated: false, status: "not-found", detail: "session path missing" };
+  }
+  try {
+    const codec = await loadCapabilityForRoot(input.projectRoot, RunSessionJournalCap);
+    if (!codec) {
+      return { runId: input.runId, updated: false, status: "unavailable", detail: "RUN_SESSION_JOURNAL codec capability unavailable" };
+    }
+    installCapability(RunSessionJournalCap, codec);
+    const { SessionManager } = await import("@oh-my-pi/pi-coding-agent/session/session-manager");
+    const session = await SessionManager.open(input.sessionPath, undefined, undefined, { suppressBreadcrumb: true });
+    const journal = await createRunJournal(session, input.runId);
+    if (!journal) {
+      return { runId: input.runId, updated: false, status: "not-found", detail: "run journal not found" };
+    }
+    journal.appendStatus("failed", {
+      reason: input.reason ?? "lazy-reconcile:dead-pid",
+      actor: { kind: "agent" },
+      force: true
+    });
+    return { runId: input.runId, updated: true, status: "reconciled" };
+  } catch (error) {
+    return { runId: input.runId, updated: false, status: "unavailable", detail: error instanceof Error ? error.message : String(error) };
+  }
+}
+var RunSessionJournalCap, runSessionJournalWriterService;
+var init_session_journal_writer = __esm(() => {
+  RunSessionJournalCap = defineCapability2(RUN_SESSION_JOURNAL);
+  runSessionJournalWriterService = {
+    createRunJournal,
+    reconcileDeadPid
+  };
+});
+
+// packages/run-plugin/src/worker/workflow-journal-writer.ts
+var exports_workflow_journal_writer = {};
+__export(exports_workflow_journal_writer, {
+  workflowJournalWriterService: () => workflowJournalWriterService,
+  createWorkflowTaskSelected: () => createWorkflowTaskSelected,
+  createWorkflowTargetSelected: () => createWorkflowTargetSelected,
+  createWorkflowStatusChanged: () => createWorkflowStatusChanged,
+  createWorkflowStarted: () => createWorkflowStarted,
+  createWorkflowOperatorNote: () => createWorkflowOperatorNote
+});
+import {
+  RIG_WORKFLOW_OPERATOR_NOTE,
+  RIG_WORKFLOW_STARTED,
+  RIG_WORKFLOW_STATUS_CHANGED,
+  RIG_WORKFLOW_TARGET_SELECTED,
+  RIG_WORKFLOW_TASK_SELECTED
+} from "@rig/contracts";
+function createWorkflowStarted(input) {
+  return {
+    schemaVersion: 1,
+    workflowId: input.workflowId,
+    target: input.target,
+    selectedRepo: input.selectedRepo,
+    owner: input.owner,
+    createdAt: input.createdAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowTargetSelected(input) {
+  return {
+    schemaVersion: 1,
+    target: input.target,
+    ...input.reason ? { reason: input.reason } : {},
+    selectedAt: input.selectedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowTaskSelected(input) {
+  return {
+    schemaVersion: 1,
+    taskId: input.taskId,
+    ...input.title ? { title: input.title } : {},
+    selectedAt: input.selectedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowStatusChanged(input) {
+  return {
+    schemaVersion: 1,
+    status: input.status,
+    ...input.detail ? { detail: input.detail } : {},
+    changedAt: input.changedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowOperatorNote(input) {
+  return {
+    schemaVersion: 1,
+    ...input.noteId ? { noteId: input.noteId } : {},
+    note: input.note,
+    notedAt: input.notedAt ?? new Date().toISOString()
+  };
+}
+var workflowJournalWriterService;
+var init_workflow_journal_writer = __esm(() => {
+  workflowJournalWriterService = {
+    appendStarted(appender, input) {
+      appender.appendEntry(RIG_WORKFLOW_STARTED, createWorkflowStarted(input));
+    },
+    appendTargetSelected(appender, input) {
+      appender.appendEntry(RIG_WORKFLOW_TARGET_SELECTED, createWorkflowTargetSelected(input));
+    },
+    appendTaskSelected(appender, input) {
+      appender.appendEntry(RIG_WORKFLOW_TASK_SELECTED, createWorkflowTaskSelected(input));
+    },
+    appendStatusChanged(appender, input) {
+      appender.appendEntry(RIG_WORKFLOW_STATUS_CHANGED, createWorkflowStatusChanged(input));
+    },
+    appendOperatorNote(appender, input) {
+      appender.appendEntry(RIG_WORKFLOW_OPERATOR_NOTE, createWorkflowOperatorNote(input));
+    }
+  };
+});
+
+// packages/run-plugin/src/worker/run-control-service.ts
+var exports_run_control_service = {};
+__export(exports_run_control_service, {
+  runControlService: () => runControlService
+});
+import { defineCapability as defineCapability3 } from "@rig/core/capability";
+import { loadCapabilityForRoot as loadCapabilityForRoot2 } from "@rig/core/capability-loaders";
+import {
+  RIG_CONTROL_SENTINEL_END,
+  RIG_INBOX_RESOLUTION_SENTINEL,
+  RIG_PAUSE_SENTINEL,
+  RIG_RESUME_SENTINEL,
+  RIG_STOP_SENTINEL,
+  RIG_STOP_SENTINEL_END,
+  RUN_READ_MODEL as RUN_READ_MODEL2,
+  RUN_SESSION_JOURNAL_WRITER
+} from "@rig/contracts";
+async function readModel(projectRoot) {
+  const service = await loadCapabilityForRoot2(projectRoot, RunReadModelCap2);
+  if (!service)
+    throw new Error("RUN_READ_MODEL capability unavailable: load @rig/run-plugin before using run control.");
+  return service;
+}
+function buildPauseSentinel(runId) {
+  return `${RIG_PAUSE_SENTINEL} runId=${runId} requestedBy=operator ${RIG_CONTROL_SENTINEL_END}`;
+}
+function buildResumeSentinel(runId) {
+  return `${RIG_RESUME_SENTINEL} runId=${runId} requestedBy=operator ${RIG_CONTROL_SENTINEL_END}`;
+}
+function buildStopSentinel(runId, reason) {
+  return `${RIG_STOP_SENTINEL} runId=${runId} reason=${reason} ${RIG_STOP_SENTINEL_END}`;
+}
+function buildInboxResolutionSentinel(runId, payload) {
+  return `${RIG_INBOX_RESOLUTION_SENTINEL} runId=${runId} data=${encodeURIComponent(JSON.stringify(payload))} requestedBy=operator ${RIG_CONTROL_SENTINEL_END}`;
+}
+function collabControlFrames(runId, control) {
+  switch (control.kind) {
+    case "steer":
+      return [{ t: "prompt", text: control.message }];
+    case "resume":
+      return [{ t: "prompt", text: `${buildResumeSentinel(runId)}
+Continue the run from where it paused.` }];
+    case "pause":
+      return [
+        { t: "prompt", text: `${buildPauseSentinel(runId)}
+Pause this run after the current interruption settles.` },
+        { t: "abort" }
+      ];
+    case "stop":
+      return [
+        { t: "prompt", text: `${buildStopSentinel(runId, control.reason)}
+Stop this run and do not continue after the interruption settles.` },
+        { t: "abort" }
+      ];
+  }
+}
+async function loadCollabControlDeps() {
+  const [{ importRoomKey, seal }, { COLLAB_PROTO, packEnvelope, parseCollabLink }] = await Promise.all([
+    import("@oh-my-pi/pi-coding-agent/collab/crypto"),
+    import("@oh-my-pi/pi-coding-agent/collab/protocol")
+  ]);
+  return { importRoomKey, seal, COLLAB_PROTO, packEnvelope, parseCollabLink };
+}
+async function sendSealedCollabFrames(joinLink, frames) {
+  const { importRoomKey, seal, COLLAB_PROTO, packEnvelope, parseCollabLink } = await loadCollabControlDeps();
+  const parsed = parseCollabLink(joinLink);
+  if ("error" in parsed)
+    throw new Error(parsed.error);
+  if (!parsed.writeToken)
+    throw new Error("Run collab link is read-only; cannot send control.");
+  const key = await importRoomKey(parsed.key);
+  const ws = new WebSocket(`${parsed.wsUrl}?role=guest`);
+  await new Promise((resolveOpen, rejectOpen) => {
+    ws.addEventListener("open", () => resolveOpen(), { once: true });
+    ws.addEventListener("error", () => rejectOpen(new Error("collab websocket error")), { once: true });
+  });
+  const hello = {
+    t: "hello",
+    proto: COLLAB_PROTO,
+    name: "rig-operator",
+    writeToken: Buffer.from(parsed.writeToken).toString("base64url")
+  };
+  ws.send(packEnvelope(0, await seal(key, hello)));
+  for (const frame of frames)
+    ws.send(packEnvelope(0, await seal(key, frame)));
+  try {
+    ws.close();
+  } catch {}
+}
+function isSteerableStatus(status, classification) {
+  switch (status) {
+    case "needs-attention":
+    case "waiting-approval":
+    case "waiting-user-input":
+    case "paused":
+      return false;
+    default:
+      return classification.isActive;
+  }
+}
+function controlAffordance(readModel2, run, purpose) {
+  const writable = Boolean(run.joinLink && !run.stale);
+  if (!writable)
+    return { allowed: false, reason: run.stale ? "run is stale" : "run has no join link" };
+  const classification = readModel2.classifyRun(run);
+  switch (purpose) {
+    case "steer":
+      return classification.phase === "active" || classification.phase === "starting" || classification.isNeedsAttention && isSteerableStatus(classification.status, classification) ? { allowed: true } : { allowed: false, reason: "run cannot be steered in its current phase" };
+    case "stop":
+      return classification.isActive && !classification.isTerminal ? { allowed: true } : { allowed: false, reason: "run cannot be stopped in its current phase" };
+    case "pause":
+      return classification.phase === "active" || classification.phase === "starting" ? { allowed: true } : { allowed: false, reason: "run cannot be paused in its current phase" };
+    case "resume":
+      return classification.phase === "paused" ? { allowed: true } : { allowed: false, reason: "run cannot be resumed in its current phase" };
+    case "restart":
+    case "delete":
+    case "prune":
+      return !run.live || run.stale ? { allowed: true } : { allowed: false, reason: "run is still live" };
+    case "attach":
+    case "resolve-inbox":
+    case undefined:
+      return { allowed: true };
+  }
+}
+async function selectedRun(projectRoot, runId, discoveryFilter) {
+  const service = await readModel(projectRoot);
+  const run = await service.getRun({ projectRoot, selector: { id: runId, kind: "any" }, ...discoveryFilter !== undefined ? { discoveryFilter } : {} });
+  return { service, run };
+}
+function targetFromRun(service, run, purpose) {
+  const affordance = controlAffordance(service, run, purpose);
+  return {
+    runId: run.runId,
+    taskId: run.taskId,
+    sessionId: run.runId,
+    sessionPath: run.sessionPath,
+    joinLink: run.joinLink,
+    webLink: run.webLink,
+    relayUrl: run.relayUrl,
+    collabCwd: run.collabCwd,
+    live: run.live,
+    stale: run.stale,
+    canDeliver: affordance.allowed,
+    reason: affordance.allowed ? null : affordance.reason ?? null
+  };
+}
+function inboxResolutionControl(runId, resolution) {
+  return { kind: "steer", message: buildInboxResolutionSentinel(runId, resolution) };
+}
+var RunReadModelCap2, runControlService;
+var init_run_control_service = __esm(() => {
+  RunReadModelCap2 = defineCapability3(RUN_READ_MODEL2);
+  runControlService = {
+    async resolveControlTarget(input) {
+      const { service, run } = await selectedRun(input.projectRoot, input.runId, input.discoveryFilter);
+      return run ? targetFromRun(service, run, input.purpose) : null;
+    },
+    async deliverControl(input) {
+      const { service, run } = await selectedRun(input.projectRoot, input.runId, input.discoveryFilter);
+      if (!run)
+        return { runId: input.runId, kind: input.control.kind, status: "not-found", delivered: false, detail: "run not found" };
+      const affordance = controlAffordance(service, run, input.control.kind);
+      if (!affordance.allowed) {
+        return { runId: run.runId, kind: input.control.kind, status: run.joinLink && !run.stale ? "unsupported" : "not-live", delivered: false, detail: affordance.reason ?? `Run ${run.runId} is not writable in its current phase.` };
+      }
+      try {
+        if (!run.joinLink)
+          throw new Error(`Run ${run.runId} has no writable collab join link; attach interactively to ${input.control.kind}.`);
+        await sendSealedCollabFrames(run.joinLink, collabControlFrames(run.runId, input.control));
+        return { runId: run.runId, kind: input.control.kind, status: "delivered", delivered: true };
+      } catch (error) {
+        return { runId: run.runId, kind: input.control.kind, status: "unsupported", delivered: false, detail: error instanceof Error ? error.message : String(error) };
+      }
+    },
+    async resolveInboxRequest(input) {
+      const target = await this.resolveControlTarget({ projectRoot: input.projectRoot, runId: input.runId, purpose: "resolve-inbox", ...input.discoveryFilter !== undefined ? { discoveryFilter: input.discoveryFilter } : {} });
+      if (!target)
+        return { runId: input.runId, requestId: input.resolution.requestId, kind: input.resolution.kind, status: "not-found", delivered: false, detail: "run not found" };
+      if (!target.canDeliver)
+        return { runId: target.runId, requestId: input.resolution.requestId, kind: input.resolution.kind, status: "not-live", delivered: false, detail: target.reason ?? "run is not deliverable" };
+      const result = await this.deliverControl({ projectRoot: input.projectRoot, runId: target.runId, control: inboxResolutionControl(target.runId, input.resolution), ...input.discoveryFilter !== undefined ? { discoveryFilter: input.discoveryFilter } : {} });
+      const status = result.delivered ? "resolved" : result.status === "delivered" ? "resolved" : result.status;
+      return { runId: target.runId, requestId: input.resolution.requestId, kind: input.resolution.kind, status, delivered: result.delivered, ...result.detail !== undefined ? { detail: result.detail } : {} };
+    },
+    async resolveResumePlan(input) {
+      const { service, run } = await selectedRun(input.projectRoot, input.runId, input.discoveryFilter);
+      if (!run)
+        return null;
+      const affordance = controlAffordance(service, run, "resume");
+      if (affordance.allowed)
+        return { kind: "deliver-control", runId: run.runId, run };
+      if (!run.live || run.stale) {
+        return run.taskId ? { kind: "redispatch-task", runId: run.runId, taskId: run.taskId, title: run.title } : { kind: "unavailable", runId: run.runId, reason: "run is not live and has no task id to re-dispatch" };
+      }
+      return { kind: "unavailable", runId: run.runId, reason: affordance.reason ?? "run cannot be resumed in its current phase" };
+    },
+    async reconcileDeadPid(input) {
+      const RunSessionJournalWriterCap = defineCapability3(RUN_SESSION_JOURNAL_WRITER);
+      const writer = await loadCapabilityForRoot2(input.projectRoot, RunSessionJournalWriterCap);
+      if (!writer) {
+        return { runId: input.runId, updated: false, status: "unavailable", detail: "RUN_SESSION_JOURNAL_WRITER capability unavailable" };
+      }
+      return writer.reconcileDeadPid({
+        projectRoot: input.projectRoot,
+        runId: input.runId,
+        sessionPath: input.sessionPath,
+        ...input.reason !== undefined ? { reason: input.reason } : {}
+      });
+    }
+  };
+});
+
+// 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" });
+var init_local_run_changes = () => {};
+
+// packages/run-plugin/src/worker/notify-cap.ts
+import { NOTIFY_SERVICE_CAPABILITY } from "@rig/contracts";
+import { defineCapability as defineCapability4 } from "@rig/core/capability";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+async function resolveNotifyService(projectRoot) {
+  const { host } = await resolvePluginHost(projectRoot);
+  return NotifyCap.resolve(host);
+}
+var NotifyCap;
+var init_notify_cap = __esm(() => {
+  NotifyCap = defineCapability4(NOTIFY_SERVICE_CAPABILITY);
+});
+
+// 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 {}
+}
+var init_notifications = __esm(() => {
+  init_notify_cap();
+});
+
+// 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";
+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)
+  };
+}
+var RIG_PANELS_CUSTOM_MESSAGE_TYPE = "rig-panels", PANEL_PRODUCER_TIMEOUT_MS = 2000;
+var init_panel_plugin = () => {};
+
+// packages/run-plugin/src/worker/constants.ts
+var TRACKED_RUN_STALL_MS, RUN_PROCESS_STALL_SWEEP_MS, RUN_PROCESS_STALL_DETAIL = "Run process made no OMP session progress for 20+ minutes; recording a stall so recovery can requeue or resume the session.";
+var init_constants = __esm(() => {
+  TRACKED_RUN_STALL_MS = 20 * 60 * 1000;
+  RUN_PROCESS_STALL_SWEEP_MS = 60 * 1000;
+});
+
+// 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);
+}
+var init_stall = __esm(() => {
+  init_constants();
+});
+
+// packages/run-plugin/src/worker/utils.ts
+import { RIG_WORKFLOW_STATUS_CHANGED as RIG_WORKFLOW_STATUS_CHANGED2 } 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;
+}
+var init_utils = () => {};
+
+// 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 as RUN_READ_MODEL3,
+  RUN_SESSION_JOURNAL as RUN_SESSION_JOURNAL2,
+  RUN_SESSION_JOURNAL_WRITER as RUN_SESSION_JOURNAL_WRITER2,
+  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 defineCapability5, defineServiceCapability } from "@rig/core/capability";
+import { installCapability as installCapability2, loadCapabilityForRoot as loadCapabilityForRoot3, requireInstalledCapability } from "@rig/core/capability-loaders";
+import { adopt as adoptRunWorkerKernel } from "@rig/core/kernel-entrypoint";
+async function resolveRunRegistryNamespace(projectRoot, identityNamespaceKey) {
+  if (identityNamespaceKey)
+    return identityNamespaceKey;
+  const transportConfig = await loadCapabilityForRoot3(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
+  };
+}
+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 loadCapabilityForRoot3(projectRoot, capability);
+  if (impl)
+    installCapability2(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 loadCapabilityForRoot3(projectRoot, RunSessionJournalCap2);
+  if (!sessionJournal) {
+    throw new Error("RUN_SESSION_JOURNAL capability unavailable in run-worker autohost: ensure @rig/run-plugin (default bundle) is installed.");
+  }
+  installCapability2(RunSessionJournalCap2, 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 loadCapabilityForRoot3(projectRoot, LifecycleVerificationServiceCap);
+  if (verificationService) {
+    installCapability2(LifecycleVerificationServiceCap, verificationService);
+  }
+  const taskSourceReflectionService = await loadCapabilityForRoot3(projectRoot, TaskSourceReflectionCap);
+  const journalWriter = await loadCapabilityForRoot3(projectRoot, RunSessionJournalWriterCap);
+  if (!journalWriter) {
+    throw new Error("RUN_SESSION_JOURNAL_WRITER capability unavailable in run-worker autohost: ensure @rig/run-plugin is installed.");
+  }
+  installCapability2(RunSessionJournalWriterCap, journalWriter);
+  const journal = await journalWriter.createRunJournal(ctx.sessionManager, runId);
+  const placementTransport = await loadCapabilityForRoot3(projectRoot, PlacementTransportCap);
+  if (!placementTransport) {
+    throw new Error("placement run transport capability unavailable: ensure @rig/transport-plugin is installed.");
+  }
+  await adoptRunWorkerKernel(projectRoot, {
+    entrypoint: "run-worker",
+    hydrateEnv: true,
+    transport: placementTransport,
+    ...journal ? { journal: journal.kernel } : {}
+  });
+  if (!ctx.hasUI)
+    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 loadCapabilityForRoot3(projectRoot, RunIdentityEnvCap);
+  const identity = identityEnv?.resolveRigIdentity(ctx) ?? null;
+  const runReadModel = await loadCapabilityForRoot3(projectRoot, RunReadModelCap3);
+  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 loadCapabilityForRoot3(projectRoot, RunRegistryBackboneCap);
+  if (registryBackbone)
+    installCapability2(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 loadCapabilityForRoot3(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 loadCapabilityForRoot3(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 } : {}
+  });
+}
+var GitHubCliCap, GitHubTokenResolverCap, RepoChangeSetCap, RepoGitWorkflowCap, RepoNativeGitCap, TaskArtifactsCap, TaskStateStoreCap, PlacementTransportCap, RunIdentityEnvCap, RunRegistryBackboneCap, RunReadModelCap3, RunSessionJournalCap2, RunSessionJournalWriterCap, LifecycleVerificationServiceCap, TransportConfigCap, TaskSourceReflectionCap, REGISTRY_PROJECTION_TIMELINE_LIMIT = 100, OPERATOR_ACTOR, REGISTRY_SECRET_LINK_FIELDS;
+var init_autohost = __esm(() => {
+  init_local_run_changes();
+  init_notifications();
+  init_panel_plugin();
+  init_stall();
+  init_utils();
+  GitHubCliCap = defineCapability5(GITHUB_CLI);
+  GitHubTokenResolverCap = defineCapability5(GITHUB_TOKEN_RESOLVER);
+  RepoChangeSetCap = defineCapability5(REPO_CHANGE_SET);
+  RepoGitWorkflowCap = defineCapability5(REPO_GIT_WORKFLOW);
+  RepoNativeGitCap = defineCapability5(REPO_NATIVE_GIT);
+  TaskArtifactsCap = defineCapability5(TASK_ARTIFACTS);
+  TaskStateStoreCap = defineCapability5(TASK_STATE_STORE);
+  PlacementTransportCap = defineCapability5(PLACEMENT_RUN_TRANSPORT);
+  RunIdentityEnvCap = defineCapability5(RUN_IDENTITY_ENV);
+  RunRegistryBackboneCap = defineCapability5(RUN_REGISTRY_BACKBONE);
+  RunReadModelCap3 = defineCapability5(RUN_READ_MODEL3);
+  RunSessionJournalCap2 = defineCapability5(RUN_SESSION_JOURNAL2);
+  RunSessionJournalWriterCap = defineCapability5(RUN_SESSION_JOURNAL_WRITER2);
+  LifecycleVerificationServiceCap = defineServiceCapability(LIFECYCLE_VERIFICATION_SERVICE);
+  TransportConfigCap = defineCapability5(TRANSPORT_CONFIG);
+  TaskSourceReflectionCap = defineCapability5(TASK_SOURCE_REFLECTION);
+  OPERATOR_ACTOR = { kind: "operator" };
+  REGISTRY_SECRET_LINK_FIELDS = new Set(["joinLink", "webLink"]);
+});
+
+// packages/run-plugin/src/worker/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-plugin/src/worker/plugin.ts
+import { defineCapability as defineCapability6 } from "@rig/core/capability";
+import { definePlugin } from "@rig/core/config";
+import {
+  RIG_WORKFLOW_JOURNAL_WRITER,
+  RUN_CONTROL as RUN_CONTROL2,
+  RUN_SESSION_JOURNAL_WRITER as RUN_SESSION_JOURNAL_WRITER3,
+  SESSION_RUN_ADAPTER
+} from "@rig/contracts";
+async function installWorkerInboxIfPresent(parentPort) {
+  if (!parentPort)
+    return;
+  const { installWorkerInbox } = await import("@oh-my-pi/pi-utils/worker-host");
+  installWorkerInbox(parentPort);
+}
+var RunSessionJournalWriterCap2 = defineCapability6(RUN_SESSION_JOURNAL_WRITER3);
+var WorkflowJournalWriterCap = defineCapability6(RIG_WORKFLOW_JOURNAL_WRITER);
+var RunControlCap2 = defineCapability6(RUN_CONTROL2);
+var SessionRunAdapterCap = defineCapability6(SESSION_RUN_ADAPTER);
+var RUN_WORKER_SEED_ENTRYPOINTS = [
+  {
+    id: "@rig/run-worker:stats-sync-worker",
+    workerArg: "__omp_worker_stats_sync",
+    description: "OMP stats sync self-exec worker.",
+    run: async () => {
+      const scope = globalThis;
+      const pending = [];
+      const buffer = (event) => {
+        pending.push(event);
+      };
+      scope.onmessage = buffer;
+      await import("@oh-my-pi/omp-stats/sync-worker");
+      const handler = scope.onmessage;
+      if (handler && handler !== buffer) {
+        for (const event of pending)
+          handler.call(scope, event);
+      }
+    }
+  },
+  {
+    id: "@rig/run-worker:tab-worker",
+    workerArg: "__omp_worker_tab",
+    description: "Browser tab tool self-exec worker.",
+    run: async ({ parentPort }) => {
+      await installWorkerInboxIfPresent(parentPort);
+      await import("@oh-my-pi/pi-coding-agent/tools/browser/tab-worker-entry");
+    }
+  },
+  {
+    id: "@rig/run-worker:js-eval-worker",
+    workerArg: "__omp_worker_js_eval",
+    description: "JavaScript eval tool self-exec worker.",
+    run: async ({ parentPort }) => {
+      await installWorkerInboxIfPresent(parentPort);
+      await import("@oh-my-pi/pi-coding-agent/eval/js/worker-entry");
+    }
+  },
+  {
+    id: "@rig/run-worker:tiny-inference-worker",
+    workerArg: "__omp_worker_tiny_inference",
+    description: "Tiny-model (titles) transformers.js IPC subprocess worker.",
+    run: async () => {
+      const { startTinyTitleWorker } = await import("@oh-my-pi/pi-coding-agent/tiny/worker");
+      await runIpcSubprocessWorker(startTinyTitleWorker);
+    }
+  },
+  {
+    id: "@rig/run-worker:stt-worker",
+    workerArg: "__omp_worker_stt",
+    description: "Speech-to-text transformers.js IPC subprocess worker.",
+    run: async () => {
+      const { startSttWorker } = await import("@oh-my-pi/pi-coding-agent/stt/asr-worker");
+      await runIpcSubprocessWorker(startSttWorker);
+    }
+  },
+  {
+    id: "@rig/run-worker:tts-worker",
+    workerArg: "__omp_worker_tts",
+    description: "Text-to-speech transformers.js IPC subprocess worker.",
+    run: async () => {
+      const { startTtsWorker } = await import("@oh-my-pi/pi-coding-agent/tts/tts-worker");
+      await runIpcSubprocessWorker(startTtsWorker);
+    }
+  },
+  {
+    id: "@rig/run-worker:mnemopi-embed-worker",
+    workerArg: "__omp_worker_mnemopi_embed",
+    description: "Mnemopi embedding IPC subprocess worker.",
+    run: async () => {
+      const { startMnemopiEmbedWorker } = await import("@oh-my-pi/pi-coding-agent/mnemopi/embed-worker");
+      await runIpcSubprocessWorker(startMnemopiEmbedWorker);
+    }
+  }
+];
+async function runIpcSubprocessWorker(start) {
+  const { promise: shuttingDown, resolve: shutdown } = Promise.withResolvers();
+  const send = (message) => {
+    const sender = process.send;
+    if (!sender) {
+      shutdown();
+      return;
+    }
+    try {
+      sender.call(process, message);
+    } catch {
+      shutdown();
+    }
+  };
+  start({
+    send,
+    onMessage(handler) {
+      const wrap = (data) => handler(data);
+      process.on("message", wrap);
+      return () => {
+        process.off("message", wrap);
+      };
+    }
+  });
+  const keepalive = setInterval(() => {}, 1073741824);
+  process.on("disconnect", () => shutdown());
+  try {
+    await shuttingDown;
+  } finally {
+    clearInterval(keepalive);
+  }
+  process.kill(process.pid, "SIGKILL");
+}
+var inboxCommand = {
+  id: "@rig/run-worker:inbox",
+  family: "inbox",
+  description: "Inspect and resolve run inbox items.",
+  projectRequired: true,
+  run: async (context, args) => (await Promise.resolve().then(() => (init_inbox_command(), exports_inbox_command))).executeInbox(context, [...args]),
+  helpDoc: {
+    name: "inbox",
+    summary: "Legacy automation-only request view; normal UX is the OMP Inbox screen.",
+    usage: ["rig inbox <approvals|approve|inputs|respond> [options]"],
+    commands: [
+      { command: "approvals [--run <id>] [--task <id>]", description: "Legacy automation-only: list pending approval records.", primary: true },
+      { command: "inputs [--run <id>] [--task <id>]", description: "Legacy automation-only: list pending user-input records.", primary: true },
+      { command: "approve --run <id> --request <id> --decision approve|reject", description: "Legacy automation-only: resolve an approval record." },
+      { command: "respond --run <id> --request <id> --text <answer> | --answer <answer>", description: "Legacy automation-only: answer a user-input record." }
+    ],
+    examples: [
+      "rig inbox approvals # legacy automation only"
+    ],
+    next: ["For normal UX, use bare `rig`, then the OMP Inbox screen."]
+  }
+};
+var runWorkerPlugin = definePlugin({
+  name: "@rig/run-plugin",
+  version: "0.0.0-alpha.1",
+  effects: {
+    readsFiles: true,
+    writesFiles: true,
+    opensNetwork: true,
+    contributesCliCommands: true
+  },
+  contributes: {
+    cliCommands: [inboxCommand],
+    capabilities: [
+      RunSessionJournalWriterCap2.provide(async () => (await Promise.resolve().then(() => (init_session_journal_writer(), exports_session_journal_writer))).runSessionJournalWriterService, {
+        title: "Run session-journal writer",
+        description: "Bind writable run journals to live OMP sessions for run-worker lifecycle updates."
+      }),
+      WorkflowJournalWriterCap.provide(async () => (await Promise.resolve().then(() => (init_workflow_journal_writer(), exports_workflow_journal_writer))).workflowJournalWriterService, {
+        title: "Workflow journal writer",
+        description: "Mint and append rig.workflow.* session facts; owned by the run-status writer owner (not the read-only read-model)."
+      }),
+      RunControlCap2.provide(async () => (await Promise.resolve().then(() => (init_run_control_service(), exports_run_control_service))).runControlService, {
+        title: "Run control endpoint",
+        description: "Resolve run action targets, deliver operator control/steer/stop/pause/resume, resolve inbox requests, plan resume, and reconcile dead-pid runs."
+      }),
+      SessionRunAdapterCap.provide(async () => {
+        const { default: rigWorkerExtension2 } = await Promise.resolve().then(() => (init_extension(), exports_extension));
+        return {
+          installRunAdapter: (api) => rigWorkerExtension2(api)
+        };
+      }, {
+        title: "Session\u2192run adapter",
+        description: "Install the run-worker session extension, adapting the configured harness session into a running Rig run."
+      })
+    ],
+    seedEntrypoints: RUN_WORKER_SEED_ENTRYPOINTS
+  }
+});
+function createRunWorkerPlugin() {
+  return runWorkerPlugin;
+}
+export {
+  runWorkerPlugin,
+  createRunWorkerPlugin
+};