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

package/dist/src/plugin.js

@@ -0,0 +1,4319 @@
+// @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/read-model/stats-format.ts
+function formatRatePercent(value) {
+  return value === null ? "\u2014" : `${Math.round(value * 100)}%`;
+}
+
+// packages/run-plugin/src/read-model/session-journal.ts
+var exports_session_journal = {};
+__export(exports_session_journal, {
+  timelineEntriesFromCustomEntries: () => timelineEntriesFromCustomEntries,
+  sessionIdFromSessionFile: () => sessionIdFromSessionFile,
+  runSessionJournalCodec: () => runSessionJournalCodec,
+  projectRunFromSession: () => projectRunFromSession,
+  parseStopSentinel: () => parseStopSentinel,
+  parseResumeSentinel: () => parseResumeSentinel,
+  parsePauseSentinel: () => parsePauseSentinel,
+  parseInboxResolutionSentinel: () => parseInboxResolutionSentinel,
+  latestTimelineEntriesFromCustomEntries: () => latestTimelineEntriesFromCustomEntries,
+  isTerminalRunStatus: () => isTerminalRunStatus,
+  foldRunSessionEntries: () => foldRunSessionEntries
+});
+import { Schema } from "effect";
+import {
+  CUSTOM_TYPE_FOR as CUSTOM_TYPE_FOR2,
+  RIG_CONTROL_SENTINEL_END as RIG_CONTROL_SENTINEL_END2,
+  RIG_INBOX_RESOLUTION_SENTINEL as RIG_INBOX_RESOLUTION_SENTINEL2,
+  RIG_PAUSE_SENTINEL as RIG_PAUSE_SENTINEL2,
+  RIG_RESUME_SENTINEL as RIG_RESUME_SENTINEL2,
+  RIG_STOP_SENTINEL as RIG_STOP_SENTINEL2,
+  RIG_STOP_SENTINEL_END as RIG_STOP_SENTINEL_END2,
+  RunJournalEvent,
+  TYPE_FOR_CUSTOM
+} from "@rig/contracts";
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+function canTransitionRunStatus(from, to) {
+  if (from === null)
+    return true;
+  if (from === to)
+    return true;
+  return RUN_STATUS_TRANSITIONS[from].includes(to);
+}
+function assertRunStatusTransition(from, to) {
+  if (!canTransitionRunStatus(from, to)) {
+    throw new Error(`Illegal run status transition: ${from ?? "(none)"} -> ${to}. ` + `Allowed from ${from ?? "(none)"}: ${from ? RUN_STATUS_TRANSITIONS[from].join(", ") : "(any)"}.`);
+  }
+}
+function reduceRunJournal(events, runId = null) {
+  let record = {};
+  let status = null;
+  const statusHistory = [];
+  const pendingApprovals = new Map;
+  const resolvedApprovals = [];
+  const pendingUserInputs = new Map;
+  const resolvedUserInputs = [];
+  const closeoutPhases = [];
+  let resolvedPipeline = null;
+  const stageOutcomes = [];
+  const anomalies = [];
+  let steeringCount = 0;
+  let stallCount = 0;
+  let lastSeq = 0;
+  let lastEventAt = null;
+  const projectedRunId = runId ?? events[0]?.runId ?? null;
+  for (const event of events) {
+    lastSeq = event.seq;
+    lastEventAt = event.at;
+    switch (event.type) {
+      case "status-changed": {
+        if (!canTransitionRunStatus(status, event.to)) {
+          anomalies.push({ seq: event.seq, kind: "illegal-transition", detail: `${status ?? "(none)"} -> ${event.to}` });
+        }
+        statusHistory.push({ seq: event.seq, at: event.at, from: status, to: event.to, reason: event.reason ?? null });
+        const wasTerminal = status !== null && isTerminalRunStatus(status);
+        status = event.to;
+        record = { ...record, updatedAt: event.at };
+        if (isTerminalRunStatus(event.to) && !record.completedAt)
+          record = { ...record, completedAt: event.at };
+        if (!isTerminalRunStatus(event.to) && wasTerminal)
+          record = { ...record, completedAt: null };
+        if (event.to === "running" && !record.startedAt)
+          record = { ...record, startedAt: event.at };
+        break;
+      }
+      case "record-patch": {
+        const next = { ...record };
+        for (const [key, value] of Object.entries(event.patch)) {
+          if (value !== undefined)
+            next[key] = value;
+        }
+        next.updatedAt = event.patch.updatedAt ?? event.at;
+        record = next;
+        break;
+      }
+      case "approval-requested": {
+        pendingApprovals.set(event.requestId, {
+          requestId: event.requestId,
+          requestKind: event.requestKind,
+          actionId: event.actionId ?? null,
+          payload: event.payload,
+          requestedAt: event.at
+        });
+        break;
+      }
+      case "approval-resolved": {
+        const pending = pendingApprovals.get(event.requestId);
+        if (!pending) {
+          const alreadyResolved = resolvedApprovals.some((entry) => entry.requestId === event.requestId);
+          anomalies.push({ seq: event.seq, kind: alreadyResolved ? "duplicate-resolution" : "unknown-request", detail: `approval ${event.requestId}` });
+          break;
+        }
+        pendingApprovals.delete(event.requestId);
+        resolvedApprovals.push({ ...pending, decision: event.decision, note: event.note ?? null, actor: event.actor, resolvedAt: event.at });
+        break;
+      }
+      case "input-requested": {
+        pendingUserInputs.set(event.requestId, {
+          requestId: event.requestId,
+          requestKind: "user-input",
+          actionId: null,
+          payload: event.payload,
+          requestedAt: event.at
+        });
+        break;
+      }
+      case "input-resolved": {
+        const pending = pendingUserInputs.get(event.requestId);
+        if (!pending) {
+          const alreadyResolved = resolvedUserInputs.some((entry) => entry.requestId === event.requestId);
+          anomalies.push({ seq: event.seq, kind: alreadyResolved ? "duplicate-resolution" : "unknown-request", detail: `user-input ${event.requestId}` });
+          break;
+        }
+        pendingUserInputs.delete(event.requestId);
+        resolvedUserInputs.push({ ...pending, answers: event.answers, actor: event.actor, resolvedAt: event.at });
+        break;
+      }
+      case "steering":
+        steeringCount += 1;
+        break;
+      case "adopted":
+        record = { ...record, pid: event.pid, updatedAt: event.at };
+        break;
+      case "stall-detected":
+        stallCount += 1;
+        break;
+      case "closeout-phase":
+        closeoutPhases.push({ seq: event.seq, at: event.at, phase: event.phase, outcome: event.outcome, detail: event.detail ?? null });
+        break;
+      case "pipeline-resolved":
+        resolvedPipeline = event.pipeline;
+        break;
+      case "stage-outcome":
+        stageOutcomes.push({ seq: event.seq, at: event.at, outcome: event.outcome });
+        break;
+      case "timeline-entry":
+      case "log-entry":
+        break;
+    }
+  }
+  return {
+    runId: projectedRunId,
+    record,
+    status,
+    statusHistory,
+    pendingApprovals: [...pendingApprovals.values()],
+    resolvedApprovals,
+    pendingUserInputs: [...pendingUserInputs.values()],
+    resolvedUserInputs,
+    steeringCount,
+    stallCount,
+    closeoutPhases,
+    resolvedPipeline,
+    stageOutcomes,
+    lastSeq,
+    lastEventAt,
+    anomalies
+  };
+}
+function sessionIdFromSessionFile(sessionPath) {
+  if (!sessionPath)
+    return null;
+  const file = sessionPath.split(/[\\/]/).pop() ?? "";
+  const match = file.match(/_([0-9a-fA-F][0-9a-fA-F-]{7,})\.jsonl$/);
+  return match?.[1] ?? null;
+}
+function isRunSessionCustomType(customType) {
+  return customType !== undefined && Object.hasOwn(TYPE_FOR_CUSTOM, customType);
+}
+function foldRunSessionEntries(entries, runId) {
+  const events = [];
+  entries.forEach((entry, index) => {
+    if (entry.type !== "custom" || !isRunSessionCustomType(entry.customType))
+      return;
+    const data = entry.data !== null && typeof entry.data === "object" ? entry.data : {};
+    const stamped = {
+      v: 1,
+      seq: index + 1,
+      at: typeof data.at === "string" ? data.at : new Date(0).toISOString(),
+      runId,
+      ...data,
+      type: TYPE_FOR_CUSTOM[entry.customType]
+    };
+    try {
+      events.push(decodeRunJournalEvent(stamped));
+    } catch {}
+  });
+  return reduceRunJournal(events, runId);
+}
+function projectRunFromSession(source, runId) {
+  const entries = "getEntries" in source ? source.getEntries() : source;
+  return foldRunSessionEntries(entries, runId);
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function timelineEntryFromCustomEntry(entry) {
+  if (entry.customType !== CUSTOM_TYPE_FOR2["timeline-entry"] || !isRecord(entry.data))
+    return null;
+  const payload = isRecord(entry.data.payload) ? entry.data.payload : entry.data;
+  const type = typeof payload.type === "string" ? payload.type : "timeline";
+  const stage = typeof payload.stage === "string" ? payload.stage : typeof payload.name === "string" ? payload.name : null;
+  const status = typeof payload.status === "string" ? payload.status : typeof payload.outcome === "string" ? payload.outcome : null;
+  const detail = typeof payload.detail === "string" ? payload.detail : typeof payload.message === "string" ? payload.message : null;
+  const at = typeof entry.data.at === "string" ? entry.data.at : typeof payload.at === "string" ? payload.at : null;
+  return { at, type, stage, status, detail };
+}
+function timelineEntriesFromCustomEntries(entries) {
+  return entries.flatMap((entry) => {
+    const timelineEntry = timelineEntryFromCustomEntry(entry);
+    return timelineEntry ? [timelineEntry] : [];
+  });
+}
+function latestTimelineEntriesFromCustomEntries(entries, limit) {
+  if (limit <= 0)
+    return [];
+  const timeline = [];
+  for (let index = entries.length - 1;index >= 0 && timeline.length < limit; index -= 1) {
+    const timelineEntry = timelineEntryFromCustomEntry(entries[index]);
+    if (timelineEntry)
+      timeline.push(timelineEntry);
+  }
+  timeline.reverse();
+  return timeline;
+}
+function parseStopSentinel(text, expectedRunId) {
+  const start = text.indexOf(RIG_STOP_SENTINEL2);
+  if (start < 0)
+    return null;
+  const end = text.indexOf(RIG_STOP_SENTINEL_END2, start);
+  const body = text.slice(start + RIG_STOP_SENTINEL2.length, end >= 0 ? end : undefined).trim();
+  const runId = body.match(/(?:^|\s)runId=([^\s>]+)/)?.[1] ?? "";
+  if (runId && runId !== expectedRunId)
+    return null;
+  const reason = body.match(/(?:^|\s)reason=(.+)$/)?.[1]?.trim() ?? null;
+  return { reason };
+}
+function parseControlSentinel(marker, text, expectedRunId) {
+  const start = text.indexOf(marker);
+  if (start < 0)
+    return null;
+  const end = text.indexOf(RIG_CONTROL_SENTINEL_END2, start);
+  const body = text.slice(start + marker.length, end >= 0 ? end : undefined).trim();
+  const runId = body.match(/(?:^|\s)runId=([^\s>]+)/)?.[1] ?? "";
+  if (runId && runId !== expectedRunId)
+    return null;
+  const requestedBy = body.match(/(?:^|\s)requestedBy=([^\s>]+)/)?.[1] ?? null;
+  return { requestedBy };
+}
+function parsePauseSentinel(text, expectedRunId) {
+  return parseControlSentinel(RIG_PAUSE_SENTINEL2, text, expectedRunId);
+}
+function parseResumeSentinel(text, expectedRunId) {
+  return parseControlSentinel(RIG_RESUME_SENTINEL2, text, expectedRunId);
+}
+function decodeInboxResolutionPayload(payload) {
+  try {
+    const parsed = JSON.parse(decodeURIComponent(payload));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return null;
+    const record = parsed;
+    if (record.kind === "approval") {
+      const requestId = typeof record.requestId === "string" ? record.requestId.trim() : "";
+      const decision = record.decision === "approve" || record.decision === "reject" ? record.decision : null;
+      const note = typeof record.note === "string" ? record.note : record.note === null ? null : undefined;
+      if (!requestId || !decision)
+        return null;
+      return { kind: "approval", requestId, decision, ...note !== undefined ? { note } : {} };
+    }
+    if (record.kind === "input") {
+      const requestId = typeof record.requestId === "string" ? record.requestId.trim() : "";
+      const answers = record.answers && typeof record.answers === "object" && !Array.isArray(record.answers) ? Object.fromEntries(Object.entries(record.answers).filter((entry) => typeof entry[1] === "string")) : null;
+      if (!requestId || !answers)
+        return null;
+      return { kind: "input", requestId, answers };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function parseInboxResolutionSentinel(text, expectedRunId) {
+  const start = text.indexOf(RIG_INBOX_RESOLUTION_SENTINEL2);
+  if (start < 0)
+    return null;
+  const end = text.indexOf(RIG_CONTROL_SENTINEL_END2, start);
+  const body = text.slice(start + RIG_INBOX_RESOLUTION_SENTINEL2.length, end >= 0 ? end : undefined).trim();
+  const runId = body.match(/(?:^|\s)runId=([^\s>]+)/)?.[1] ?? "";
+  if (runId && runId !== expectedRunId)
+    return null;
+  const requestedBy = body.match(/(?:^|\s)requestedBy=([^\s>]+)/)?.[1] ?? null;
+  const payload = body.match(/(?:^|\s)data=([^\s>]+)/)?.[1] ?? "";
+  const decoded = decodeInboxResolutionPayload(payload);
+  if (!decoded)
+    return null;
+  return { ...decoded, requestedBy };
+}
+var decodeRunJournalEvent = (value) => Schema.decodeUnknownSync(RunJournalEvent)(value), RUN_STATUS_TRANSITIONS, TERMINAL_RUN_STATUSES, runSessionJournalCodec;
+var init_session_journal = __esm(() => {
+  RUN_STATUS_TRANSITIONS = {
+    created: ["queued", "preparing", "running", "failed", "stopped"],
+    queued: ["preparing", "running", "failed", "stopped"],
+    preparing: ["queued", "running", "needs-attention", "failed", "stopped"],
+    running: [
+      "queued",
+      "waiting-approval",
+      "waiting-user-input",
+      "paused",
+      "validating",
+      "reviewing",
+      "closing-out",
+      "needs-attention",
+      "completed",
+      "failed",
+      "stopped"
+    ],
+    "waiting-approval": ["running", "needs-attention", "failed", "stopped"],
+    "waiting-user-input": ["running", "needs-attention", "failed", "stopped"],
+    paused: ["running", "failed", "stopped"],
+    validating: ["running", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+    reviewing: ["running", "validating", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+    "closing-out": ["running", "needs-attention", "completed", "failed", "stopped"],
+    "needs-attention": ["queued", "preparing", "running", "closing-out", "completed", "failed", "stopped"],
+    completed: [],
+    failed: ["queued", "preparing", "running", "closing-out"],
+    stopped: ["queued", "preparing", "running", "closing-out"]
+  };
+  TERMINAL_RUN_STATUSES = ["completed", "failed", "stopped"];
+  runSessionJournalCodec = {
+    foldRunSessionEntries,
+    projectRunFromSession,
+    isTerminalRunStatus,
+    canTransitionRunStatus,
+    assertRunStatusTransition,
+    sessionIdFromSessionFile,
+    timelineEntriesFromCustomEntries,
+    latestTimelineEntriesFromCustomEntries,
+    parseStopSentinel,
+    parsePauseSentinel,
+    parseResumeSentinel,
+    parseInboxResolutionSentinel
+  };
+});
+
+// packages/run-plugin/src/read-model/reconcile.ts
+import { defineCapability as defineCapability7 } from "@rig/core/capability";
+import { loadCapabilityForRoot as loadCapabilityForRoot4 } from "@rig/core/capability-loaders";
+import {
+  RUN_SESSION_JOURNAL_WRITER as RUN_SESSION_JOURNAL_WRITER4
+} from "@rig/contracts";
+async function loadCollabApi() {
+  collabApiPromise ??= import("@oh-my-pi/pi-coding-agent/collab-api").then((api) => api).catch(() => null);
+  return collabApiPromise;
+}
+function pidExists(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function projectionRunId(item) {
+  if (item.runId?.trim())
+    return item.runId.trim();
+  if (item.collab?.sessionId?.trim())
+    return item.collab.sessionId.trim();
+  if (item.session.id?.trim())
+    return item.session.id.trim();
+  return null;
+}
+function isLocallyDiscovered(item) {
+  return item.source === "session-list";
+}
+function isActiveStatus(status) {
+  if (status === null)
+    return false;
+  return !isTerminalRunStatus(status);
+}
+function shouldFlip(item, status, exists) {
+  if (!isActiveStatus(status))
+    return false;
+  if (item.collab?.stale === true)
+    return true;
+  const pid = item.collab?.pid;
+  return isLocallyDiscovered(item) && pid !== undefined && ACTIVE_LOCAL_RUN_STATUSES.has(status) && !exists(pid);
+}
+async function reconcileActiveRuns(input, deps = {}) {
+  const collabApi = deps.listCollabSessionProjections ? null : await loadCollabApi();
+  const listProjections = deps.listCollabSessionProjections ?? collabApi?.listCollabSessionProjections;
+  const journalWriter = deps.journalWriter ?? await loadCapabilityForRoot4(input.workspaceRoot, RunSessionJournalWriterCap3);
+  if (!journalWriter)
+    return { flipped: [], resumable: [] };
+  const exists = deps.processExists ?? pidExists;
+  if (!listProjections)
+    return { flipped: [], resumable: [] };
+  const projections = await listProjections(input.identityFilter);
+  const flipped = [];
+  for (const item of projections) {
+    const runId = projectionRunId(item);
+    const sessionPath = item.session.path || item.collab?.sessionPath || "";
+    if (!runId || !sessionPath)
+      continue;
+    const projection = projectRunFromSession(item.customEntries, runId);
+    const status = projection.status;
+    if (status === null || !shouldFlip(item, status, exists))
+      continue;
+    const result = await journalWriter.reconcileDeadPid({
+      projectRoot: input.workspaceRoot,
+      runId,
+      sessionPath,
+      reason: "lazy-reconcile:dead-pid"
+    });
+    if (result.updated)
+      flipped.push({ runId, sessionPath, reason: "lazy-reconcile:dead-pid" });
+  }
+  return { flipped, resumable: flipped };
+}
+var RunSessionJournalWriterCap3, collabApiPromise = null, ACTIVE_LOCAL_RUN_STATUSES;
+var init_reconcile = __esm(() => {
+  init_session_journal();
+  RunSessionJournalWriterCap3 = defineCapability7(RUN_SESSION_JOURNAL_WRITER4);
+  ACTIVE_LOCAL_RUN_STATUSES = new Set([
+    "created",
+    "preparing",
+    "running",
+    "validating",
+    "reviewing",
+    "closing-out"
+  ]);
+});
+
+// packages/run-plugin/src/read-model/run-format.ts
+import pc from "picocolors";
+import { formatSection, formatSuccessCard, formatNextSteps } from "@rig/std-shared/cli-format";
+function projectedStatusRole(value) {
+  return typeof value === "string" && STATUS_ROLES.has(value) ? value : null;
+}
+function truncate(value, width) {
+  return value.length <= width ? value : `${value.slice(0, Math.max(0, width - 1))}\u2026`;
+}
+function pad(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+function colorForRole(role) {
+  switch (role) {
+    case "success":
+      return pc.green;
+    case "action-yellow":
+      return pc.yellow;
+    case "active-cyan":
+      return pc.cyan;
+    case "failure":
+      return pc.red;
+    case "muted":
+    case "neutral":
+      return pc.dim;
+  }
+}
+function inboxStatusRole(record) {
+  const projected = projectedStatusRole(record.statusRole);
+  if (projected)
+    return projected;
+  return record.status === "pending" ? "active-cyan" : "neutral";
+}
+function compactDate(value) {
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed))
+    return value;
+  return new Date(parsed).toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "Z");
+}
+function firstString(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value;
+  }
+  return fallback;
+}
+function runIdOf(run) {
+  return firstString(run, ["runId", "id"], "(unknown-run)");
+}
+function taskIdOf(run) {
+  return firstString(run, ["taskId", "task", "task_id"]);
+}
+function runTitleOf(run) {
+  return firstString(run, ["title", "summary", "name"], taskIdOf(run) || "(untitled)");
+}
+function requestIdOf(entry) {
+  return firstString(entry, ["requestId", "id", "approvalId", "inputId"], "(unknown-request)");
+}
+function runLikeStatusText(run) {
+  const record = run;
+  const status = typeof record.status === "string" ? record.status.trim() : "";
+  return status || "unclassified";
+}
+function runLikeStatusColor(run) {
+  const record = run;
+  return colorForRole(projectedStatusRole(record.statusRole) ?? "neutral");
+}
+function formatStatusPill(status, role) {
+  const label = status || "unclassified";
+  return colorForRole(role ?? "neutral")(`\u25CF ${label}`);
+}
+function formatLegacyAutomationSurface() {
+  return [];
+}
+function formatRunList(runs, options = {}) {
+  if (runs.length === 0) {
+    return [
+      formatSection("Runs", "none recorded"),
+      options.source === "server" ? dim("No runs recorded on the selected server.") : dim("No runs recorded in local state."),
+      "",
+      ...formatLegacyAutomationSurface()
+    ].join(`
+`);
+  }
+  const body = runs.map((run) => {
+    const row = run;
+    const runId = runIdOf(row);
+    const status = runLikeStatusText(run);
+    const runtime = firstString(row, ["runtime", "runtimeAdapter"], "");
+    return [
+      pc.bold(runId),
+      runLikeStatusColor(run)(pad(truncate(status, 12), 12)),
+      `${runTitleOf(row)}${runtime ? dim(`  ${runtime}`) : ""}`
+    ].join("  ");
+  });
+  return [formatSection("Runs", options.source === "server" ? "selected server" : "local state"), ...body, "", ...formatLegacyAutomationSurface()].join(`
+`);
+}
+function formatSubmittedRun(input) {
+  return formatSuccessCard("Run submitted", [
+    ["run", input.runId],
+    ["task", input.taskId ?? undefined],
+    ["title", input.title ?? undefined],
+    ["queue", input.queuePosition ?? undefined]
+  ]);
+}
+function formatRunCard(run, options = {}) {
+  const record = run;
+  const lines = [formatSection(options.title ?? "Run")];
+  for (const [label, value] of [
+    ["run", runIdOf(record)],
+    ["task", taskIdOf(record)],
+    ["title", runTitleOf(record)],
+    ["status", runLikeStatusText(run)],
+    ["runtime", firstString(record, ["runtime", "runtimeAdapter"], "")],
+    ["created", firstString(record, ["createdAt"], "")],
+    ["updated", firstString(record, ["updatedAt"], "")]
+  ]) {
+    if (value)
+      lines.push(`${faintBar} ${dim(label.padEnd(12))} ${label === "status" ? runLikeStatusColor(run)(value) : label === "created" || label === "updated" ? compactDate(value) : value}`);
+  }
+  const errorSummary = firstString(record, ["errorSummary"]);
+  if (errorSummary)
+    lines.push(`${faintBar} Error: ${errorSummary}`);
+  return lines.join(`
+`);
+}
+function formatRunStatus(summary, options = {}) {
+  const activeRuns = summary.activeRuns ?? [];
+  const recentRuns = summary.recentRuns ?? [];
+  const lines = [formatSection("Run status", options.source === "server" ? "selected server" : "local state")];
+  lines.push(`Active runs (${activeRuns.length})`);
+  if (activeRuns.length === 0)
+    lines.push(dim("No active runs."));
+  else
+    for (const run of activeRuns)
+      lines.push(formatRunSummaryLine(run));
+  lines.push("", `Recent runs (${recentRuns.length})`);
+  if (recentRuns.length === 0)
+    lines.push(dim("No recent terminal runs."));
+  else
+    for (const run of recentRuns.slice(0, 10))
+      lines.push(formatRunSummaryLine(run));
+  lines.push("", ...formatLegacyAutomationSurface());
+  return lines.join(`
+`);
+}
+function formatRunSummaryLine(run) {
+  const record = run;
+  const runId = runIdOf(record);
+  const taskId = taskIdOf(record);
+  const title = runTitleOf(record);
+  const status = runLikeStatusText(run);
+  const runtime = firstString(record, ["runtime", "runtimeAdapter"], "");
+  const descriptor = [taskId, title].filter(Boolean).join(" \xB7 ");
+  return `${faintBar} ${pc.bold(runId)} ${runLikeStatusColor(run)(`\u25CF ${status}`)} ${descriptor}${runtime ? dim(`  ${runtime}`) : ""}`;
+}
+function formatInboxList(kind, entries) {
+  const title = kind === "approvals" ? "Pending approvals" : "Pending user input";
+  if (entries.length === 0) {
+    return [
+      formatSection(title, "empty"),
+      dim(kind === "approvals" ? "No pending approvals." : "No pending user-input requests."),
+      "",
+      ...formatLegacyAutomationSurface()
+    ].join(`
+`);
+  }
+  const lines = [formatSection(title, `${entries.length}`)];
+  for (const record of entries) {
+    const runId = firstString(record, ["runId"], "(unknown-run)");
+    const taskId = firstString(record, ["taskId"], "");
+    const status = firstString(record, ["status"], "pending");
+    const prompt = firstString(record, ["prompt", "message", "reason", "title", "summary"], kind === "approvals" ? "Approval requested" : "Input requested");
+    lines.push(`${faintBar} ${pc.bold(requestIdOf(record))} ${formatStatusPill(status, inboxStatusRole(record))} ${prompt}`);
+    lines.push(`${faintBar} ${dim("run".padEnd(12))} ${runId}${taskId ? dim(`  task ${taskId}`) : ""}`);
+  }
+  lines.push("", ...formatLegacyAutomationSurface(), ...formatNextSteps(kind === "approvals" ? ["Resolve: `rig inbox approve --run <run-id> --request <request-id> --decision approve|reject`"] : ["Reply: `rig inbox answer --run <run-id> --request <request-id> --text ...`"]));
+  return lines.join(`
+`);
+}
+var dim, faintBar, accent, STATUS_ROLES;
+var init_run_format = __esm(() => {
+  dim = pc.dim;
+  faintBar = pc.dim("\u2502");
+  accent = pc.cyan;
+  STATUS_ROLES = new Set([
+    "success",
+    "action-yellow",
+    "active-cyan",
+    "failure",
+    "muted",
+    "neutral"
+  ]);
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/guard.ts
+var TERMINAL;
+var init_guard = __esm(() => {
+  TERMINAL = new Set(["completed", "failed", "stopped"]);
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/run-status.ts
+function isTerminalRunStatus2(status) {
+  return TERMINAL_RUN_STATUSES2.includes(status);
+}
+function isActiveRunStatus(status) {
+  return !isTerminalRunStatus2(status);
+}
+function isRuntimeActiveStatus(status) {
+  return RUNTIME_ACTIVE_STATUSES.has(normalizeRunStatusToken(status));
+}
+function normalizeRunStatusToken(status) {
+  return String(status ?? "").trim().toLowerCase().replace(/[\s_]+/g, "-");
+}
+function isOperatorActiveRunStatus(status) {
+  const normalized = normalizeRunStatusToken(status);
+  if (!normalized)
+    return false;
+  return !OPERATOR_INACTIVE_RUN_STATUSES.has(normalized);
+}
+function canonicalStatusToken(status) {
+  const normalized = normalizeRunStatusToken(status);
+  if (normalized === "waiting-input")
+    return "waiting-user-input";
+  return normalized;
+}
+function asRunStatus(status) {
+  return KNOWN_RUN_STATUS[status] ? status : null;
+}
+function statusColorRole(status) {
+  switch (canonicalStatusToken(status)) {
+    case "done":
+    case "completed":
+    case "ready":
+    case "healthy":
+    case "approved":
+    case "merged":
+      return "success";
+    case "needs-attention":
+    case "waiting-approval":
+    case "waiting-user-input":
+    case "blocked":
+    case "paused":
+      return "action-yellow";
+    case "running":
+    case "adopted":
+    case "preparing":
+    case "created":
+    case "queued":
+    case "starting":
+    case "pending":
+    case "in-progress":
+    case "active":
+    case "booting":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return "active-cyan";
+    case "failed":
+    case "error":
+    case "rejected":
+      return "failure";
+    case "stopped":
+    case "cancelled":
+    case "canceled":
+    case "stale":
+      return "muted";
+    default:
+      return "neutral";
+  }
+}
+function isNeedsAttention(run) {
+  return canonicalStatusToken(run.status) === "needs-attention" || run.pendingApprovals + run.pendingInputs > 0 || run.stallCount > 0;
+}
+function phaseForStatus(status, runStatus, needsAttention) {
+  if (runStatus && isTerminalRunStatus2(runStatus))
+    return runStatus === "completed" || runStatus === "failed" || runStatus === "stopped" ? runStatus : "stopped";
+  if (needsAttention)
+    return "needs-attention";
+  switch (status) {
+    case "created":
+    case "queued":
+    case "preparing":
+    case "starting":
+    case "booting":
+      return "starting";
+    case "waiting-approval":
+    case "waiting-user-input":
+      return "waiting";
+    case "paused":
+      return "paused";
+    case "running":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return "active";
+    default:
+      return runStatus && isActiveRunStatus(runStatus) ? "active" : "unknown";
+  }
+}
+function classifyRun(run) {
+  const status = canonicalStatusToken(run.status) || (run.live && !run.stale ? "starting" : "unknown");
+  const runStatus = asRunStatus(status);
+  const isTerminal = runStatus ? isTerminalRunStatus2(runStatus) : false;
+  const isNeedsAttentionValue = isNeedsAttention(run);
+  const phase = phaseForStatus(status, runStatus, isNeedsAttentionValue);
+  return {
+    status,
+    runStatus: runStatus ?? "needs-attention",
+    phase,
+    isActive: runStatus ? isActiveRunStatus(runStatus) : !isTerminal && status !== "unknown",
+    isTerminal,
+    isNeedsAttention: isNeedsAttentionValue,
+    offersRecovery: phase === "failed"
+  };
+}
+function runStatusColorRole(run) {
+  const classification = classifyRun(run);
+  return classification.isNeedsAttention && !classification.isTerminal ? "action-yellow" : statusColorRole(classification.status);
+}
+function statusRank(run) {
+  const classification = classifyRun(run);
+  if (classification.isNeedsAttention)
+    return 0;
+  switch (classification.phase) {
+    case "needs-attention":
+      return 0;
+    case "active":
+    case "waiting":
+    case "paused":
+      return 1;
+    case "starting":
+      return 2;
+    case "completed":
+      return 3;
+    case "failed":
+      return 4;
+    case "stopped":
+      return 5;
+    case "unknown":
+      return 6;
+  }
+}
+var OPERATOR_INACTIVE_RUN_STATUSES, TERMINAL_RUN_STATUSES2, RUNTIME_ACTIVE_STATUSES, ACTIVE_RUN_STATUSES, KNOWN_RUN_STATUS;
+var init_run_status = __esm(() => {
+  OPERATOR_INACTIVE_RUN_STATUSES = new Set([
+    "completed",
+    "complete",
+    "done",
+    "success",
+    "succeeded",
+    "passed",
+    "failed",
+    "failure",
+    "error",
+    "errored",
+    "stopped",
+    "cancelled",
+    "canceled",
+    "aborted",
+    "abort",
+    "merged",
+    "closed",
+    "skipped",
+    "needs-attention",
+    "needs_attention"
+  ]);
+  TERMINAL_RUN_STATUSES2 = ["completed", "failed", "stopped"];
+  RUNTIME_ACTIVE_STATUSES = new Set([
+    "created",
+    "preparing",
+    "running",
+    "validating",
+    "reviewing",
+    "closing-out"
+  ]);
+  ACTIVE_RUN_STATUSES = [
+    "created",
+    "queued",
+    "preparing",
+    "running",
+    "waiting-approval",
+    "waiting-user-input",
+    "paused",
+    "validating",
+    "reviewing",
+    "closing-out",
+    "needs-attention"
+  ];
+  KNOWN_RUN_STATUS = Object.fromEntries([...ACTIVE_RUN_STATUSES, ...TERMINAL_RUN_STATUSES2].map((status) => [status, true]));
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/diagnostics.ts
+function normalizeString(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function isGenericRunFailure(value) {
+  const text = normalizeString(value);
+  return Boolean(text && /^Task run failed \([^)]*\)$/i.test(text));
+}
+function appendCandidate(candidates, value) {
+  const text = normalizeString(value);
+  if (text && !candidates.includes(text))
+    candidates.push(text);
+}
+function categorizeUsefulRunError(lines) {
+  const taskSourceFailure = lines.find((line) => /failed to update task source/i.test(line));
+  if (taskSourceFailure)
+    return `Task source update failed: ${taskSourceFailure}`;
+  const moduleFailure = lines.find((line) => /cannot find module/i.test(line));
+  if (moduleFailure)
+    return `Runtime module resolution failed: ${moduleFailure}`;
+  const providerFailure = lines.find((line) => /no api key found|unauthorized|authentication failed|invalid api key/i.test(line));
+  if (providerFailure)
+    return `Provider authentication failed: ${providerFailure}`;
+  return null;
+}
+function summarizeRunError(projection) {
+  if (projection.status !== "failed")
+    return null;
+  const candidates = [];
+  for (const anomaly of projection.anomalies) {
+    appendCandidate(candidates, `Journal anomaly (${anomaly.kind}): ${anomaly.detail}`);
+  }
+  for (const phase of projection.closeoutPhases) {
+    if (phase.outcome === "failed")
+      appendCandidate(candidates, phase.detail);
+  }
+  for (const entry of projection.statusHistory) {
+    appendCandidate(candidates, entry.reason);
+  }
+  appendCandidate(candidates, projection.record.statusDetail);
+  appendCandidate(candidates, projection.record.errorText);
+  const nonGeneric = candidates.filter((candidate) => !isGenericRunFailure(candidate));
+  return categorizeUsefulRunError(nonGeneric) ?? nonGeneric.at(-1) ?? normalizeString(projection.record.errorText);
+}
+
+// packages/run-plugin/src/read-model/read-model-backend/projection.ts
+var exports_projection = {};
+__export(exports_projection, {
+  selectRunProjection: () => selectRunProjection,
+  runRecordsFromCollab: () => runRecordsFromCollab,
+  runRecordFromRegistryEntry: () => runRecordFromRegistryEntry,
+  resolveRunJoinTarget: () => resolveRunJoinTarget,
+  resolveJoinTarget: () => resolveJoinTarget,
+  readSessionRunEntries: () => readSessionRunEntries,
+  listRuns: () => listRuns,
+  listRunProjections: () => listRunProjections,
+  getRunProjection: () => getRunProjection,
+  getRun: () => getRun,
+  discoveryDiagnosticRunRecord: () => discoveryDiagnosticRunRecord
+});
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { isAbsolute, relative, resolve as resolve2 } from "path";
+import { RUN_DISCOVERY, RUN_REGISTRY_BACKBONE as RUN_REGISTRY_BACKBONE2 } from "@rig/contracts";
+import { loadCapabilityForRoot as loadCapabilityForRoot5 } from "@rig/core/capability-loaders";
+import { defineCapability as defineCapability8 } from "@rig/core/capability";
+function registryEntryFromCollab(collab) {
+  const record = collab;
+  return {
+    roomId: collab.sessionId,
+    title: collab.title,
+    status: record.registryStatus ?? (collab.stale ? "stale" : "running"),
+    startedAt: collab.startedAt ?? null,
+    heartbeatAt: collab.updatedAt ?? null,
+    sessionPath: collab.sessionPath ?? null,
+    cwd: collab.cwd ?? null,
+    joinLink: collab.joinLink ?? null,
+    webLink: collab.webLink ?? null,
+    relayUrl: collab.relayUrl ?? null,
+    stale: collab.stale,
+    repo: collab.selectedRepo ?? null,
+    ...collab.pid === undefined ? {} : { pid: collab.pid },
+    projection: record.registryProjection ?? null
+  };
+}
+function readSessionRunEntries(sessionPath) {
+  if (!sessionPath || !existsSync2(sessionPath))
+    return [];
+  try {
+    return parseSessionRunEntries(readFileSync(sessionPath, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function parseSessionRunEntries(raw) {
+  const entries = [];
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        continue;
+      entries.push({
+        type: "type" in parsed && typeof parsed.type === "string" ? parsed.type : "",
+        ..."customType" in parsed && typeof parsed.customType === "string" ? { customType: parsed.customType } : {},
+        ..."data" in parsed ? { data: parsed.data } : {}
+      });
+    } catch {
+      continue;
+    }
+  }
+  return entries;
+}
+function stringOrNull(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function objectRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function payloadString(payload, keys) {
+  if (!payload || typeof payload !== "object")
+    return null;
+  const record = payload;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  return null;
+}
+function payloadOptions(payload) {
+  if (!payload || typeof payload !== "object")
+    return;
+  const record = payload;
+  const options = Array.isArray(record.options) ? record.options : Array.isArray(record.choices) ? record.choices : null;
+  const values = options?.filter((value) => typeof value === "string" && value.trim().length > 0) ?? [];
+  return values.length > 0 ? values : undefined;
+}
+function inboxRequest(request, kind) {
+  const fallback = kind === "approval" ? "Approval requested" : "Input requested";
+  const body = payloadString(request.payload, ["body", "description", "detail", "details"]);
+  const options = payloadOptions(request.payload);
+  return {
+    requestId: request.requestId,
+    kind,
+    title: payloadString(request.payload, ["title", "message", "reason", "prompt", "summary"]) ?? fallback,
+    ...body !== undefined ? { body } : {},
+    ...options ? { options } : {},
+    requestedAt: request.requestedAt ?? null,
+    source: "run"
+  };
+}
+function inboxFromProjection(projection) {
+  return [
+    ...projection.pendingApprovals.map((request) => inboxRequest(request, "approval")),
+    ...projection.pendingUserInputs.map((request) => inboxRequest(request, "input"))
+  ].sort((a, b) => (Date.parse(a.requestedAt ?? "") || 0) - (Date.parse(b.requestedAt ?? "") || 0));
+}
+function isProjectPath(projectRoot, cwd) {
+  const root = resolve2(projectRoot);
+  const candidate = resolve2(cwd);
+  const pathFromRoot = relative(root, candidate);
+  return pathFromRoot === "" || !pathFromRoot.startsWith("../") && pathFromRoot !== ".." && !isAbsolute(pathFromRoot);
+}
+function sourceFromEntry(projectRoot, projection, entry) {
+  const candidates = [
+    stringOrNull(projection.collabCwd),
+    stringOrNull(projection.cwd),
+    stringOrNull(entry.cwd),
+    stringOrNull(projection.worktreePath)
+  ].filter((cwd) => cwd !== null);
+  return candidates.some((cwd) => isProjectPath(projectRoot, cwd)) ? "local" : "remote";
+}
+function pendingRequests(value, fallbackKind) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((item) => {
+    const record = objectRecord(item);
+    const requestId = stringOrNull(record?.requestId) ?? stringOrNull(record?.id);
+    if (!record || !requestId)
+      return [];
+    return [{
+      requestId,
+      requestKind: stringOrNull(record.requestKind) ?? stringOrNull(record.kind) ?? fallbackKind,
+      actionId: stringOrNull(record.actionId),
+      payload: "payload" in record ? record.payload : record,
+      requestedAt: stringOrNull(record.requestedAt) ?? stringOrNull(record.at) ?? ""
+    }];
+  });
+}
+function emptyFoldedProjection(runId, projection, toRunStatus) {
+  const projectionRecord = projection;
+  const nestedProjection = objectRecord(projectionRecord.projection);
+  const pendingApprovals = pendingRequests(nestedProjection?.pendingApprovals ?? projectionRecord.pendingApprovals, "approval");
+  const pendingUserInputs = pendingRequests(nestedProjection?.pendingUserInputs ?? nestedProjection?.pendingInputs ?? projectionRecord.pendingUserInputs ?? (Array.isArray(projectionRecord.pendingInputs) ? projectionRecord.pendingInputs : undefined), "user-input");
+  const nestedRecord = objectRecord(nestedProjection?.record);
+  const nestedFolded = nestedProjection;
+  return {
+    ...EMPTY_PROJECTION,
+    ...nestedFolded ?? {},
+    record: {
+      ...nestedRecord ?? {},
+      runId,
+      ...projection.taskId ? { taskId: projection.taskId } : {},
+      ...projection.title ? { title: projection.title } : {},
+      ...projection.startedAt ? { startedAt: projection.startedAt } : {},
+      ...projection.updatedAt ? { updatedAt: projection.updatedAt } : {},
+      ...projection.completedAt ? { completedAt: projection.completedAt } : {},
+      ...projection.sessionPath ? { sessionPath: projection.sessionPath } : {},
+      ...projection.worktreePath ? { worktreePath: projection.worktreePath } : {},
+      ...projection.prUrl ? { prUrl: projection.prUrl } : {}
+    },
+    status: toRunStatus(projection.status) ?? toRunStatus(nestedProjection?.status),
+    pendingApprovals,
+    pendingUserInputs,
+    steeringCount: projection.steeringCount ?? numberOrNull(nestedProjection?.steeringCount) ?? 0,
+    stallCount: projection.stallCount ?? numberOrNull(nestedProjection?.stallCount) ?? 0,
+    lastEventAt: projection.updatedAt ?? stringOrNull(nestedProjection?.lastEventAt)
+  };
+}
+function foldedProjectionForRun(runId, projection, sessionPath, toRunStatus) {
+  const registryFolded = emptyFoldedProjection(runId, projection, toRunStatus);
+  const sessionEntries = readSessionRunEntries(sessionPath);
+  if (sessionEntries.length === 0)
+    return { projection: registryFolded, hasSessionEntries: false };
+  const sessionFolded = foldRunSessionEntries(sessionEntries, runId);
+  if (sessionFolded.lastSeq === 0)
+    return { projection: registryFolded, hasSessionEntries: false };
+  return {
+    projection: {
+      ...registryFolded,
+      ...sessionFolded,
+      record: {
+        ...registryFolded.record,
+        ...sessionFolded.record,
+        runId
+      },
+      status: sessionFolded.status ?? registryFolded.status,
+      lastEventAt: sessionFolded.lastEventAt ?? registryFolded.lastEventAt
+    },
+    hasSessionEntries: true
+  };
+}
+function runRecordFromRegistryEntry(projectRoot, entry, toRunStatus) {
+  const projection = entry.projection && typeof entry.projection === "object" ? entry.projection : {};
+  const projectionRecord = projection;
+  const runId = stringOrNull(projection.runId) ?? entry.roomId;
+  const sessionPath = stringOrNull(projection.sessionPath) ?? stringOrNull(entry.sessionPath) ?? null;
+  const foldedResult = foldedProjectionForRun(runId, projection, sessionPath, toRunStatus);
+  const folded = foldedResult.projection;
+  const pushedStatus = folded.status ?? toRunStatus(projection.status) ?? toRunStatus(entry.status);
+  const status = entry.stale ? pushedStatus && isTerminalRunStatus(pushedStatus) ? pushedStatus : "stale" : pushedStatus ?? "running";
+  const collabCwd = stringOrNull(projection.collabCwd) ?? stringOrNull(projection.cwd) ?? stringOrNull(entry.cwd) ?? stringOrNull(projection.worktreePath);
+  const pendingApprovals = foldedResult.hasSessionEntries ? folded.pendingApprovals.length : numberOrNull(projectionRecord.pendingApprovals) ?? folded.pendingApprovals.length;
+  const pendingInputs = foldedResult.hasSessionEntries ? folded.pendingUserInputs.length : numberOrNull(projectionRecord.pendingInputs) ?? folded.pendingUserInputs.length;
+  return {
+    runId,
+    taskId: stringOrNull(projection.taskId),
+    title: stringOrNull(projection.title) ?? entry.title,
+    status,
+    source: sourceFromEntry(projectRoot, projection, entry),
+    live: !entry.stale,
+    stale: entry.stale,
+    startedAt: stringOrNull(projection.startedAt) ?? entry.startedAt ?? null,
+    updatedAt: stringOrNull(projection.updatedAt) ?? entry.heartbeatAt ?? null,
+    completedAt: stringOrNull(projection.completedAt),
+    joinLink: stringOrNull(projection.joinLink) ?? entry.joinLink ?? null,
+    webLink: stringOrNull(projection.webLink) ?? entry.webLink ?? null,
+    relayUrl: stringOrNull(projection.relayUrl) ?? entry.relayUrl ?? null,
+    sessionPath,
+    prUrl: stringOrNull(projection.prUrl),
+    worktreePath: stringOrNull(projection.worktreePath) ?? collabCwd,
+    pendingApprovals,
+    pendingInputs,
+    steeringCount: projection.steeringCount ?? folded.steeringCount ?? 0,
+    stallCount: projection.stallCount ?? folded.stallCount ?? 0,
+    errorSummary: stringOrNull(projection.errorSummary) ?? summarizeRunError(folded),
+    timeline: Array.isArray(projection.timeline) ? [...projection.timeline] : [...timelineEntriesFromCustomEntries([])],
+    inbox: inboxFromProjection(folded),
+    collabCwd: collabCwd ?? null,
+    projection: folded
+  };
+}
+function runRecordsFromCollab(projectRoot, collabs, toRunStatus) {
+  return sortByRecency(collabs.map((collab) => runRecordFromRegistryEntry(projectRoot, registryEntryFromCollab(collab), toRunStatus)).filter((record) => record !== null));
+}
+function sortByRecency(records) {
+  return [...records].sort((a, b) => {
+    const at = Date.parse(b.updatedAt ?? b.startedAt ?? "") || 0;
+    const bt = Date.parse(a.updatedAt ?? a.startedAt ?? "") || 0;
+    return at - bt;
+  });
+}
+function discoveryDiagnosticRunRecord(projectRoot, error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  const runId = DISCOVERY_DIAGNOSTIC_RUN_ID;
+  const projection = {
+    ...EMPTY_PROJECTION,
+    record: { runId, title: "Registry discovery unavailable" },
+    status: "needs-attention",
+    stallCount: 1
+  };
+  return {
+    runId,
+    taskId: null,
+    title: "Registry discovery unavailable",
+    status: "needs-attention",
+    source: "remote",
+    live: false,
+    stale: true,
+    startedAt: null,
+    updatedAt: null,
+    completedAt: null,
+    joinLink: null,
+    webLink: null,
+    relayUrl: null,
+    sessionPath: null,
+    prUrl: null,
+    worktreePath: null,
+    pendingApprovals: 0,
+    pendingInputs: 0,
+    steeringCount: 0,
+    stallCount: 1,
+    errorSummary: `registry discovery unavailable: ${detail}`,
+    timeline: [],
+    inbox: [],
+    collabCwd: null,
+    projection
+  };
+}
+async function listRunProjections(projectRoot, filter = {}) {
+  try {
+    const discovery = await loadCapabilityForRoot5(projectRoot, RunDiscoveryCap);
+    if (!discovery)
+      return [discoveryDiagnosticRunRecord(projectRoot, "run discovery capability unavailable")];
+    const backbone = await loadCapabilityForRoot5(projectRoot, RunRegistryBackboneCap2);
+    if (!backbone)
+      return [discoveryDiagnosticRunRecord(projectRoot, "run registry backbone capability unavailable")];
+    const collabs = await discovery.listActiveRunCollab(projectRoot, filter, { isRuntimeActiveStatus });
+    return runRecordsFromCollab(projectRoot, collabs, backbone.registryStatusToRunStatus);
+  } catch (error) {
+    return [discoveryDiagnosticRunRecord(projectRoot, error)];
+  }
+}
+function selectRunProjection(runs, runId) {
+  const exactRun = runs.find((run) => run.runId === runId);
+  if (exactRun)
+    return exactRun;
+  const exactTask = runs.find((run) => run.taskId === runId);
+  if (exactTask)
+    return exactTask;
+  const prefixMatches = runs.filter((run) => run.runId.startsWith(runId));
+  if (prefixMatches.length === 1)
+    return prefixMatches[0] ?? null;
+  if (prefixMatches.length > 1) {
+    const matches = prefixMatches.map((run) => run.runId).join(", ");
+    throw new Error(`Ambiguous run id prefix "${runId}" matched ${prefixMatches.length} runs: ${matches}`);
+  }
+  return runs.find((run) => run.runId === DISCOVERY_DIAGNOSTIC_RUN_ID) ?? null;
+}
+async function getRunProjection(projectRoot, runId, filter = {}) {
+  const runs = await listRunProjections(projectRoot, filter);
+  return selectRunProjection(runs, runId);
+}
+async function resolveRunJoinTarget(projectRoot, runId, filter = {}) {
+  const run = await getRunProjection(projectRoot, runId, filter);
+  if (!run || !run.joinLink)
+    return null;
+  return { runId: run.runId, taskId: run.taskId, joinLink: run.joinLink, cwd: run.collabCwd ?? run.sessionPath, stale: run.stale };
+}
+var RunDiscoveryCap, RunRegistryBackboneCap2, EMPTY_PROJECTION, DISCOVERY_DIAGNOSTIC_RUN_ID = "__registry_discovery_error__", listRuns, getRun, resolveJoinTarget;
+var init_projection = __esm(() => {
+  init_session_journal();
+  init_run_status();
+  RunDiscoveryCap = defineCapability8(RUN_DISCOVERY);
+  RunRegistryBackboneCap2 = defineCapability8(RUN_REGISTRY_BACKBONE2);
+  EMPTY_PROJECTION = foldRunSessionEntries([], "");
+  listRuns = listRunProjections;
+  getRun = getRunProjection;
+  resolveJoinTarget = resolveRunJoinTarget;
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/inbox.ts
+function promptFromPayload(payload, fallback) {
+  if (payload && typeof payload === "object") {
+    const record = payload;
+    for (const key of ["title", "message", "reason", "prompt", "summary"]) {
+      const value = record[key];
+      if (typeof value === "string" && value.trim().length > 0)
+        return value.trim();
+    }
+  }
+  return fallback;
+}
+function recordsFromRun(run, kind) {
+  const pending = kind === "approvals" ? run.projection.pendingApprovals : run.projection.pendingUserInputs;
+  return pending.map((request) => ({
+    runId: run.runId,
+    taskId: run.taskId,
+    requestId: request.requestId,
+    status: "pending",
+    prompt: promptFromPayload(request.payload, kind === "approvals" ? "Approval requested" : "Input requested"),
+    requestedAt: request.requestedAt,
+    payload: request.payload,
+    kind: kind === "approvals" ? "approval" : "input"
+  }));
+}
+function matchesFilters(run, filters) {
+  if (filters.run && run.runId !== filters.run)
+    return false;
+  if (filters.task && run.taskId !== filters.task && run.runId !== filters.task)
+    return false;
+  return true;
+}
+async function listInboxRecords2(input, kind, filters = {}, deps = {}) {
+  const runs = await (deps.listRuns ?? listRuns)(input.projectRoot);
+  return runs.filter((run) => matchesFilters(run, filters)).flatMap((run) => recordsFromRun(run, kind));
+}
+var init_inbox = __esm(() => {
+  init_projection();
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/inspect.ts
+import { RIG_RUN_LOG_ENTRY } from "@rig/contracts";
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function firstString2(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim().length > 0)
+      return value;
+  }
+  return null;
+}
+function stringifyLogPayload(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  const record = asRecord(value);
+  if (!record)
+    return null;
+  const direct = firstString2(record, ["line", "message", "text", "content", "output", "summary", "detail"]);
+  if (direct)
+    return direct;
+  try {
+    return JSON.stringify(record);
+  } catch {
+    return String(record);
+  }
+}
+function logLineFromValue(value) {
+  const record = asRecord(value);
+  if (!record)
+    return stringifyLogPayload(value);
+  const direct = firstString2(record, ["line", "message", "text", "content", "output", "summary", "detail"]);
+  if (direct)
+    return direct;
+  if ("payload" in record)
+    return stringifyLogPayload(record.payload);
+  if ("data" in record)
+    return stringifyLogPayload(record.data);
+  return stringifyLogPayload(record);
+}
+function logLineFromSessionEntry(entry) {
+  if (entry.type !== "custom" || entry.customType !== RIG_RUN_LOG_ENTRY)
+    return null;
+  return logLineFromValue(entry.data);
+}
+function logLinesFromProjection(projection) {
+  const projected = projection;
+  const lines = [];
+  for (const key of ["logs", "logEntries", "journalLogs", "runLogs"]) {
+    const entries = projected[key];
+    if (!Array.isArray(entries))
+      continue;
+    for (const entry of entries) {
+      const line = logLineFromValue(entry);
+      if (line !== null)
+        lines.push(line);
+    }
+  }
+  return lines;
+}
+function extractRunLogs(run, deps = {}) {
+  const projectedLines = logLinesFromProjection(run.projection);
+  if (projectedLines.length > 0)
+    return projectedLines;
+  return (deps.readSessionRunEntries ?? readSessionRunEntries)(run.sessionPath).map(logLineFromSessionEntry).filter((line) => line !== null);
+}
+function summarizeRunFailures(run) {
+  const failures = [];
+  const useful = summarizeRunError(run.projection);
+  if (useful)
+    failures.push(`${run.runId}: ${useful}`);
+  if (run.status === "failed" || run.projection.status === "failed")
+    failures.push(`${run.runId}: run status failed`);
+  for (const phase of run.projection.closeoutPhases) {
+    if (phase.outcome === "failed")
+      failures.push(`${run.runId}: closeout ${phase.phase} failed${phase.detail ? ` \u2014 ${phase.detail}` : ""}`);
+  }
+  for (const anomaly of run.projection.anomalies) {
+    failures.push(`${run.runId}: anomaly ${anomaly.kind}${anomaly.detail ? ` \u2014 ${anomaly.detail}` : ""}`);
+  }
+  return failures;
+}
+function runInspectSummaryRows(runs, options = {}) {
+  const attachable = runs.filter((run) => Boolean(run.joinLink && !run.stale)).length;
+  const pendingInbox = options.pendingInbox ?? runs.reduce((total, run) => total + run.pendingApprovals + run.pendingInputs, 0);
+  return [
+    { id: "title", label: "Inspect", currentValue: "runtime", heading: true, description: "session/runtime inspection rows from @rig/client" },
+    { id: "inspect:sessions", label: "RUNS", currentValue: String(runs.length), heading: true, description: `${attachable} attachable OMP collab links` },
+    { id: "inspect:cwd", label: "PROJECT ROOT", currentValue: options.projectRoot ?? "", heading: true, description: "selected target/project root used by Rig chrome" },
+    { id: "inspect:inbox", label: "INBOX", currentValue: String(pendingInbox), values: ["open"], description: "pending run gates; open Inbox to resolve" },
+    { id: "inspect:runs", label: "RUNS", currentValue: String(runs.length), values: ["open"], description: "open Runs to inspect individual run detail, logs, and attach controls" },
+    { id: "inspect:audit", label: "AUDIT", currentValue: "unavailable", heading: true, description: "CLI inspect audit has no cockpit equivalent; use rig inspect audit" }
+  ];
+}
+var init_inspect = __esm(() => {
+  init_projection();
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/stats.ts
+function parseTimestamp(value) {
+  if (!value)
+    return null;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function median(values) {
+  if (values.length === 0)
+    return null;
+  const sorted = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+function rate(part, total) {
+  return total === 0 ? null : part / total;
+}
+function completedDuration(run) {
+  if (run.status !== "completed")
+    return null;
+  const startedAt = parseTimestamp(run.startedAt);
+  const completedAt = parseTimestamp(run.completedAt);
+  if (startedAt === null || completedAt === null || completedAt < startedAt)
+    return null;
+  return completedAt - startedAt;
+}
+async function computeStats(projectRootOrRuns, options = {}) {
+  const sinceMs = options.since ? options.since.getTime() : null;
+  const allRuns = typeof projectRootOrRuns === "string" ? await (options.listRuns ?? (await Promise.resolve().then(() => (init_projection(), exports_projection))).listRuns)(projectRootOrRuns) : projectRootOrRuns;
+  const runs = allRuns.filter((run) => {
+    if (sinceMs === null)
+      return true;
+    const startedAt = parseTimestamp(run.startedAt);
+    return startedAt !== null && startedAt >= sinceMs;
+  });
+  const statusCounts = {};
+  const completionDurations = [];
+  let completedRuns = 0;
+  let failedRuns = 0;
+  let needsAttentionRuns = 0;
+  let steeringTotal = 0;
+  let stallTotal = 0;
+  let approvalsPending = 0;
+  let approvalsApproved = 0;
+  let approvalsRejected = 0;
+  for (const run of runs) {
+    const status = run.status || "unknown";
+    statusCounts[status] = (statusCounts[status] ?? 0) + 1;
+    if (status === "completed")
+      completedRuns += 1;
+    if (status === "failed")
+      failedRuns += 1;
+    if (isNeedsAttention(run))
+      needsAttentionRuns += 1;
+    const duration = completedDuration(run);
+    if (duration !== null)
+      completionDurations.push(duration);
+    steeringTotal += run.steeringCount;
+    stallTotal += run.stallCount;
+    approvalsPending += run.projection.pendingApprovals.length;
+    for (const approval of run.projection.resolvedApprovals) {
+      if (approval.decision === "approve")
+        approvalsApproved += 1;
+      if (approval.decision === "reject")
+        approvalsRejected += 1;
+    }
+  }
+  const approvalsRequested = approvalsPending + approvalsApproved + approvalsRejected;
+  const totalRuns = runs.length;
+  return {
+    since: options.since ? options.since.toISOString() : null,
+    totalRuns,
+    statusCounts,
+    completedRuns,
+    failedRuns,
+    needsAttentionRuns,
+    completionRate: rate(completedRuns, totalRuns),
+    failureRate: rate(failedRuns, totalRuns),
+    needsAttentionRate: rate(needsAttentionRuns, totalRuns),
+    medianCompletionMs: median(completionDurations),
+    steeringTotal,
+    steeringPerRun: totalRuns === 0 ? null : steeringTotal / totalRuns,
+    stallTotal,
+    approvalsRequested,
+    approvalsApproved,
+    approvalsRejected,
+    approvalsPending
+  };
+}
+var init_stats = __esm(() => {
+  init_run_status();
+  init_run_status();
+});
+
+// packages/run-plugin/src/read-model/read-model-backend/index.ts
+var init_read_model_backend = __esm(() => {
+  init_projection();
+  init_guard();
+  init_inbox();
+  init_inspect();
+  init_run_status();
+  init_stats();
+});
+
+// packages/run-plugin/src/read-model/read-model-service.ts
+var exports_read_model_service = {};
+__export(exports_read_model_service, {
+  runReadModelService: () => runReadModelService
+});
+import {
+  RUN_REGISTRY_BACKBONE as RUN_REGISTRY_BACKBONE3
+} from "@rig/contracts";
+import { defineCapability as defineCapability9 } from "@rig/core/capability";
+import { requireInstalledCapability as requireInstalledCapability2 } from "@rig/core/capability-loaders";
+function registryBackbone() {
+  return requireInstalledCapability2(RunRegistryBackboneCap3, "RUN_REGISTRY_BACKBONE capability unavailable: the run-worker autohost installs it before building registry projections; ensure @rig/transport-plugin is installed.");
+}
+function discoveryFilter(filter) {
+  return filter ?? {};
+}
+function requestedKinds(kind) {
+  if (kind === "approval")
+    return ["approvals"];
+  if (kind === "input")
+    return ["inputs"];
+  return ["approvals", "inputs"];
+}
+function sourceMatches(run, source) {
+  return !source || source === "all" || run.source === source;
+}
+function failureSummaries(run) {
+  return summarizeRunFailures(run).map((summary) => ({ kind: "run", summary }));
+}
+function inboxRecord(record) {
+  return {
+    runId: record.runId,
+    taskId: record.taskId,
+    requestId: record.requestId,
+    kind: record.kind,
+    status: record.status,
+    title: record.prompt,
+    prompt: record.prompt,
+    requestedAt: record.requestedAt,
+    payload: record.payload,
+    source: "run"
+  };
+}
+async function listedRuns(input) {
+  const runs = await listRuns(input.projectRoot, discoveryFilter(input.discoveryFilter));
+  return runs.filter((run) => {
+    if (input.taskId && run.taskId !== input.taskId && run.runId !== input.taskId)
+      return false;
+    return sourceMatches(run, input.source);
+  });
+}
+async function selectedRun2(input) {
+  return getRun(input.projectRoot, input.id, discoveryFilter(input.discoveryFilter));
+}
+async function representativeRun(input) {
+  const runs = await listedRuns({
+    projectRoot: input.projectRoot,
+    taskId: input.taskId,
+    discoveryFilter: input.discoveryFilter
+  });
+  for (const run of runs)
+    return run;
+  return selectedRun2({ projectRoot: input.projectRoot, id: input.taskId, discoveryFilter: input.discoveryFilter });
+}
+async function readDetails(input) {
+  const run = await selectedRun2(input);
+  if (!run)
+    return null;
+  const pendingInbox = run.inbox;
+  const inboxCounts = {
+    approvals: run.pendingApprovals,
+    inputs: run.pendingInputs,
+    total: run.pendingApprovals + run.pendingInputs
+  };
+  const sessionEntries = run.sessionPath ? readSessionRunEntries(run.sessionPath) : undefined;
+  return {
+    run,
+    projection: run.projection,
+    pendingInbox,
+    inboxCounts,
+    sourceTask: null,
+    ...sessionEntries ? { sessionEntries } : {},
+    failures: failureSummaries(run),
+    logs: input.includeLogs ? extractRunLogs(run) : []
+  };
+}
+async function inboxRecords(input) {
+  const out = [];
+  for (const kind of requestedKinds(input.kind)) {
+    const records = await listInboxRecords2({ projectRoot: input.projectRoot }, kind, { ...input.runId ? { run: input.runId } : {}, ...input.taskId ? { task: input.taskId } : {} }, { listRuns: (projectRoot) => listedRuns({ projectRoot, discoveryFilter: input.discoveryFilter }) });
+    out.push(...records.map(inboxRecord));
+  }
+  return out;
+}
+function classify(run) {
+  const classification = classifyRun(run);
+  return {
+    ...classification,
+    role: runStatusColorRole(run),
+    rank: statusRank(run)
+  };
+}
+function normalizeStageName(value) {
+  const key = value?.toLowerCase().replace(/[_\s]+/g, "-");
+  switch (key) {
+    case "connect":
+    case "collab-host-started":
+      return "Connect";
+    case "github-sync":
+    case "github":
+    case "running-reflection":
+      return "GitHub-sync";
+    case "created":
+    case "queued":
+    case "prepare":
+    case "preparing":
+      return "Prepare";
+    case "launch":
+    case "starting":
+    case "booting":
+    case "running":
+    case "paused":
+      return "Launch";
+    case "plan":
+    case "planning":
+      return "Plan";
+    case "implement":
+    case "implementation":
+      return "Implement";
+    case "validate":
+    case "validating":
+      return "Validate";
+    case "commit":
+      return "Commit";
+    case "push":
+    case "pr-opened":
+    case "open-pr":
+      return "Open-PR";
+    case "pr-review-merge":
+    case "review":
+    case "reviewing":
+    case "review-ci":
+      return "Review/CI";
+    case "merge":
+      return "Merge";
+    case "closing-out":
+    case "completed":
+    case "complete":
+    case "waiting-approval":
+    case "waiting-input":
+    case "waiting-user-input":
+    case "needs-attention":
+    case "failed":
+    case "stopped":
+      return "Complete/Needs-attention/Failed";
+    default:
+      return null;
+  }
+}
+function stageStatusFromRunStatus(value) {
+  const key = value?.toLowerCase().replace(/[_\s]+/g, "-");
+  switch (key) {
+    case "failed":
+      return "failed";
+    case "needs-attention":
+      return "needs-attention";
+    case "stopped":
+      return "stopped";
+    case "paused":
+      return "paused";
+    case "waiting-approval":
+      return "waiting-approval";
+    case "waiting-input":
+      return "waiting-input";
+    case "waiting-user-input":
+      return "waiting-user-input";
+    case "running":
+    case "starting":
+    case "booting":
+    case "started":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return "running";
+    default:
+      return "completed";
+  }
+}
+function terminalStageStatus(classification) {
+  if (classification.isNeedsAttention)
+    return "needs-attention";
+  switch (classification.phase) {
+    case "completed":
+      return "completed";
+    case "failed":
+      return "failed";
+    case "stopped":
+      return "stopped";
+    case "paused":
+      return "paused";
+    default:
+      return classification.isTerminal ? "completed" : null;
+  }
+}
+function projectRunStages(run) {
+  const classification = classify(run);
+  const statuses = new Map;
+  const details = new Map;
+  for (const stage of RUN_DETAIL_STAGES)
+    statuses.set(stage, "pending");
+  for (const history of run.projection.statusHistory ?? []) {
+    const stage = normalizeStageName(history.to);
+    if (stage) {
+      statuses.set(stage, stageStatusFromRunStatus(history.to));
+      if (history.reason)
+        details.set(stage, history.reason);
+    }
+  }
+  for (const entry of run.timeline ?? []) {
+    const stage = normalizeStageName(entry.stage ?? entry.type);
+    if (!stage)
+      continue;
+    statuses.set(stage, stageStatusFromRunStatus(entry.status ?? entry.type));
+    if (entry.detail)
+      details.set(stage, entry.detail);
+  }
+  for (const phase of run.projection.closeoutPhases ?? []) {
+    const stage = normalizeStageName(phase.phase);
+    if (!stage)
+      continue;
+    statuses.set(stage, phase.outcome === "failed" ? "failed" : phase.outcome === "completed" ? "completed" : "running");
+    if (phase.detail)
+      details.set(stage, phase.detail);
+  }
+  const terminalStatus = terminalStageStatus(classification);
+  if (terminalStatus) {
+    statuses.set("Complete/Needs-attention/Failed", terminalStatus);
+  }
+  return RUN_DETAIL_STAGES.map((stage) => ({
+    id: `stage:${stage}`,
+    label: stage,
+    currentValue: statuses.get(stage) ?? "pending",
+    description: details.get(stage) ?? "rig.run timeline / closeout projection"
+  }));
+}
+function buildRegistryProjection(input) {
+  const folded = projectRunFromSession(input.entries, input.runId);
+  const timeline = latestTimelineEntriesFromCustomEntries(input.entries, input.timelineLimit ?? REGISTRY_PROJECTION_TIMELINE_LIMIT2);
+  const cwd = input.cwd ?? process.cwd();
+  const collabCwd = input.collabCwd ?? cwd;
+  const dispatchHandle = input.dispatchHandle?.trim() || null;
+  return {
+    runId: input.runId,
+    taskId: typeof folded.record.taskId === "string" ? folded.record.taskId : input.taskId ?? null,
+    title: typeof folded.record.title === "string" ? folded.record.title : input.title,
+    status: registryBackbone().coerceRegistryStatus(folded.status, "running"),
+    source: "local",
+    startedAt: typeof folded.record.startedAt === "string" ? folded.record.startedAt : null,
+    updatedAt: folded.lastEventAt ?? (typeof folded.record.updatedAt === "string" ? folded.record.updatedAt : new Date().toISOString()),
+    completedAt: typeof folded.record.completedAt === "string" ? folded.record.completedAt : null,
+    joinLink: input.joinLink ?? null,
+    webLink: input.webLink ?? null,
+    relayUrl: input.relayUrl ?? null,
+    sessionPath: typeof folded.record.sessionPath === "string" ? folded.record.sessionPath : input.sessionPath ?? null,
+    prUrl: typeof folded.record.prUrl === "string" ? folded.record.prUrl : null,
+    worktreePath: typeof folded.record.worktreePath === "string" ? folded.record.worktreePath : cwd,
+    collabCwd,
+    cwd,
+    dispatchHandle,
+    pendingApprovals: folded.pendingApprovals.length,
+    pendingInputs: folded.pendingUserInputs.length,
+    steeringCount: folded.steeringCount,
+    stallCount: folded.stallCount,
+    ...typeof folded.record.errorText === "string" ? { errorSummary: folded.record.errorText } : { errorSummary: null },
+    timeline: [...timeline]
+  };
+}
+var REGISTRY_PROJECTION_TIMELINE_LIMIT2 = 100, RunRegistryBackboneCap3, RUN_DETAIL_STAGES, runReadModelService;
+var init_read_model_service = __esm(() => {
+  init_session_journal();
+  init_reconcile();
+  init_run_format();
+  init_read_model_backend();
+  RunRegistryBackboneCap3 = defineCapability9(RUN_REGISTRY_BACKBONE3);
+  RUN_DETAIL_STAGES = [
+    "Connect",
+    "GitHub-sync",
+    "Prepare",
+    "Launch",
+    "Plan",
+    "Implement",
+    "Validate",
+    "Commit",
+    "Open-PR",
+    "Review/CI",
+    "Merge",
+    "Complete/Needs-attention/Failed"
+  ];
+  runReadModelService = {
+    async listRuns(input) {
+      return listedRuns(input);
+    },
+    async getRepresentativeRun(input) {
+      return representativeRun(input);
+    },
+    async getRun(input) {
+      return selectedRun2({ projectRoot: input.projectRoot, id: input.selector.id, discoveryFilter: input.discoveryFilter });
+    },
+    async getRunProjection(input) {
+      const run = await selectedRun2({ projectRoot: input.projectRoot, id: input.runId, discoveryFilter: input.discoveryFilter });
+      return run?.projection ?? null;
+    },
+    buildSessionProjection(input) {
+      return projectRunFromSession(input.entries, input.runId);
+    },
+    buildRegistryProjection,
+    async getRunDetails(input) {
+      return readDetails({
+        projectRoot: input.projectRoot,
+        id: input.selector.id,
+        includeLogs: input.includeLogs,
+        discoveryFilter: input.discoveryFilter
+      });
+    },
+    async inspectRun(input) {
+      const details = await readDetails({
+        projectRoot: input.projectRoot,
+        id: input.selector.id,
+        includeLogs: input.includeLogs,
+        discoveryFilter: input.discoveryFilter
+      });
+      if (!details)
+        return null;
+      return {
+        details,
+        classification: classify(details.run),
+        rows: runInspectSummaryRows([details.run], { projectRoot: input.projectRoot, pendingInbox: details.inboxCounts.total })
+      };
+    },
+    listInboxRecords: inboxRecords,
+    async getInboxCounts(input) {
+      const records = await inboxRecords(input);
+      const approvals = records.filter((record) => record.kind === "approval").length;
+      const inputs = records.filter((record) => record.kind === "input").length;
+      return { approvals, inputs, total: approvals + inputs };
+    },
+    async getStats(input) {
+      const since = input.since ? new Date(input.since) : null;
+      const runs = input.runs ?? await listedRuns({ projectRoot: input.projectRoot, discoveryFilter: input.discoveryFilter });
+      return computeStats(runs, { since });
+    },
+    async getInspectRows(input) {
+      const runs = input.runs ?? await listedRuns({ projectRoot: input.projectRoot, discoveryFilter: input.discoveryFilter });
+      return runInspectSummaryRows(runs, { projectRoot: input.projectRoot, pendingInbox: input.pendingInbox ?? null });
+    },
+    isRuntimeActiveStatus,
+    isOperatorActiveRunStatus,
+    classifyRun: classify,
+    projectRunStages,
+    formatRunList,
+    formatRunCard,
+    formatRunStatus,
+    formatSubmittedRun,
+    formatInboxList,
+    reconcileActiveRuns: (input) => reconcileActiveRuns(input)
+  };
+});
+
+// packages/run-plugin/src/read-model/stats-command.ts
+var exports_stats_command = {};
+__export(exports_stats_command, {
+  parseSinceOption: () => parseSinceOption,
+  formatStatsRows: () => formatStatsRows,
+  executeStats: () => executeStats
+});
+import { RUN_READ_MODEL as RUN_READ_MODEL4 } from "@rig/contracts";
+import { defineCapability as defineCapability10 } from "@rig/core/capability";
+import { requireCapabilityForRoot as requireCapabilityForRoot2 } from "@rig/core/capability-loaders";
+import { CliError as CliError2, requireNoExtraArgs as requireNoExtraArgs2, takeOption as takeOption2 } from "@rig/std-shared/cli-args";
+import { formatStatsTable, printFormattedOutput as printFormattedOutput2 } from "@rig/std-shared/cli-format";
+function parseSinceOption(value, now = new Date) {
+  if (!value?.trim())
+    return null;
+  const trimmed = value.trim();
+  const relative2 = trimmed.match(/^(\d+)d$/i);
+  if (relative2?.[1]) {
+    const days = Number.parseInt(relative2[1], 10);
+    if (!Number.isFinite(days) || days <= 0)
+      throw new CliError2(`Invalid --since value: ${value}`, 2, { hint: "Use an ISO date or a relative window like `7d`." });
+    return new Date(now.getTime() - days * DAY_MS);
+  }
+  const parsed = Date.parse(trimmed);
+  if (!Number.isFinite(parsed))
+    throw new CliError2(`Invalid --since value: ${value}`, 2, { hint: "Use an ISO date or a relative window like `7d`." });
+  return new Date(parsed);
+}
+function formatDuration(ms) {
+  if (ms === null)
+    return "\u2014";
+  const seconds = Math.round(ms / 1000);
+  if (seconds < 60)
+    return `${seconds}s`;
+  const minutes = Math.round(ms / 60000);
+  if (minutes < 60)
+    return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const remainder = minutes % 60;
+  return remainder === 0 ? `${hours}h` : `${hours}h ${remainder}m`;
+}
+function formatStatsRows(stats2) {
+  return [
+    ["window", stats2.since ? `since ${stats2.since}` : "all runs"],
+    ["total runs", stats2.totalRuns],
+    ["completed", `${stats2.completedRuns} (${formatRatePercent(stats2.completionRate)})`],
+    ["failed", `${stats2.failedRuns} (${formatRatePercent(stats2.failureRate)})`],
+    ["needs attention", `${stats2.needsAttentionRuns} (${formatRatePercent(stats2.needsAttentionRate)})`],
+    ["median run time", formatDuration(stats2.medianCompletionMs)],
+    ["steering", stats2.steeringTotal],
+    ["stalls", stats2.stallTotal],
+    ["pending approvals", stats2.approvalsPending]
+  ];
+}
+async function executeStats(context, args, deps = {}) {
+  const list = [...args];
+  const [first = "show", ...rest] = list;
+  const command = first.startsWith("-") ? "show" : first;
+  const commandArgs = first.startsWith("-") ? list : rest;
+  if (command === "help") {
+    printFormattedOutput2(`Usage: ${STATS_USAGE}`);
+    return { ok: true, group: "stats", command };
+  }
+  if (command !== "show")
+    throw new CliError2(`Unknown stats command: ${command}`, 1, { hint: "Run `rig stats --help` \u2014 the default command is `show`." });
+  const sinceResult = takeOption2(commandArgs, "--since");
+  requireNoExtraArgs2(sinceResult.rest, STATS_USAGE);
+  const since = parseSinceOption(sinceResult.value);
+  const readModel2 = await requireCapabilityForRoot2(context.projectRoot, RunReadModelCap4, "RUN_READ_MODEL capability unavailable for this project root: load @rig/run-plugin (standard bundle).");
+  const details = await readModel2.getStats({
+    projectRoot: context.projectRoot,
+    since: since ? since.toISOString() : null,
+    ...deps.listRuns ? { runs: await deps.listRuns(context.projectRoot) } : {}
+  });
+  if ((context.outputMode ?? "text") === "text")
+    printFormattedOutput2(formatStatsTable(formatStatsRows(details)));
+  return { ok: true, group: "stats", command, details };
+}
+var DAY_MS, STATS_USAGE = "rig stats [show] [--since <7d|30d|ISO date>]", RunReadModelCap4;
+var init_stats_command = __esm(() => {
+  DAY_MS = 24 * 60 * 60 * 1000;
+  RunReadModelCap4 = defineCapability10(RUN_READ_MODEL4);
+});
+
+// packages/run-plugin/src/read-model/inspect-command.ts
+var exports_inspect_command = {};
+__export(exports_inspect_command, {
+  executeInspect: () => executeInspect
+});
+import { RUN_READ_MODEL as RUN_READ_MODEL5, TASK_CLI_DATA_CAPABILITY } from "@rig/contracts";
+import { defineCapability as defineCapability11 } from "@rig/core/capability";
+import { requireCapabilityForRoot as requireCapabilityForRoot3 } from "@rig/core/capability-loaders";
+import { CliError as CliError3, requireNoExtraArgs as requireNoExtraArgs3, requireOption, takeOption as takeOption3 } from "@rig/std-shared/cli-args";
+import { printFormattedOutput as printFormattedOutput3 } from "@rig/std-shared/cli-format";
+function inspectHelpText() {
+  return [
+    `Usage: ${INSPECT_USAGE}`,
+    "",
+    "Commands:",
+    "  logs --task <id>              Print log lines from a projected run for a task.",
+    "  artifact --task <id> --file <name>",
+    "                                Preview a single task artifact.",
+    "  artifacts --task <id>         List task artifacts.",
+    "  run-logs --run <id>           Print log lines from a run journal.",
+    "  runs                          List projected runs.",
+    "  diff --task <id>              List files changed by a task.",
+    "  graph [--task <id>]           Print the task dependency graph.",
+    "  failures --task <id>          Print run read-model failure summaries for a task."
+  ].join(`
+`);
+}
+function printInspectHelp() {
+  printFormattedOutput3(inspectHelpText());
+}
+function toRunLike(run, classification) {
+  return {
+    runId: run.runId,
+    taskId: run.taskId,
+    title: run.title,
+    status: classification?.status ?? run.status,
+    runStatus: classification?.runStatus,
+    statusPhase: classification?.phase,
+    statusRole: classification?.role,
+    statusRank: classification?.rank,
+    isActive: classification?.isActive,
+    isTerminal: classification?.isTerminal,
+    isNeedsAttention: classification?.isNeedsAttention,
+    source: run.source,
+    live: run.live,
+    stale: run.stale,
+    startedAt: run.startedAt,
+    updatedAt: run.updatedAt,
+    completedAt: run.completedAt,
+    joinLink: run.joinLink,
+    prUrl: run.prUrl,
+    pendingApprovals: run.pendingApprovals,
+    pendingInputs: run.pendingInputs,
+    steeringCount: run.steeringCount,
+    stallCount: run.stallCount
+  };
+}
+function requireRunId(value, usage) {
+  if (!value || !value.trim())
+    throw new CliError3(`${usage} requires a run id.`, 2, { hint: "Run `rig inspect runs` to find run ids." });
+  return value.trim();
+}
+async function loadRunReadModel2(projectRoot) {
+  return requireCapabilityForRoot3(projectRoot, RunReadModelCap5, "RUN_READ_MODEL capability unavailable for this project root: load @rig/run-plugin (standard bundle).");
+}
+async function listRunRecords(projectRoot, deps) {
+  return deps.listRunProjections ? deps.listRunProjections(projectRoot) : (await loadRunReadModel2(projectRoot)).listRuns({ projectRoot });
+}
+async function getRunRecord(projectRoot, runId, deps) {
+  return deps.getRunProjection ? deps.getRunProjection(projectRoot, runId) : (await loadRunReadModel2(projectRoot)).getRun({ projectRoot, selector: { id: runId, kind: "any" } });
+}
+async function getRunDetails(projectRoot, runId, deps, options = {}) {
+  return deps.getRunDetails ? deps.getRunDetails(projectRoot, runId, options) : (await loadRunReadModel2(projectRoot)).getRunDetails({ projectRoot, selector: { id: runId, kind: "any" }, ...options.includeLogs === undefined ? {} : { includeLogs: options.includeLogs } });
+}
+async function runsForTaskId(projectRoot, taskId, deps) {
+  try {
+    if (!deps.listRunProjections) {
+      const runs = await (await loadRunReadModel2(projectRoot)).listRuns({ projectRoot, taskId });
+      if (runs.length > 0)
+        return runs;
+    } else {
+      const runs = await listRunRecords(projectRoot, deps);
+      const filtered = runs.filter((run2) => run2.taskId === taskId || run2.runId === taskId);
+      if (filtered.length > 0)
+        return filtered;
+    }
+  } catch {}
+  const run = await getRunRecord(projectRoot, taskId, deps);
+  return run ? [run] : [];
+}
+async function representativeRunForTaskId(projectRoot, taskId, deps) {
+  if (deps.listRunProjections) {
+    const runs = await runsForTaskId(projectRoot, taskId, deps);
+    for (const run of runs)
+      return run;
+    return null;
+  }
+  return (await loadRunReadModel2(projectRoot)).getRepresentativeRun({ projectRoot, taskId, purpose: "inspect" });
+}
+function failureLine(failure) {
+  return failure.detail ? `${failure.summary} \u2014 ${failure.detail}` : failure.summary;
+}
+async function executeLogs(context, args, deps) {
+  const taskResult = takeOption3(args, "--task");
+  requireNoExtraArgs3(taskResult.rest, "rig inspect logs --task <id>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect logs --task <id>");
+  const projection = await representativeRunForTaskId(context.projectRoot, taskId, deps);
+  if (!projection)
+    throw new CliError3(`No projected runs found for task ${taskId}.`, 1, { hint: "Run `rig run list` to confirm the run journal is discoverable." });
+  const details = await getRunDetails(context.projectRoot, projection.runId, deps, { includeLogs: true });
+  const lines = [...details?.logs ?? []];
+  if (context.outputMode === "text") {
+    if (lines.length === 0)
+      console.log(`No log entries found for task ${taskId}.`);
+    else
+      for (const line of lines)
+        console.log(line);
+  }
+  return { ok: true, group: "inspect", command: "logs", details: { taskId, runId: projection.runId, count: lines.length, lines } };
+}
+async function executeArtifact(context, args, deps) {
+  const taskResult = takeOption3(args, "--task");
+  const fileResult = takeOption3(taskResult.rest, "--file");
+  requireNoExtraArgs3(fileResult.rest, "rig inspect artifact --task <id> --file <name>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect artifact --task <id> --file <name>");
+  const filename = fileResult.value?.trim();
+  if (!filename)
+    throw new CliError3("rig inspect artifact --task <id> --file <name> requires an artifact file name.", 2);
+  const preview = await (deps.taskArtifactRead ?? (await taskCliData(context.projectRoot)).taskArtifactRead)(context.projectRoot, filename, { taskId, maxBytes: 64 * 1024 });
+  if (context.outputMode === "text") {
+    console.log(preview.contents);
+    if (preview.truncated)
+      console.log(`
+[truncated at ${preview.maxBytes} bytes; artifact is ${preview.sizeBytes} bytes]`);
+  }
+  return { ok: true, group: "inspect", command: "artifact", details: { taskId, file: filename, ...preview } };
+}
+async function executeRunLogs(context, args, deps) {
+  const runResult = takeOption3(args, "--run");
+  requireNoExtraArgs3(runResult.rest, "rig inspect run-logs --run <id>");
+  const runId = requireRunId(runResult.value, "rig inspect run-logs --run <id>");
+  const projection = await getRunRecord(context.projectRoot, runId, deps);
+  if (!projection)
+    throw new CliError3(`Run not found: ${runId}`, 2, { hint: "Run `rig inspect runs` to see runs." });
+  const details = await getRunDetails(context.projectRoot, projection.runId, deps, { includeLogs: true });
+  const lines = [...details?.logs ?? []];
+  if (context.outputMode === "text") {
+    if (lines.length === 0)
+      console.log(`No log entries found for run ${projection.runId}.`);
+    else
+      for (const line of lines)
+        console.log(line);
+  }
+  return { ok: true, group: "inspect", command: "run-logs", details: { runId: projection.runId, taskId: projection.taskId, count: lines.length, lines } };
+}
+async function executeRuns(context, args, deps) {
+  requireNoExtraArgs3(args, "rig inspect runs");
+  let formatted;
+  if (deps.listRunProjections) {
+    formatted = (await listRunRecords(context.projectRoot, deps)).map((run) => toRunLike(run));
+  } else {
+    const readModel2 = await loadRunReadModel2(context.projectRoot);
+    const runs = await readModel2.listRuns({ projectRoot: context.projectRoot });
+    formatted = runs.map((run) => toRunLike(run, readModel2.classifyRun(run)));
+  }
+  if (context.outputMode === "text")
+    printFormattedOutput3(formatRunList(formatted));
+  return { ok: true, group: "inspect", command: "runs", details: { runs: formatted } };
+}
+async function executeArtifacts(context, args, deps) {
+  const taskResult = takeOption3(args, "--task");
+  requireNoExtraArgs3(taskResult.rest, "rig inspect artifacts --task <id>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect artifacts --task <id>");
+  if (context.outputMode === "text")
+    await (deps.taskArtifacts ?? (await taskCliData(context.projectRoot)).taskArtifacts)(context.projectRoot, taskId);
+  return { ok: true, group: "inspect", command: "artifacts", details: { taskId, printed: context.outputMode === "text" } };
+}
+async function executeDiff(context, args, deps) {
+  const taskResult = takeOption3(args, "--task");
+  requireNoExtraArgs3(taskResult.rest, "rig inspect diff --task <id>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect diff --task <id>");
+  const files = (deps.changedFilesForTask ?? (await taskCliData(context.projectRoot)).changedFilesForTask)(context.projectRoot, taskId, true);
+  if (context.outputMode === "text")
+    for (const file of files)
+      console.log(file);
+  return { ok: true, group: "inspect", command: "diff", details: { taskId, files } };
+}
+async function executeGraph(context, args, deps) {
+  const taskResult = takeOption3(args, "--task");
+  requireNoExtraArgs3(taskResult.rest, "rig inspect graph [--task <id>]");
+  if (context.outputMode === "text")
+    await (deps.taskDeps ?? (await taskCliData(context.projectRoot)).taskDeps)(context.projectRoot, taskResult.value);
+  return { ok: true, group: "inspect", command: "graph", details: { taskId: taskResult.value ?? null, printed: context.outputMode === "text" } };
+}
+async function executeFailures(context, args, deps) {
+  const taskResult = takeOption3(args, "--task");
+  requireNoExtraArgs3(taskResult.rest, "rig inspect failures --task <id>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect failures --task <id>");
+  const runs = await runsForTaskId(context.projectRoot, taskId, deps);
+  const failures = (await Promise.all(runs.map(async (run) => (await getRunDetails(context.projectRoot, run.runId, deps))?.failures ?? []))).flat().map(failureLine);
+  if (context.outputMode === "text") {
+    if (failures.length === 0)
+      console.log(`No failures recorded for task ${taskId}.`);
+    else
+      for (const failure of failures)
+        console.log(failure);
+  }
+  return { ok: true, group: "inspect", command: "failures", details: { taskId, count: failures.length, failures } };
+}
+function executeAudit(args) {
+  requireNoExtraArgs3(args, "rig inspect audit");
+  throw new CliError3("rig inspect audit cannot read the controlled-command audit trail yet: current code only writes audit JSONL and exposes no supported reader API.", 2, { hint: "Use the OMP session history for operator audit context until a controlled-bash audit reader is added." });
+}
+async function executeInspect(context, args, deps = {}) {
+  const [command = "failures", ...rest] = args;
+  if (command === "--help" || command === "-h" || command === "help") {
+    if (context.outputMode === "text")
+      printInspectHelp();
+    return { ok: true, group: "inspect", command: "help" };
+  }
+  switch (command) {
+    case "logs":
+      return executeLogs(context, rest, deps);
+    case "artifact":
+      return executeArtifact(context, rest, deps);
+    case "artifacts":
+      return executeArtifacts(context, rest, deps);
+    case "run-logs":
+      return executeRunLogs(context, rest, deps);
+    case "runs":
+      return executeRuns(context, rest, deps);
+    case "diff":
+      return executeDiff(context, rest, deps);
+    case "graph":
+      return executeGraph(context, rest, deps);
+    case "failures":
+      return executeFailures(context, rest, deps);
+    case "audit":
+      return executeAudit(rest);
+    default:
+      throw new CliError3(`Unknown inspect command: ${command}`, 1, { hint: "Run `rig inspect --help` to list inspect commands." });
+  }
+}
+var RunReadModelCap5, TaskCliDataCap, taskCliData = (projectRoot) => requireCapabilityForRoot3(projectRoot, TaskCliDataCap, "CLI task-data capability unavailable: load @rig/tasks-plugin (default bundle)."), INSPECT_USAGE = "rig inspect <logs|artifact|artifacts|run-logs|runs|failures|graph|diff>";
+var init_inspect_command = __esm(() => {
+  init_run_format();
+  RunReadModelCap5 = defineCapability11(RUN_READ_MODEL5);
+  TaskCliDataCap = defineCapability11(TASK_CLI_DATA_CAPABILITY);
+});
+
+// packages/run-plugin/src/read-model/runs-screen.ts
+var exports_runs_screen = {};
+__export(exports_runs_screen, {
+  createRunsBoardView: () => createRunsBoardView
+});
+import {
+  DRONE_WIDTH,
+  RIG_SPINNER_FRAMES,
+  accent as accent2,
+  bold,
+  ink,
+  ink2,
+  ink3,
+  ink4,
+  phaseGlyph,
+  red,
+  renderDroneFrame,
+  statusRoleColor
+} from "@rig/std-shared/board-theme";
+function createRunsBoardView(host, deps) {
+  const { truncateToWidth, matchesKey } = deps;
+  let runs = [];
+  let selected = 0;
+  let loading = true;
+  let error = null;
+  let tick = 0;
+  let filter = "";
+  let sortMode = "active";
+  function visibleRuns() {
+    const query = filter.trim().toLowerCase();
+    const filtered = query ? runs.filter((run) => run.runId.toLowerCase().includes(query) || run.status.toLowerCase().includes(query) || run.title.toLowerCase().includes(query)) : [...runs];
+    if (sortMode === "active") {
+      return filtered.map((run, index) => ({ run, index })).sort((a, b) => a.run.rank - b.run.rank || a.index - b.index).map((entry) => entry.run);
+    }
+    if (sortMode === "status") {
+      return filtered.map((run, index) => ({ run, index })).sort((a, b) => a.run.status.localeCompare(b.run.status) || a.index - b.index).map((entry) => entry.run);
+    }
+    return filtered;
+  }
+  function clampSelection() {
+    selected = Math.max(0, Math.min(selected, Math.max(0, visibleRuns().length - 1)));
+  }
+  function moveSelection(delta) {
+    const visible = visibleRuns();
+    if (visible.length === 0)
+      return;
+    selected = Math.max(0, Math.min(visible.length - 1, selected + delta));
+  }
+  function selectedRun3() {
+    return visibleRuns()[selected] ?? null;
+  }
+  function setFilter(next) {
+    filter = next;
+    clampSelection();
+  }
+  function cycleSort() {
+    sortMode = sortMode === "active" ? "recent" : sortMode === "recent" ? "status" : "active";
+    clampSelection();
+    return sortMode;
+  }
+  function droneBoardLines(width, message, messageWidth) {
+    const spinner = RIG_SPINNER_FRAMES[tick % RIG_SPINNER_FRAMES.length];
+    if (width < DRONE_WIDTH + 4) {
+      return ["", ` ${accent2(spinner)} ${ink3(message)}`, ""];
+    }
+    const pad2 = " ".repeat(Math.max(0, Math.floor((width - DRONE_WIDTH) / 2)));
+    const msgPad = " ".repeat(Math.max(0, Math.floor((width - messageWidth) / 2)));
+    return [
+      "",
+      ...renderDroneFrame(tick).map((line) => pad2 + line),
+      "",
+      `${msgPad}${accent2(spinner)} ${ink3(message)}`,
+      ""
+    ];
+  }
+  function renderLines(width) {
+    if (loading) {
+      return droneBoardLines(width, "contacting the fleet\u2026", 24);
+    }
+    if (error) {
+      return ["", ` ${red("runs unavailable:")} ${ink2(error)}`, ""];
+    }
+    const visible = visibleRuns();
+    if (runs.length === 0) {
+      return droneBoardLines(width, "no runs yet \u2014 n picks a task and launches one", 44);
+    }
+    if (visible.length === 0) {
+      return ["", ` ${ink2("no runs match")} ${accent2(`/${filter}`)} ${ink3("\u2014 esc clears the filter")}`, ""];
+    }
+    const start = Math.max(0, Math.min(selected - Math.floor(MAX_VISIBLE / 2), visible.length - MAX_VISIBLE));
+    const window = visible.slice(start, start + MAX_VISIBLE);
+    const lines = window.map((run, index) => {
+      const isSelected = start + index === selected;
+      const color = statusRoleColor(run.role);
+      const dot = color(phaseGlyph(run.phase));
+      const id = run.runId.slice(0, 8);
+      const status = color(run.status.padEnd(16));
+      const title = truncateToWidth(run.title, Math.max(8, width - 36));
+      const row = ` ${dot} ${isSelected ? bold(ink(id)) : ink3(id)}  ${status} ${isSelected ? ink(title) : ink2(title)}`;
+      return isSelected ? accent2("\u258C") + row : " " + row;
+    });
+    const meta = [];
+    if (visible.length > MAX_VISIBLE)
+      meta.push(`${selected + 1}/${visible.length}`);
+    if (filter)
+      meta.push(`filter: ${filter}`);
+    meta.push(`sort: ${sortMode}`);
+    lines.push(ink4(`   ${meta.join("  \xB7  ")}`));
+    return ["", ...lines, ""];
+  }
+  function handleInput(data) {
+    const enc = (value) => encodeURIComponent(value);
+    if (matchesKey(data, "up") || data === "k") {
+      moveSelection(-1);
+      host.requestRender();
+      return true;
+    }
+    if (matchesKey(data, "down") || data === "j") {
+      moveSelection(1);
+      host.requestRender();
+      return true;
+    }
+    if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+      const run = selectedRun3();
+      if (run)
+        host.act(`run-detail:${enc(run.runId)}`);
+      return true;
+    }
+    if (data === "a") {
+      const run = selectedRun3();
+      if (run)
+        host.attach(run.runId);
+      return true;
+    }
+    if (data === "s") {
+      const run = selectedRun3();
+      if (run)
+        host.openSteer(run.runId);
+      return true;
+    }
+    if (data === "p") {
+      const run = selectedRun3();
+      if (run) {
+        host.setNotice(`pause requested for ${run.runId.slice(0, 8)}\u2026`);
+        host.act(`run-pause:${enc(run.runId)}`);
+      }
+      return true;
+    }
+    if (data === "u") {
+      const run = selectedRun3();
+      if (run) {
+        host.setNotice(`resume requested for ${run.runId.slice(0, 8)}\u2026`);
+        host.act(`run-resume:${enc(run.runId)}`);
+      }
+      return true;
+    }
+    if (data === "x") {
+      const run = selectedRun3();
+      if (run) {
+        host.setNotice(`stop requested for ${run.runId.slice(0, 8)}\u2026`);
+        host.act(`run-stop:${enc(run.runId)}`);
+      }
+      return true;
+    }
+    if (data === "n") {
+      host.navigate("tasks");
+      return true;
+    }
+    if (data === "/") {
+      host.openSearch(filter, setFilter);
+      return true;
+    }
+    if (data === "o") {
+      const mode = cycleSort();
+      host.setNotice(`sorted: ${mode}`);
+      host.requestRender();
+      return true;
+    }
+    if (matchesKey(data, "escape")) {
+      if (filter) {
+        setFilter("");
+        host.requestRender();
+        return true;
+      }
+      return false;
+    }
+    return false;
+  }
+  return {
+    render(width) {
+      return renderLines(width).map((line) => truncateToWidth(line, Math.max(10, width - 1)));
+    },
+    handleInput,
+    setBoard(board) {
+      if (board.kind !== "runs")
+        return;
+      const previous = selectedRun3()?.runId;
+      runs = [...board.runs];
+      if (previous) {
+        const index = visibleRuns().findIndex((run) => run.runId === previous);
+        if (index >= 0)
+          selected = index;
+      }
+      clampSelection();
+      loading = false;
+      error = null;
+    },
+    setError(next) {
+      error = next;
+    },
+    setTick(next) {
+      tick = next;
+    },
+    invalidate() {}
+  };
+}
+var MAX_VISIBLE = 16;
+var init_runs_screen = () => {};
+
+// packages/run-plugin/src/plugin.ts
+import { definePlugin as definePlugin3 } from "@rig/core/config";
+
+// 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;
+}
+
+// packages/run-plugin/src/read-model/plugin.ts
+import { defineCapability as defineCapability12 } from "@rig/core/capability";
+import { loadCapabilityForRoot as loadCapabilityForRoot6 } from "@rig/core/capability-loaders";
+import { definePlugin as definePlugin2 } from "@rig/core/config";
+import {
+  RIG_COCKPIT_PANEL_SLOT,
+  RUN_IDENTITY_ENV as RUN_IDENTITY_ENV2,
+  RUN_READ_MODEL as RUN_READ_MODEL6,
+  RUN_SESSION_JOURNAL as RUN_SESSION_JOURNAL3,
+  TASK_IO_SERVICE_CAPABILITY,
+  TASK_PROJECTION_CAPABILITY_ID
+} from "@rig/contracts";
+var RUN_READ_MODEL_PLUGIN_NAME = "@rig/run-plugin";
+var RunReadModelCap6 = defineCapability12(RUN_READ_MODEL6);
+var RunSessionJournalCap3 = defineCapability12(RUN_SESSION_JOURNAL3);
+var RunIdentityEnvCap2 = defineCapability12(RUN_IDENTITY_ENV2);
+var TaskIoCap = defineCapability12(TASK_IO_SERVICE_CAPABILITY);
+var TaskProjectionCap = defineCapability12(TASK_PROJECTION_CAPABILITY_ID);
+async function resolveDiscoveryFilter(projectRoot, identityContext) {
+  const identityEnv = await loadCapabilityForRoot6(projectRoot, RunIdentityEnvCap2);
+  return (identityContext && identityEnv ? identityEnv.resolveRigIdentityFilter(identityContext) : null) ?? {};
+}
+async function produceRunsBoard(context) {
+  const { projectRoot, identityContext, runs: providedRuns, runClassifications } = context ?? {};
+  if (!projectRoot)
+    return { kind: "runs", runs: [] };
+  const service = (await Promise.resolve().then(() => (init_read_model_service(), exports_read_model_service))).runReadModelService;
+  const runs = providedRuns ?? await service.listRuns({ projectRoot, discoveryFilter: await resolveDiscoveryFilter(projectRoot, identityContext) });
+  const rows = runs.map((run) => {
+    const classification = runClassifications?.get(run.runId) ?? service.classifyRun(run);
+    return {
+      runId: run.runId,
+      status: classification.status,
+      role: classification.role,
+      phase: classification.phase,
+      rank: classification.rank,
+      title: run.title
+    };
+  });
+  return { kind: "runs", runs: rows };
+}
+var statsCommand = {
+  id: `${RUN_READ_MODEL_PLUGIN_NAME}:stats`,
+  family: "stats",
+  description: "Inspect run statistics.",
+  projectRequired: true,
+  run: async (context, args) => (await Promise.resolve().then(() => (init_stats_command(), exports_stats_command))).executeStats(context, [...args]),
+  helpDoc: {
+    name: "stats",
+    summary: "Legacy automation-only metrics over old run records; not the OMP live UX.",
+    usage: ["rig stats [show] [--since <7d|30d|ISO date>]"],
+    commands: [
+      { command: "show [--since <window>]", description: "Legacy automation-only: totals, completion/failure rates, run time, steering, stalls, approvals.", primary: true }
+    ],
+    examples: [
+      "rig stats --json # legacy automation only"
+    ],
+    next: ["For normal UX, use the OMP Runs screen."]
+  }
+};
+var inspectCommand = {
+  id: `${RUN_READ_MODEL_PLUGIN_NAME}:inspect`,
+  family: "inspect",
+  description: "Inspect live/project Rig state.",
+  projectRequired: false,
+  run: async (context, args) => (await Promise.resolve().then(() => (init_inspect_command(), exports_inspect_command))).executeInspect(context, [...args]),
+  helpDoc: {
+    name: "inspect",
+    summary: "Legacy automation-only artifact/log inspection; normal UX is OMP session history.",
+    usage: ["rig inspect <logs|artifact|artifacts|run-logs|runs|failures|graph|diff> [options]"],
+    commands: [
+      { command: "logs --task <id>", description: "Legacy automation-only: latest old run log for a task.", primary: true },
+      { command: "run-logs --run <id>", description: "Legacy automation-only: log lines for a specific run.", primary: true },
+      { command: "runs", description: "Legacy automation-only: list projected runs." },
+      { command: "artifact --task <id> --file <name>", description: "Legacy automation-only: preview one completion artifact." },
+      { command: "artifacts --task <id>", description: "Legacy automation-only: list completion artifacts.", primary: true },
+      { command: "diff --task <id>", description: "Legacy automation-only: list task changed files." },
+      { command: "failures --task <id>", description: "Legacy automation-only: recorded failures for a task.", primary: true },
+      { command: "graph [--task <id>]", description: "Legacy automation-only: task dependency graph." }
+    ],
+    next: ["For normal UX, use the OMP Runs screen and OMP session history."]
+  }
+};
+var runReadModelPlugin = definePlugin2({
+  name: RUN_READ_MODEL_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  effects: { readsFiles: true, contributesCliCommands: true, contributesPanels: true },
+  contributes: {
+    capabilities: [
+      RunReadModelCap6.provide(async () => (await Promise.resolve().then(() => (init_read_model_service(), exports_read_model_service))).runReadModelService, {
+        title: "Run read-model service",
+        description: "List, inspect, summarize, and classify canonical run session projections for operator surfaces."
+      }),
+      RunSessionJournalCap3.provide(async () => (await Promise.resolve().then(() => (init_session_journal(), exports_session_journal))).runSessionJournalCodec, {
+        title: "Run session-journal codec",
+        description: "Fold run-session entries into projections, extract timelines, and parse control sentinels."
+      })
+    ],
+    cliCommands: [statsCommand, inspectCommand],
+    panels: [
+      {
+        id: "runs",
+        slot: RIG_COCKPIT_PANEL_SLOT,
+        title: "Runs",
+        description: "Dispatched Rig runs and live OMP collaborative sessions.",
+        produceBoard: produceRunsBoard,
+        createView: async (host) => {
+          const { truncateToWidth, matchesKey } = await import("@oh-my-pi/pi-tui");
+          return (await Promise.resolve().then(() => (init_runs_screen(), exports_runs_screen))).createRunsBoardView(host, { truncateToWidth, matchesKey });
+        },
+        screen: {
+          title: "Runs",
+          navOrder: 2,
+          navLabel: "RUNS",
+          navDescription: "attach to dispatched Rig runs and live OMP collaborative sessions",
+          shortcutKey: "r",
+          shortcutDescription: "Rig runs"
+        }
+      }
+    ]
+  }
+});
+function createRunReadModelPlugin() {
+  return runReadModelPlugin;
+}
+
+// packages/run-plugin/src/plugin.ts
+var RUN_PLUGIN_NAME = "@rig/run-plugin";
+function createRunPlugin() {
+  const parts = [createRunWorkerPlugin(), createRunReadModelPlugin()];
+  return definePlugin3({
+    name: RUN_PLUGIN_NAME,
+    version: "0.0.0-alpha.1",
+    effects: {
+      readsFiles: true,
+      writesFiles: true,
+      spawnsProcesses: true,
+      opensNetwork: true,
+      contributesCliCommands: true,
+      contributesPanels: true
+    },
+    contributes: {
+      capabilities: parts.flatMap((p) => [...p.contributes?.capabilities ?? []]),
+      cliCommands: parts.flatMap((p) => [...p.contributes?.cliCommands ?? []]),
+      panels: parts.flatMap((p) => [...p.contributes?.panels ?? []]),
+      seedEntrypoints: parts.flatMap((p) => [...p.contributes?.seedEntrypoints ?? []]),
+      sessionExtensions: parts.flatMap((p) => [...p.contributes?.sessionExtensions ?? []])
+    }
+  });
+}
+var plugin_default = createRunPlugin;
+export {
+  plugin_default as default,
+  createRunPlugin,
+  RUN_PLUGIN_NAME
+};