@h-rig/rig-extension 0.0.6-alpha.100

package/dist/src/extension.js

@@ -0,0 +1,3757 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/rig-extension/src/extension.ts
+import { spawnSync } from "child_process";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import {
+  SessionManager
+} from "@oh-my-pi/pi-coding-agent";
+import {
+  listCollabSessionProjections
+} from "@oh-my-pi/pi-coding-agent/collab/api";
+import { buildStopSentinel, CUSTOM_TYPE_FOR, foldRunSessionEntries, parseStopSentinel, RIG_RUN_STEERING, sessionIdFromSessionFile } from "@rig/contracts";
+import { buildRigInitConfigSource, computeTaskDependencyBadges, selectNextReadyTaskByPriority, selectTasksAssignedToMe, selectTasksGroupedByStatus } from "@rig/core";
+import { createEnvCloseoutRunners } from "@rig/runtime/control-plane/native/closeout-runners";
+import { runInProcessCloseout } from "@rig/runtime/control-plane/native/in-process-closeout";
+import { projectRunFromSession } from "@rig/runtime/control-plane/run-session-projection";
+import { listManagedRemoteEndpoints, resolveOwnerNamespaceKey, resolveRegistryBaseUrl, resolveRegistrySecret, resolveRelayUrl, resolveSelectedRemote, upsertManagedRemoteEndpoint } from "@rig/runtime/control-plane/remote";
+import { resolveAuthorityPaths } from "@rig/runtime/control-plane/server-paths";
+import { listAgentRuntimes } from "@rig/runtime/control-plane/runtime/isolation";
+import { updateRunTaskSourceLifecycle } from "@rig/runtime/control-plane/tasks/source-lifecycle";
+import { dispatchEventToTargets, loadNotificationConfig } from "@rig/runtime/control-plane/notifications";
+import {
+  beginGitHubDeviceFlow,
+  createGitHubAuthStore,
+  pollGitHubDeviceFlow,
+  probeGitHubRepository,
+  resolveGitHubAuthStatus,
+  saveGitHubTokenForProject
+} from "@rig/runtime/control-plane/github";
+import { createRegistryClient } from "@rig/relay-registry";
+import { deriveOwnerToken } from "@rig/relay-registry/auth";
+import { isKeyRelease, matchesKey } from "@oh-my-pi/pi-tui";
+import { Duration, Effect, Fiber, Stream } from "effect";
+import { localRunChanges, remoteRunChanges } from "@rig/runtime/control-plane/run-discovery-stream";
+import { forkDiscoverySources, RunDiscoveryBus } from "@rig/runtime/control-plane/run-discovery-bus";
+
+// packages/rig-extension/src/board-views.ts
+import { helpCatalog } from "@rig/contracts";
+import { truncateToWidth } from "@oh-my-pi/pi-tui";
+
+// packages/rig-extension/src/board-theme.ts
+var RIG_PALETTE = {
+  ink: "#f2f3f6",
+  ink2: "#aeb0ba",
+  ink3: "#6c6e79",
+  ink4: "#44464f",
+  accent: "#ccff4d",
+  accentDim: "#a9d63f",
+  cyan: "#56d8ff",
+  red: "#ff5d5d",
+  yellow: "#ffd24d"
+};
+function hexToRgb(hex) {
+  const value = hex.replace("#", "");
+  return [
+    Number.parseInt(value.slice(0, 2), 16),
+    Number.parseInt(value.slice(2, 4), 16),
+    Number.parseInt(value.slice(4, 6), 16)
+  ];
+}
+function fg(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[39m`;
+}
+var ink = fg(RIG_PALETTE.ink);
+var ink2 = fg(RIG_PALETTE.ink2);
+var ink3 = fg(RIG_PALETTE.ink3);
+var ink4 = fg(RIG_PALETTE.ink4);
+var accent = fg(RIG_PALETTE.accent);
+var accentDim = fg(RIG_PALETTE.accentDim);
+var cyan = fg(RIG_PALETTE.cyan);
+var red = fg(RIG_PALETTE.red);
+var yellow = fg(RIG_PALETTE.yellow);
+function bold(text) {
+  return `\x1B[1m${text}\x1B[22m`;
+}
+function statusColor(status) {
+  switch (status) {
+    case "running":
+      return accent;
+    case "preparing":
+    case "created":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return cyan;
+    case "needs-attention":
+    case "needs_attention":
+      return yellow;
+    case "failed":
+      return red;
+    default:
+      return ink3;
+  }
+}
+var RIG_SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var DRONE_ART = [
+  "  .-=-.                   .-=-.   ",
+  " ( !!! )                 ( !!! )  ",
+  "  '-=-'._               _.'-=-'   ",
+  "        '._           _.'         ",
+  "           '=$$$$$$$=.'           ",
+  "          =$$$$$$$$$$$=           ",
+  "         $$$@@@@@@@@@@$$$         ",
+  "        $$$@@        @@$$$        ",
+  "        $$@    ?     @$$$         ",
+  "        $$$@   '-'   @$$$         ",
+  "        $$$@@        @@$$$        ",
+  "         $$$@@@@@@@@@@$$$         ",
+  "          =$$$$$$$$$$$=           ",
+  "           '=$$$$$$$=.'           ",
+  "        _.'           '._         ",
+  "  .-=-.'                 '.-=-.   ",
+  " ( !!! )                 ( !!! )  ",
+  "  '-=-'                   '-=-'   "
+];
+var BLADE_FRAMES = ["---", "\\\\\\", "|||", "///"];
+var EYE_FRAMES = ["@", "o", "."];
+function droneCharColor(char) {
+  if (char === "$" || char === "@")
+    return accent;
+  if (char === "=" || char === "%")
+    return accentDim;
+  if (char === "\\" || char === "/")
+    return ink3;
+  return ink4;
+}
+function renderDroneFrame(tick) {
+  const blade = BLADE_FRAMES[Math.floor(tick / 4) % BLADE_FRAMES.length];
+  const pulse = Math.sin(tick * 0.07);
+  const eye = pulse > 0.45 ? EYE_FRAMES[0] : pulse > -0.1 ? EYE_FRAMES[1] : EYE_FRAMES[2];
+  return DRONE_ART.map((line) => {
+    let out = "";
+    let index = 0;
+    while (index < line.length) {
+      if (line.startsWith("!!!", index)) {
+        out += cyan(blade);
+        index += 3;
+        continue;
+      }
+      const char = line[index];
+      if (char === "?") {
+        out += bold(cyan(eye));
+      } else if (char !== " ") {
+        out += droneCharColor(char)(char);
+      } else {
+        out += " ";
+      }
+      index += 1;
+    }
+    return out;
+  });
+}
+var DRONE_WIDTH = DRONE_ART[0].length;
+var DRONE_HEIGHT = DRONE_ART.length;
+var MICRO_BLADES = ["---", "\\\\\\", "|||", "///"];
+function microDroneFrame(tick) {
+  const blade = MICRO_BLADES[tick % MICRO_BLADES.length];
+  const eye = EYE_FRAMES[Math.floor(tick / 2) % EYE_FRAMES.length];
+  return `(${blade})${eye}(${blade})`;
+}
+var MICRO_DRONE_FRAMES = Array.from({ length: 12 }, (_, index) => microDroneFrame(index));
+
+// packages/rig-extension/src/board-views.ts
+function hairline(width) {
+  return ink4("\u2500".repeat(Math.max(0, width)));
+}
+function statusRank(status) {
+  switch (status) {
+    case "needs-attention":
+    case "needs_attention":
+      return 0;
+    case "running":
+      return 1;
+    case "pending":
+    case "preparing":
+    case "adopted":
+      return 2;
+    case "completed":
+    case "merged":
+      return 3;
+    case "failed":
+      return 4;
+    default:
+      return 5;
+  }
+}
+
+class RunsList {
+  runs = [];
+  selected = 0;
+  loading = true;
+  noProject = false;
+  tick = 0;
+  filter = "";
+  sortMode = "active";
+  visibleRuns() {
+    const query = this.filter.trim().toLowerCase();
+    const filtered = query ? this.runs.filter((run) => run.runId.toLowerCase().includes(query) || run.status.toLowerCase().includes(query) || run.title.toLowerCase().includes(query)) : [...this.runs];
+    if (this.sortMode === "active") {
+      return filtered.map((run, index) => ({ run, index })).sort((a, b) => statusRank(a.run.status) - statusRank(b.run.status) || a.index - b.index).map((entry) => entry.run);
+    }
+    if (this.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;
+  }
+  moveSelection(delta) {
+    const visible = this.visibleRuns();
+    if (visible.length === 0)
+      return;
+    this.selected = Math.max(0, Math.min(visible.length - 1, this.selected + delta));
+  }
+  selectedRun() {
+    return this.visibleRuns()[this.selected] ?? null;
+  }
+  cycleSort() {
+    this.sortMode = this.sortMode === "active" ? "recent" : this.sortMode === "recent" ? "status" : "active";
+    this.clampSelection();
+    return this.sortMode;
+  }
+  setFilter(filter) {
+    this.filter = filter;
+    this.clampSelection();
+  }
+  clampSelection() {
+    this.selected = Math.max(0, Math.min(this.selected, Math.max(0, this.visibleRuns().length - 1)));
+  }
+  setRuns(runs) {
+    const previous = this.selectedRun()?.runId;
+    this.runs = runs;
+    if (previous) {
+      const index = this.visibleRuns().findIndex((run) => run.runId === previous);
+      if (index >= 0)
+        this.selected = index;
+    }
+    this.clampSelection();
+    this.loading = false;
+  }
+  invalidate() {}
+  render(width) {
+    return this.renderLines(width).map((line) => truncateToWidth(line, Math.max(10, width - 1)));
+  }
+  renderLines(width) {
+    if (this.loading) {
+      const frame = renderDroneFrame(this.tick);
+      const spinner = RIG_SPINNER_FRAMES[this.tick % RIG_SPINNER_FRAMES.length];
+      const pad = Math.max(0, Math.floor((width - 34) / 2));
+      return [
+        "",
+        ...frame.map((line) => " ".repeat(pad) + line),
+        "",
+        " ".repeat(Math.max(0, Math.floor((width - 24) / 2))) + accent(spinner) + ink3(" contacting the fleet\u2026"),
+        ""
+      ];
+    }
+    if (this.noProject) {
+      const frame = renderDroneFrame(this.tick);
+      const pad = Math.max(0, Math.floor((width - 34) / 2));
+      const center = (text, visible2) => " ".repeat(Math.max(0, Math.floor((width - visible2) / 2))) + text;
+      return [
+        "",
+        ...frame.map((line) => " ".repeat(pad) + line),
+        "",
+        center(ink2("no rig project in this directory"), 32),
+        "",
+        center(`${accent("rig init")}${ink2("        set this repo up: config, GitHub auth, task source, server, Pi")}`, 80),
+        center(`${accent("rig init --yes")}${ink2("  same, non-interactive, sensible defaults")}`, 60),
+        center(`${accent("rig doctor")}${ink2("      already initialized somewhere else? check the wiring")}`, 70),
+        "",
+        center(ink3("after init: rig task run --next puts a drone on your next task"), 62),
+        ""
+      ];
+    }
+    const visible = this.visibleRuns();
+    if (this.runs.length === 0) {
+      const frame = renderDroneFrame(this.tick);
+      const pad = Math.max(0, Math.floor((width - 34) / 2));
+      return [
+        "",
+        ...frame.map((line) => " ".repeat(pad) + line),
+        "",
+        " ".repeat(Math.max(0, Math.floor((width - 44) / 2))) + ink2("no runs yet \u2014 ") + accent("n") + ink2(" picks a task and launches one"),
+        ""
+      ];
+    }
+    if (visible.length === 0) {
+      return ["", ` ${ink2("no runs match")} ${accent(`/${this.filter}`)} ${ink3("\u2014 esc clears the filter")}`, ""];
+    }
+    const maxVisible = 16;
+    const start = Math.max(0, Math.min(this.selected - Math.floor(maxVisible / 2), visible.length - maxVisible));
+    const window = visible.slice(start, start + maxVisible);
+    const lines = window.map((run, index) => {
+      const absolute = start + index;
+      const isSelected = absolute === this.selected;
+      const dot = statusColor(run.status)(isSelected ? "\u25CF" : "\xB7");
+      const id = run.runId.slice(0, 8);
+      const status = statusColor(run.status)(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 ? accent("\u258C") + row : " " + row;
+    });
+    const meta = [];
+    if (visible.length > maxVisible)
+      meta.push(`${this.selected + 1}/${visible.length}`);
+    if (this.filter)
+      meta.push(`filter: ${this.filter}`);
+    meta.push(`sort: ${this.sortMode}`);
+    lines.push(ink4(`   ${meta.join("  \xB7  ")}`));
+    return ["", ...lines, ""];
+  }
+}
+
+class TasksView {
+  tasks = [];
+  selected = 0;
+  loading = true;
+  error = null;
+  tick = 0;
+  setTasks(tasks) {
+    this.tasks = tasks;
+    this.selected = Math.min(this.selected, Math.max(0, tasks.length - 1));
+    this.loading = false;
+    this.error = null;
+  }
+  moveSelection(delta) {
+    if (this.tasks.length === 0)
+      return;
+    this.selected = Math.max(0, Math.min(this.tasks.length - 1, this.selected + delta));
+  }
+  selectedTask() {
+    return this.tasks[this.selected] ?? null;
+  }
+  invalidate() {}
+  render(width) {
+    return this.renderLines(width).map((line) => truncateToWidth(line, Math.max(10, width - 1)));
+  }
+  renderLines(width) {
+    if (this.loading) {
+      const spinner = RIG_SPINNER_FRAMES[this.tick % RIG_SPINNER_FRAMES.length];
+      return ["", ` ${accent(spinner)} ${ink3("reading tasks from the server\u2026")}`, ""];
+    }
+    if (this.error) {
+      return ["", ` ${red("tasks unavailable:")} ${ink2(this.error)}`, ""];
+    }
+    if (this.tasks.length === 0) {
+      return ["", ` ${ink2("no ready tasks \u2014 the task source is drained")}`, ""];
+    }
+    const maxVisible = 16;
+    const start = Math.max(0, Math.min(this.selected - Math.floor(maxVisible / 2), this.tasks.length - maxVisible));
+    const window = this.tasks.slice(start, start + maxVisible);
+    const lines = window.map((task, index) => {
+      const absolute = start + index;
+      const isSelected = absolute === this.selected;
+      const id = task.id.padEnd(8).slice(0, 12);
+      const status = statusColor(task.status)(task.status.padEnd(12));
+      const title = truncateToWidth(task.title, Math.max(8, width - 32));
+      const row = ` ${isSelected ? bold(ink(id)) : ink3(id)} ${status} ${isSelected ? ink(title) : ink2(title)}`;
+      return isSelected ? accent("\u258C") + row : " " + row;
+    });
+    if (this.tasks.length > maxVisible)
+      lines.push(ink4(`   ${this.selected + 1}/${this.tasks.length}`));
+    return ["", ...lines, ""];
+  }
+}
+
+class InboxView {
+  items = [];
+  selected = 0;
+  loading = true;
+  error = null;
+  tick = 0;
+  setItems(items) {
+    this.items = items;
+    this.selected = Math.min(this.selected, Math.max(0, items.length - 1));
+    this.loading = false;
+    this.error = null;
+  }
+  moveSelection(delta) {
+    if (this.items.length === 0)
+      return;
+    this.selected = Math.max(0, Math.min(this.items.length - 1, this.selected + delta));
+  }
+  selectedItem() {
+    return this.items[this.selected] ?? null;
+  }
+  invalidate() {}
+  render(width) {
+    return this.renderLines(width).map((line) => truncateToWidth(line, Math.max(10, width - 1)));
+  }
+  renderLines(width) {
+    if (this.loading) {
+      const spinner = RIG_SPINNER_FRAMES[this.tick % RIG_SPINNER_FRAMES.length];
+      return ["", ` ${accent(spinner)} ${ink3("reading the inbox\u2026")}`, ""];
+    }
+    if (this.error) {
+      return ["", ` ${red("inbox unavailable:")} ${ink2(this.error)}`, ""];
+    }
+    if (this.items.length === 0) {
+      return ["", ` ${ink2("inbox clear \u2014 no drone is waiting on you")}`, ""];
+    }
+    const maxVisible = 14;
+    const start = Math.max(0, Math.min(this.selected - Math.floor(maxVisible / 2), this.items.length - maxVisible));
+    const window = this.items.slice(start, start + maxVisible);
+    const lines = window.flatMap((item, index) => {
+      const absolute = start + index;
+      const isSelected = absolute === this.selected;
+      const kind = item.kind === "approval" ? accentDim("approval") : cyan("input   ");
+      const run = item.runId.slice(0, 8);
+      const summary = truncateToWidth(item.summary, Math.max(8, width - 30));
+      const row = ` ${kind} ${isSelected ? bold(ink(run)) : ink3(run)}  ${isSelected ? ink(summary) : ink2(summary)}`;
+      const main = isSelected ? accent("\u258C") + row : " " + row;
+      if (isSelected && item.kind === "input" && item.options.length > 0) {
+        return [main, ink4(`     options: ${item.options.join(" \xB7 ")}`)];
+      }
+      return [main];
+    });
+    if (this.items.length > maxVisible)
+      lines.push(ink4(`   ${this.selected + 1}/${this.items.length}`));
+    return ["", ...lines, ""];
+  }
+}
+class HelpView {
+  group;
+  offset = 0;
+  #built = null;
+  constructor(group) {
+    this.group = group;
+  }
+  #build(width) {
+    if (this.#built)
+      return this.#built;
+    const { sections, groups } = helpCatalog();
+    const lines = [];
+    const groupAnchors = new Map;
+    const columnWidth = Math.min(38, Math.max(24, Math.floor(width * 0.4)));
+    const row = (command, description) => {
+      const left = command.length >= columnWidth ? `${command}  ` : command.padEnd(columnWidth);
+      return `  ${bold(ink(left))} ${ink2(truncateToWidth(description, Math.max(16, width - columnWidth - 4)))}`;
+    };
+    for (const section of sections) {
+      lines.push(`${accent("\u25C7")} ${bold(ink(section.title))} ${ink3(`\u2014 ${section.subtitle}`)}`);
+      for (const command of section.commands)
+        lines.push(row(command.command, command.description));
+      lines.push("");
+    }
+    lines.push(`${accent("\u25C7")} ${bold(ink("command groups"))} ${ink3("\u2014 every `rig <group>` surface")}`);
+    lines.push("");
+    for (const group of groups) {
+      groupAnchors.set(group.name, lines.length);
+      lines.push(`${accentDim("\u258D")}${bold(ink(`rig ${group.name}`))} ${ink3(`\u2014 ${group.summary}`)}`);
+      for (const usage of group.usage)
+        lines.push(`  ${cyan(usage)}`);
+      for (const command of group.commands)
+        lines.push(row(command.command, command.description));
+      if (group.examples?.length) {
+        for (const example of group.examples)
+          lines.push(`  ${ink4("$")} ${ink2(example)}`);
+      }
+      if (group.next?.length) {
+        for (const next of group.next)
+          lines.push(`  ${accent("\u203A")} ${ink3(next)}`);
+      }
+      lines.push("");
+    }
+    this.#built = { lines, groupAnchors };
+    if (this.group) {
+      const anchor = groupAnchors.get(this.group);
+      if (anchor !== undefined)
+        this.offset = anchor;
+    }
+    return this.#built;
+  }
+  scroll(delta) {
+    if (!this.#built)
+      return;
+    const max = Math.max(0, this.#built.lines.length - 10);
+    this.offset = Math.max(0, Math.min(max, this.offset + delta));
+  }
+  invalidate() {
+    this.#built = null;
+  }
+  render(width) {
+    const { lines } = this.#build(width);
+    const viewport = Math.max(10, (process.stdout.rows ?? 30) - 8);
+    const slice = lines.slice(this.offset, this.offset + viewport);
+    const more = this.offset + viewport < lines.length;
+    return [
+      "",
+      ...slice.map((line) => truncateToWidth(` ${line}`, Math.max(10, width - 1))),
+      more ? ink4(`   \u2026 ${lines.length - this.offset - viewport} more (\u2193)`) : ""
+    ];
+  }
+}
+
+// packages/rig-extension/src/workflow/projections.ts
+var RIG_WORKFLOW_STARTED = "rig.workflow.started";
+var RIG_WORKFLOW_TARGET_SELECTED = "rig.workflow.target.selected";
+var RIG_WORKFLOW_TASK_SELECTED = "rig.workflow.task.selected";
+var RIG_WORKFLOW_STATUS_CHANGED = "rig.workflow.status.changed";
+var RIG_WORKFLOW_OPERATOR_NOTE = "rig.workflow.operator.note";
+var RIG_WORKFLOW_INBOX_REQUESTED = "rig.workflow.inbox.requested";
+var RIG_WORKFLOW_INBOX_RESOLVED = "rig.workflow.inbox.resolved";
+var EMPTY_PROJECTION = {
+  started: null,
+  target: null,
+  task: null,
+  status: null,
+  notes: [],
+  inbox: [],
+  resolvedInbox: [],
+  updatedAt: null
+};
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function requiredString(value) {
+  const text = optionalString(value);
+  return text ?? null;
+}
+function timestamp(value) {
+  const text = requiredString(value);
+  if (!text)
+    return null;
+  const millis = Date.parse(text);
+  return Number.isFinite(millis) ? text : null;
+}
+function newer(left, right) {
+  if (!right)
+    return false;
+  if (!left)
+    return true;
+  return Date.parse(right) >= Date.parse(left);
+}
+function isWorkflowTarget(value) {
+  return value === "local" || value === "remote";
+}
+function isWorkflowStatus(value) {
+  return value === "starting" || value === "running" || value === "waiting-approval" || value === "waiting-input" || value === "completed" || value === "failed" || value === "stopped";
+}
+function isInboxKind(value) {
+  return value === "approval" || value === "input";
+}
+function isInboxDecision(value) {
+  return value === "approved" || value === "rejected" || value === "answered";
+}
+function parseOwner(value) {
+  const record = asRecord(value);
+  if (!record)
+    return null;
+  const githubUserId = requiredString(record.githubUserId);
+  const login = requiredString(record.login);
+  const namespaceKey = requiredString(record.namespaceKey);
+  return githubUserId && login && namespaceKey ? { githubUserId, login, namespaceKey } : null;
+}
+function parseStringArray(value) {
+  if (!Array.isArray(value))
+    return;
+  const options = value.map(optionalString).filter((option) => option !== undefined);
+  return options.length > 0 ? options : undefined;
+}
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function entryUpdatedAt(entry) {
+  if ("createdAt" in entry)
+    return entry.createdAt;
+  if ("selectedAt" in entry)
+    return entry.selectedAt;
+  if ("changedAt" in entry)
+    return entry.changedAt;
+  if ("notedAt" in entry)
+    return entry.notedAt;
+  if ("requestedAt" in entry)
+    return entry.requestedAt;
+  return entry.resolvedAt;
+}
+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()
+  };
+}
+function createWorkflowInboxRequested(input) {
+  return {
+    schemaVersion: 1,
+    requestId: input.requestId,
+    kind: input.kind,
+    title: input.title,
+    ...input.body ? { body: input.body } : {},
+    ...input.options && input.options.length > 0 ? { options: input.options } : {},
+    requestedAt: input.requestedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowInboxResolved(input) {
+  const base = {
+    schemaVersion: 1,
+    requestId: input.requestId,
+    decision: input.decision,
+    resolvedAt: input.resolvedAt ?? new Date().toISOString()
+  };
+  return hasOwn(input, "answer") ? { ...base, answer: input.answer } : base;
+}
+function parseWorkflowStarted(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const workflowId = requiredString(record.workflowId);
+  const target = optionalString(record.target);
+  const selectedRepo = requiredString(record.selectedRepo);
+  const owner = parseOwner(record.owner);
+  const createdAt = timestamp(record.createdAt);
+  if (!workflowId || !isWorkflowTarget(target) || !selectedRepo || !owner || !createdAt)
+    return null;
+  return {
+    schemaVersion: 1,
+    workflowId,
+    target,
+    selectedRepo,
+    owner,
+    createdAt
+  };
+}
+function parseWorkflowTargetSelected(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const target = optionalString(record.target);
+  const selectedAt = timestamp(record.selectedAt);
+  if (!isWorkflowTarget(target) || !selectedAt)
+    return null;
+  const reason = optionalString(record.reason);
+  return {
+    schemaVersion: 1,
+    target,
+    ...reason ? { reason } : {},
+    selectedAt
+  };
+}
+function parseWorkflowTaskSelected(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const taskId = requiredString(record.taskId);
+  const selectedAt = timestamp(record.selectedAt);
+  if (!taskId || !selectedAt)
+    return null;
+  const title = optionalString(record.title);
+  return { schemaVersion: 1, taskId, ...title ? { title } : {}, selectedAt };
+}
+function parseWorkflowStatusChanged(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const status = optionalString(record.status);
+  const changedAt = timestamp(record.changedAt);
+  if (!changedAt || !isWorkflowStatus(status))
+    return null;
+  const detail = optionalString(record.detail);
+  return { schemaVersion: 1, status, ...detail ? { detail } : {}, changedAt };
+}
+function parseWorkflowOperatorNote(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const note = requiredString(record.note);
+  const notedAt = timestamp(record.notedAt);
+  if (!note || !notedAt)
+    return null;
+  const noteId = optionalString(record.noteId);
+  return { schemaVersion: 1, ...noteId ? { noteId } : {}, note, notedAt };
+}
+function parseWorkflowInboxRequested(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const requestId = requiredString(record.requestId);
+  const kind = optionalString(record.kind);
+  const title = requiredString(record.title);
+  const requestedAt = timestamp(record.requestedAt);
+  if (!requestId || !isInboxKind(kind) || !title || !requestedAt)
+    return null;
+  const body = optionalString(record.body);
+  const options = parseStringArray(record.options);
+  return {
+    schemaVersion: 1,
+    requestId,
+    kind,
+    title,
+    ...body ? { body } : {},
+    ...options ? { options } : {},
+    requestedAt
+  };
+}
+function parseWorkflowInboxResolved(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const requestId = requiredString(record.requestId);
+  const decision = optionalString(record.decision);
+  const resolvedAt = timestamp(record.resolvedAt);
+  if (!requestId || !isInboxDecision(decision) || !resolvedAt)
+    return null;
+  const base = { schemaVersion: 1, requestId, decision, resolvedAt };
+  return hasOwn(record, "answer") ? { ...base, answer: record.answer } : base;
+}
+function collectPendingInboxRequests(entries) {
+  const requested = new Map;
+  const resolved = new Map;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType === RIG_WORKFLOW_INBOX_REQUESTED) {
+      const request = parseWorkflowInboxRequested(entry.data);
+      if (request && newer(requested.get(request.requestId)?.requestedAt, request.requestedAt))
+        requested.set(request.requestId, request);
+    } else if (entry.customType === RIG_WORKFLOW_INBOX_RESOLVED) {
+      const resolution = parseWorkflowInboxResolved(entry.data);
+      if (resolution && newer(resolved.get(resolution.requestId), resolution.resolvedAt))
+        resolved.set(resolution.requestId, resolution.resolvedAt);
+    }
+  }
+  for (const [requestId, request] of requested) {
+    const resolvedAt = resolved.get(requestId);
+    if (resolvedAt && Date.parse(resolvedAt) >= Date.parse(request.requestedAt))
+      requested.delete(requestId);
+  }
+  return Array.from(requested.values()).sort((a, b) => Date.parse(b.requestedAt) - Date.parse(a.requestedAt));
+}
+function collectResolvedInboxRequests(entries) {
+  const requested = new Map;
+  const resolved = new Map;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType === RIG_WORKFLOW_INBOX_REQUESTED) {
+      const request = parseWorkflowInboxRequested(entry.data);
+      if (request && newer(requested.get(request.requestId), request.requestedAt))
+        requested.set(request.requestId, request.requestedAt);
+    } else if (entry.customType === RIG_WORKFLOW_INBOX_RESOLVED) {
+      const resolution = parseWorkflowInboxResolved(entry.data);
+      if (resolution && newer(resolved.get(resolution.requestId)?.resolvedAt, resolution.resolvedAt)) {
+        resolved.set(resolution.requestId, resolution);
+      }
+    }
+  }
+  for (const [requestId, resolution] of resolved) {
+    const requestedAt = requested.get(requestId);
+    if (requestedAt && Date.parse(requestedAt) > Date.parse(resolution.resolvedAt))
+      resolved.delete(requestId);
+  }
+  return Array.from(resolved.values()).sort((a, b) => Date.parse(b.resolvedAt) - Date.parse(a.resolvedAt));
+}
+function projectCollabWorkflowMarker(collab) {
+  const status = createWorkflowStatusChanged({
+    status: collab.stale ? "stopped" : "running",
+    detail: collab.stale ? "Stale OMP collab session discovered from the sanctioned collab registry." : "Live OMP collab session discovered from the sanctioned collab registry.",
+    changedAt: collab.updatedAt
+  });
+  return {
+    started: null,
+    target: null,
+    task: null,
+    status,
+    notes: [],
+    inbox: [],
+    resolvedInbox: [],
+    updatedAt: newer(collab.startedAt, collab.updatedAt) ? collab.updatedAt : collab.startedAt
+  };
+}
+function projectWorkflowEntries(entries) {
+  let started = null;
+  let target = null;
+  let task = null;
+  let status = null;
+  const notes = [];
+  let updatedAt = null;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType === RIG_WORKFLOW_STARTED) {
+      const parsed = parseWorkflowStarted(entry.data);
+      if (parsed && newer(started?.createdAt, parsed.createdAt))
+        started = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_TARGET_SELECTED) {
+      const parsed = parseWorkflowTargetSelected(entry.data);
+      if (parsed && newer(target?.selectedAt, parsed.selectedAt))
+        target = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_TASK_SELECTED) {
+      const parsed = parseWorkflowTaskSelected(entry.data);
+      if (parsed && newer(task?.selectedAt, parsed.selectedAt))
+        task = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_STATUS_CHANGED) {
+      const parsed = parseWorkflowStatusChanged(entry.data);
+      if (parsed && newer(status?.changedAt, parsed.changedAt))
+        status = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_OPERATOR_NOTE) {
+      const parsed = parseWorkflowOperatorNote(entry.data);
+      if (parsed)
+        notes.push(parsed);
+    }
+  }
+  notes.sort((a, b) => Date.parse(b.notedAt) - Date.parse(a.notedAt));
+  for (const value of [started, target, task, status, ...notes].map((entry) => entry ? entryUpdatedAt(entry) : null)) {
+    if (newer(updatedAt, value))
+      updatedAt = value;
+  }
+  const inbox = collectPendingInboxRequests(entries);
+  const resolvedInbox = collectResolvedInboxRequests(entries);
+  for (const entry of [...inbox, ...resolvedInbox]) {
+    if (newer(updatedAt, entryUpdatedAt(entry)))
+      updatedAt = entryUpdatedAt(entry);
+  }
+  if (!started && !target && !task && !status && notes.length === 0 && inbox.length === 0 && resolvedInbox.length === 0 && !updatedAt)
+    return EMPTY_PROJECTION;
+  return { started, target, task, status, notes, inbox, resolvedInbox, updatedAt };
+}
+
+// packages/rig-extension/src/workflow/identity.ts
+function stringField(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function numericStringField(value) {
+  return typeof value === "number" && Number.isInteger(value) ? String(value) : stringField(value);
+}
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function customEntries(entries) {
+  const customs = [];
+  for (const entry of entries) {
+    if (entry.type === "custom")
+      customs.push(entry);
+  }
+  return customs;
+}
+function candidateFromStartedProjection(workflow) {
+  const started = workflow.started;
+  if (!started)
+    return null;
+  return {
+    selectedRepo: started.selectedRepo,
+    githubUserId: started.owner.githubUserId,
+    login: started.owner.login,
+    namespaceKey: started.owner.namespaceKey,
+    source: "workflow-metadata"
+  };
+}
+function candidateFromStartedData(data) {
+  const record = asRecord2(data);
+  if (!record)
+    return null;
+  const owner = asRecord2(record.owner);
+  const selectedRepo = stringField(record.selectedRepo);
+  const githubUserId = stringField(owner?.githubUserId) ?? numericStringField(record.githubUserId) ?? numericStringField(record.userId);
+  const login = stringField(owner?.login) ?? stringField(record.login);
+  const namespaceKey = stringField(owner?.namespaceKey) ?? stringField(record.namespaceKey) ?? stringField(record.userNamespaceKey);
+  if (!selectedRepo && !githubUserId && !login && !namespaceKey)
+    return null;
+  return { selectedRepo, githubUserId, login, namespaceKey, source: "workflow-metadata" };
+}
+function workflowIdentityCandidate(entries) {
+  const customs = customEntries(entries);
+  const projected = candidateFromStartedProjection(projectWorkflowEntries(customs));
+  if (projected)
+    return projected;
+  for (let index = customs.length - 1;index >= 0; index -= 1) {
+    const entry = customs[index];
+    if (entry?.customType !== RIG_WORKFLOW_STARTED)
+      continue;
+    const candidate = candidateFromStartedData(entry.data);
+    if (candidate)
+      return candidate;
+  }
+  return null;
+}
+function ompGitHubIdentityCandidate(ctx) {
+  const account = asRecord2(ctx.modelRegistry?.authStorage?.getOAuthAccountIdentity?.("github-copilot", ctx.sessionManager.getSessionId()));
+  if (!account)
+    return null;
+  const githubUserId = stringField(account.accountId);
+  const login = stringField(account.login) ?? stringField(account.email);
+  if (!githubUserId && !login)
+    return null;
+  return {
+    githubUserId,
+    login,
+    namespaceKey: githubUserId ? `gh:${githubUserId}` : undefined,
+    source: "omp-github-copilot-auth"
+  };
+}
+function envField(name) {
+  return stringField(process.env[name]);
+}
+function envIdentityCandidate() {
+  const selectedRepo = envField("RIG_SELECTED_REPO");
+  const githubUserId = envField("RIG_GITHUB_USER_ID");
+  const login = envField("RIG_GITHUB_LOGIN");
+  const namespaceKey = envField("RIG_GITHUB_NAMESPACE_KEY") ?? (githubUserId ? `gh:${githubUserId}` : undefined);
+  if (!selectedRepo && !githubUserId && !login && !namespaceKey)
+    return null;
+  return {
+    selectedRepo,
+    githubUserId,
+    login,
+    namespaceKey,
+    source: "rig-public-identity-env"
+  };
+}
+function mergeSource(sources, source) {
+  if (source && !sources.includes(source))
+    sources.push(source);
+}
+function completeIdentity(candidate, sources) {
+  const selectedRepo = stringField(candidate.selectedRepo);
+  const githubUserId = stringField(candidate.githubUserId);
+  const login = stringField(candidate.login);
+  const namespaceKey = stringField(candidate.namespaceKey);
+  if (!selectedRepo || !githubUserId || !login || !namespaceKey)
+    return null;
+  const uniqueSources = [];
+  for (const value of sources) {
+    if (!uniqueSources.includes(value))
+      uniqueSources.push(value);
+  }
+  return {
+    selectedRepo,
+    owner: { githubUserId, login, namespaceKey },
+    source: uniqueSources.join("+")
+  };
+}
+function resolveRigIdentity(ctx) {
+  const workflow = workflowIdentityCandidate(ctx.sessionManager.getBranch());
+  const omp = ompGitHubIdentityCandidate(ctx);
+  const env = envIdentityCandidate();
+  const sources = [];
+  const selectedRepo = workflow?.selectedRepo ?? env?.selectedRepo;
+  const githubUserId = workflow?.githubUserId ?? omp?.githubUserId ?? env?.githubUserId;
+  const login = workflow?.login ?? omp?.login ?? env?.login;
+  const namespaceKey = workflow?.namespaceKey ?? omp?.namespaceKey ?? env?.namespaceKey;
+  if (workflow && (workflow.selectedRepo || workflow.githubUserId || workflow.login || workflow.namespaceKey))
+    mergeSource(sources, workflow.source);
+  if (omp && (!workflow?.githubUserId || !workflow?.login || !workflow?.namespaceKey))
+    mergeSource(sources, omp.source);
+  if (env && (!workflow?.selectedRepo && env.selectedRepo || !workflow?.githubUserId && !omp?.githubUserId && env.githubUserId || !workflow?.login && !omp?.login && env.login || !workflow?.namespaceKey && !omp?.namespaceKey && env.namespaceKey))
+    mergeSource(sources, env.source);
+  return completeIdentity({ selectedRepo, githubUserId, login, namespaceKey, source: sources.join("+") }, sources);
+}
+function resolveRigIdentityFilter(ctx) {
+  const identity = resolveRigIdentity(ctx);
+  if (!identity)
+    return null;
+  return {
+    cwd: ctx.sessionManager.getCwd(),
+    selectedRepo: identity.selectedRepo,
+    githubUserId: identity.owner.githubUserId,
+    namespaceKey: identity.owner.namespaceKey
+  };
+}
+
+// packages/rig-extension/src/extension.ts
+function isRigScreen(value) {
+  return value === "cockpit" || value === "server" || value === "tasks" || value === "task-detail" || value === "runs" || value === "inbox" || value === "doctor" || value === "setup";
+}
+var RIG_EXTENSION_BRIDGE_GLOBAL = "__RIG_EXTENSION_BRIDGE__";
+function projectRootFromContext(ctx) {
+  return ctx.cwd || ctx.sessionManager.getCwd?.() || process.cwd();
+}
+function connectionStatePath(projectRoot) {
+  return resolve(resolveAuthorityPaths(projectRoot).stateDir, "connection.json");
+}
+function readJsonRecord(path) {
+  if (!existsSync(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function persistSelectedTarget(projectRoot, alias) {
+  const path = connectionStatePath(projectRoot);
+  const previous = readJsonRecord(path) ?? {};
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify({ ...previous, selected: alias }, null, 2)}
+`, "utf-8");
+  if (alias === "local") {
+    delete process.env.RIG_REMOTE_ALIAS;
+  } else {
+    process.env.RIG_REMOTE_ALIAS = alias;
+  }
+}
+function remoteTargetFromEndpoint(remote, projectRoot) {
+  return {
+    alias: remote.alias,
+    kind: "remote",
+    baseUrl: `${remote.host}:${remote.port}`,
+    projectRoot,
+    status: "ready",
+    taskSource: "configured source",
+    detail: remote.lastConnected ? `last connected ${remote.lastConnected}` : "saved remote alias"
+  };
+}
+async function listServerTargets(ctx, bridge) {
+  if (bridge?.listServerTargets)
+    return bridge.listServerTargets();
+  const projectRoot = projectRootFromContext(ctx);
+  const current = normalizeSpawnTargetState(await bridge?.readServerState?.() ?? null);
+  const remotes = listManagedRemoteEndpoints(undefined, projectRoot).map((remote) => remoteTargetFromEndpoint(remote, projectRoot));
+  const targets = [
+    {
+      alias: "local",
+      kind: "local",
+      projectRoot,
+      status: "ready",
+      taskSource: current?.kind === "local" ? current.taskSource ?? "configured source" : "configured source",
+      detail: "this checkout"
+    },
+    ...remotes
+  ];
+  return targets.map((target) => target.alias === current?.alias ? { ...target, ...current, status: "ready" } : target);
+}
+async function selectServerTarget(ctx, bridge, alias) {
+  if (bridge?.selectServerTarget)
+    return bridge.selectServerTarget(alias);
+  const projectRoot = projectRootFromContext(ctx);
+  const targets = await listServerTargets(ctx, bridge);
+  const target = targets.find((entry) => entry.alias === alias);
+  if (!target)
+    throw new Error(`Unknown Rig server target: ${alias}`);
+  persistSelectedTarget(projectRoot, alias);
+  return target;
+}
+async function addRemoteTarget(ctx, bridge) {
+  const alias = (await ctx.ui.editor("Rig remote alias", "prod"))?.trim();
+  if (!alias)
+    return null;
+  const host = (await ctx.ui.editor("Rig remote host", "where.rig-does.work"))?.trim();
+  if (!host)
+    return null;
+  const portRaw = (await ctx.ui.editor("Rig remote port", "7890"))?.trim() || "7890";
+  const port = Number.parseInt(portRaw, 10);
+  if (!Number.isFinite(port) || port <= 0 || port > 65535)
+    throw new Error(`Invalid Rig remote port: ${portRaw}`);
+  const token = (await ctx.ui.editor("Rig remote token (optional)", ""))?.trim() || null;
+  if (bridge?.addRemoteTarget)
+    return bridge.addRemoteTarget({ alias, host, port, token });
+  const projectRoot = projectRootFromContext(ctx);
+  const saved = upsertManagedRemoteEndpoint({ alias, host, port, ...token ? { token } : {} }, undefined, projectRoot);
+  persistSelectedTarget(projectRoot, alias);
+  return remoteTargetFromEndpoint(saved, projectRoot);
+}
+var RIG_LABELS_TO_ENSURE = [
+  "rig:running",
+  "rig:pr-open",
+  "rig:ci-fixing",
+  "rig:merging",
+  "rig:done",
+  "rig:needs-attention",
+  "rig:ready",
+  "rig:blocked",
+  "rig:generated"
+];
+var RIG_LABEL_METADATA = {
+  "rig:running": { color: "1d76db", description: "Rig is actively working on this issue." },
+  "rig:pr-open": { color: "5319e7", description: "Rig opened a pull request for this issue." },
+  "rig:ci-fixing": { color: "fbca04", description: "Rig is fixing CI or review feedback for this issue." },
+  "rig:merging": { color: "0052cc", description: "Rig is merging the completed change for this issue." },
+  "rig:done": { color: "0e8a16", description: "Rig completed this issue." },
+  "rig:needs-attention": { color: "d93f0b", description: "Rig needs operator attention for this issue." },
+  "rig:ready": { color: "0e8a16", description: "Rig issue analysis marked this issue ready." },
+  "rig:blocked": { color: "d93f0b", description: "Rig issue analysis found blockers for this issue." },
+  "rig:generated": { color: "c5def5", description: "Rig generated this follow-up issue." }
+};
+function cleanString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function parseRepoSlugFromRemote(remoteUrl) {
+  const trimmed = remoteUrl.trim();
+  const match = trimmed.match(/github\.com[:/]([^/\s]+)\/([^/\s.]+)(?:\.git)?$/i);
+  return match ? `${match[1]}/${match[2]}` : null;
+}
+function parseRepoSlug(value) {
+  const match = value.trim().match(/^([^/\s]+)\/([^/\s]+)$/);
+  if (!match)
+    throw new Error(`Invalid GitHub repo slug "${value}". Expected owner/repo.`);
+  return { owner: match[1], repo: match[2], slug: `${match[1]}/${match[2]}` };
+}
+function runSyncCommand(command, input = {}) {
+  const executable = command[0];
+  if (!executable)
+    throw new Error("command is required");
+  return (input.spawn ?? spawnSync)(executable, [...command.slice(1)], {
+    cwd: input.cwd,
+    encoding: "utf8",
+    timeout: input.timeoutMs ?? 1e4,
+    env: input.env ?? process.env
+  });
+}
+function detectOriginRepoSlug(projectRoot, deps = {}) {
+  const result = runSyncCommand(["git", "-C", projectRoot, "remote", "get-url", "origin"], { timeoutMs: 5000, spawn: deps.spawn });
+  if (result.status !== 0 || result.error)
+    return null;
+  return parseRepoSlugFromRemote(result.stdout.trim());
+}
+function readRigConfigStatus(projectRoot) {
+  const path = resolve(projectRoot, "rig.config.ts");
+  if (!existsSync(path)) {
+    return { exists: false, valid: false, path, slug: null, reason: "missing rig.config.ts" };
+  }
+  try {
+    const source = readFileSync(path, "utf-8");
+    const owner = source.match(/\bowner:\s*["']([^"']+)["']/)?.[1] ?? null;
+    const repoValues = [...source.matchAll(/\brepo:\s*["']([^"']+)["']/g)].map((match) => match[1]).filter(Boolean);
+    const taskRepo = repoValues.find((value) => !value.includes("/")) ?? null;
+    const projectRepo = repoValues.find((value) => value.includes("/")) ?? null;
+    const githubIssues = /\bkind:\s*["']github-issues["']/.test(source);
+    const slug = owner && taskRepo ? `${owner}/${taskRepo}` : projectRepo;
+    if (!githubIssues || !slug) {
+      return { exists: true, valid: false, path, slug: slug ?? null, reason: "rig.config.ts is not a GitHub Issues Rig config" };
+    }
+    parseRepoSlug(slug);
+    return { exists: true, valid: true, path, slug };
+  } catch (error) {
+    return { exists: true, valid: false, path, slug: null, reason: notificationMessage(error) };
+  }
+}
+function readRigConnectionStatus(projectRoot) {
+  const stateDir = resolve(projectRoot, ".rig", "state");
+  if (!existsSync(stateDir))
+    return { valid: false, selected: null, project: null, reason: "missing .rig/state" };
+  const connection = readJsonRecord(connectionStatePath(projectRoot));
+  if (!connection)
+    return { valid: false, selected: null, project: null, reason: "missing or invalid .rig/state/connection.json" };
+  const selected = cleanString(connection.selected);
+  const project = cleanString(connection.project);
+  if (!selected)
+    return { valid: false, selected: null, project, reason: "connection.json is missing selected placement" };
+  if (!project)
+    return { valid: false, selected, project: null, reason: "connection.json is missing project slug" };
+  try {
+    parseRepoSlug(project);
+  } catch (error) {
+    return { valid: false, selected, project, reason: notificationMessage(error) };
+  }
+  return { valid: true, selected, project };
+}
+function projectLinkStatePath(projectRoot) {
+  return resolve(projectRoot, ".rig", "state", "project-link.json");
+}
+function writeJsonFile(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+}
+function ensureRigPrivateDirs(projectRoot) {
+  mkdirSync(resolve(projectRoot, ".rig", "state"), { recursive: true });
+  mkdirSync(resolve(projectRoot, ".rig", "logs"), { recursive: true });
+  mkdirSync(resolve(projectRoot, ".rig", "runs"), { recursive: true });
+  mkdirSync(resolve(projectRoot, ".rig", "tmp"), { recursive: true });
+  mkdirSync(resolve(projectRoot, "artifacts"), { recursive: true });
+  const taskConfigPath = resolve(projectRoot, ".rig", "task-config.json");
+  if (!existsSync(taskConfigPath))
+    writeFileSync(taskConfigPath, `{}
+`, "utf-8");
+}
+function ensureGitignoreEntries(projectRoot) {
+  const path = resolve(projectRoot, ".gitignore");
+  const existing = existsSync(path) ? readFileSync(path, "utf-8") : "";
+  const lines = new Set(existing.split(/\r?\n/));
+  const missing = [".rig/state/", ".rig/logs/", ".rig/runs/", ".rig/tmp/"].filter((entry) => !lines.has(entry));
+  if (missing.length === 0)
+    return;
+  const prefix = existing.length > 0 && !existing.endsWith(`
+`) ? `
+` : "";
+  appendFileSync(path, `${prefix}${missing.join(`
+`)}
+`, "utf-8");
+}
+function writeRigConnectionState(projectRoot, slug, placement) {
+  const previous = readJsonRecord(connectionStatePath(projectRoot)) ?? {};
+  writeJsonFile(connectionStatePath(projectRoot), {
+    ...previous,
+    selected: placement.alias,
+    project: slug,
+    linkedAt: new Date().toISOString()
+  });
+  writeJsonFile(projectLinkStatePath(projectRoot), {
+    repoSlug: slug,
+    connection: placement.alias,
+    linkedAt: new Date().toISOString()
+  });
+  if (placement.alias === "local")
+    delete process.env.RIG_REMOTE_ALIAS;
+  else
+    process.env.RIG_REMOTE_ALIAS = placement.alias;
+}
+function writeRigConfig(projectRoot, slug) {
+  const repo = parseRepoSlug(slug);
+  writeFileSync(resolve(projectRoot, "rig.config.ts"), buildRigInitConfigSource({
+    projectName: repo.slug,
+    projectRepo: repo.slug,
+    taskSource: { kind: "github-issues", owner: repo.owner, repo: repo.repo },
+    useStandardPlugin: true
+  }), "utf-8");
+}
+function detectGhAuth(projectRoot, slug, deps = {}) {
+  const user = runSyncCommand(["gh", "api", "user", "--jq", ".login"], { cwd: projectRoot, timeoutMs: 5000, spawn: deps.spawn });
+  if (user.status !== 0 || user.error || !user.stdout.trim())
+    return null;
+  const repo = runSyncCommand(["gh", "repo", "view", slug, "--json", "nameWithOwner", "--jq", ".nameWithOwner"], { cwd: projectRoot, timeoutMs: 5000, spawn: deps.spawn });
+  if (repo.status !== 0 || repo.error) {
+    return { ok: false, source: "gh", login: user.stdout.trim(), detail: (repo.stderr || repo.stdout || "gh cannot access the selected repository").trim() };
+  }
+  return { ok: true, source: "gh", login: user.stdout.trim(), detail: "gh CLI authentication can access the selected repository" };
+}
+async function validateGitHubAuth(projectRoot, slug, deps = {}) {
+  if (!slug)
+    return { ok: false, source: "missing", detail: "GitHub repo slug is unknown" };
+  const status = resolveGitHubAuthStatus({ projectRoot, oauthConfigured: Boolean(process.env.RIG_GITHUB_OAUTH_CLIENT_ID?.trim()) });
+  if (status.signedIn) {
+    const store = createGitHubAuthStore(projectRoot);
+    if (!status.selectedRepo) {
+      store.saveSelectedRepo(slug);
+      return { ok: true, source: "stored-token", login: status.login, detail: "stored Rig GitHub token selected for this repo", status: store.status({ oauthConfigured: status.oauthConfigured }) };
+    }
+    if (status.selectedRepo !== slug) {
+      return { ok: false, source: "stored-token", login: status.login, detail: `stored GitHub token is scoped to ${status.selectedRepo}, not ${slug}`, status };
+    }
+    return { ok: true, source: "stored-token", login: status.login, detail: "stored Rig GitHub token is present", status };
+  }
+  const gh = detectGhAuth(projectRoot, slug, deps);
+  if (gh)
+    return gh;
+  return { ok: false, source: "missing", detail: "Sign in with `gh auth login`, choose Setup \u2192 GitHub auth, or paste a token." };
+}
+function lightweightSetupDoctor(ctx, projectRoot) {
+  const checks = [];
+  checks.push({ label: "workspace", level: existsSync(projectRoot) ? "ok" : "fail", detail: projectRoot });
+  checks.push({ label: "omp-ui", level: ctx.hasUI ? "ok" : "fail", detail: ctx.hasUI ? "interactive session" : "no UI context" });
+  checks.push({ label: "pi-extension", level: "ok", detail: "Rig extension registered in this OMP session" });
+  return checks;
+}
+async function detectRigStartupStatus(ctx, deps = {}) {
+  const projectRoot = projectRootFromContext(ctx);
+  const config = readRigConfigStatus(projectRoot);
+  const state = readRigConnectionStatus(projectRoot);
+  const detectedSlug = detectOriginRepoSlug(projectRoot, deps);
+  const slug = config.slug ?? state.project ?? detectedSlug;
+  const reasons = [];
+  if (!detectedSlug)
+    reasons.push("git origin does not point at a GitHub owner/repo remote");
+  if (!config.exists || !config.valid)
+    reasons.push(config.reason ?? "rig.config.ts is invalid");
+  if (!state.valid)
+    reasons.push(state.reason ?? ".rig/state/connection.json is invalid");
+  if (config.slug && state.project && config.slug !== state.project)
+    reasons.push(`rig.config.ts repo ${config.slug} does not match connection project ${state.project}`);
+  if (slug && detectedSlug && slug !== detectedSlug)
+    reasons.push(`configured repo ${slug} does not match git origin ${detectedSlug}`);
+  const auth = await validateGitHubAuth(projectRoot, slug, deps);
+  if (!auth.ok)
+    reasons.push(auth.detail);
+  const checks = lightweightSetupDoctor(ctx, projectRoot);
+  return {
+    configured: reasons.length === 0,
+    projectRoot,
+    slug,
+    config,
+    state,
+    auth,
+    checks,
+    reasons
+  };
+}
+function authStatePath(projectRoot) {
+  return resolve(projectRoot, ".rig", "state", "github-auth.json");
+}
+function copyGitHubAuthToLocalProjectRoot(projectRoot) {
+  const store = createGitHubAuthStore(projectRoot);
+  if (resolve(store.stateFile) !== authStatePath(projectRoot))
+    store.copyToLocalProjectRoot(projectRoot);
+}
+function readGhAuthToken(projectRoot, deps = {}) {
+  const result = runSyncCommand(["gh", "auth", "token"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
+  if (result.status !== 0 || result.error || !result.stdout.trim()) {
+    throw new Error((result.stderr || result.stdout || "Could not read GitHub token from `gh auth token`. Run `gh auth login` or choose pasted-token/device auth.").trim());
+  }
+  return result.stdout.trim();
+}
+async function saveGitHubTokenLocally(projectRoot, token, slug, source, deps = {}) {
+  ensureRigPrivateDirs(projectRoot);
+  await saveGitHubTokenForProject({
+    projectRoot,
+    token,
+    tokenSource: source,
+    selectedRepo: slug,
+    ...deps.fetchUser ? { fetchUser: deps.fetchUser } : {}
+  });
+  copyGitHubAuthToLocalProjectRoot(projectRoot);
+}
+async function runGitHubDeviceAuth(projectRoot, slug, ctx, deps = {}) {
+  const clientId = process.env.RIG_GITHUB_OAUTH_CLIENT_ID?.trim();
+  if (!clientId)
+    throw new Error("GitHub device auth requires RIG_GITHUB_OAUTH_CLIENT_ID. Choose gh auth or pasted token instead.");
+  ensureRigPrivateDirs(projectRoot);
+  const device = await beginGitHubDeviceFlow({
+    projectRoot,
+    clientId,
+    selectedRepo: slug,
+    ...deps.postForm ? { postForm: deps.postForm } : {}
+  });
+  const prompt = `Open ${device.verificationUri ?? "https://github.com/login/device"} and enter code ${device.userCode ?? "(missing code)"}. Press Enter here after authorizing.`;
+  await ctx.ui.editor("GitHub device auth", prompt);
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolveSleep) => setTimeout(resolveSleep, ms)));
+  const timeoutMs = Number.parseInt(process.env.RIG_DEVICE_AUTH_POLL_TIMEOUT_MS ?? "", 10);
+  const deadline = Date.now() + (Number.isFinite(timeoutMs) && timeoutMs >= 0 ? timeoutMs : 5 * 60 * 1000);
+  let intervalMs = Math.max(1000, device.intervalSeconds * 1000);
+  do {
+    const result = await pollGitHubDeviceFlow({
+      projectRoot,
+      clientId,
+      pollId: device.pollId,
+      selectedRepo: slug,
+      ...deps.postForm ? { postForm: deps.postForm } : {},
+      ...deps.fetchUser ? { fetchUser: deps.fetchUser } : {}
+    });
+    if (result.ok) {
+      copyGitHubAuthToLocalProjectRoot(projectRoot);
+      return;
+    }
+    if (result.status === "error" || result.status === "expired")
+      throw new Error(result.error ?? "GitHub device auth failed.");
+    intervalMs = Math.max(intervalMs, (result.intervalSeconds ?? device.intervalSeconds) * 1000);
+    await sleep(intervalMs);
+  } while (Date.now() < deadline);
+  throw new Error("Timed out waiting for GitHub device authorization.");
+}
+async function ensureGitHubAuthForSetup(projectRoot, slug, ctx, deps = {}) {
+  const current = await validateGitHubAuth(projectRoot, slug, deps);
+  const choices = [];
+  if (current.ok && current.source === "stored-token")
+    choices.push("Use stored Rig token");
+  if (detectGhAuth(projectRoot, slug, deps)?.ok)
+    choices.push("Import token from gh");
+  if (process.env.RIG_GITHUB_OAUTH_CLIENT_ID?.trim())
+    choices.push("GitHub device flow");
+  choices.push("Paste token");
+  const choice = await ctx.ui.select("GitHub auth", choices);
+  if (!choice)
+    throw new Error("Setup cancelled during GitHub auth.");
+  if (choice === "Use stored Rig token") {
+    createGitHubAuthStore(projectRoot).saveSelectedRepo(slug);
+    copyGitHubAuthToLocalProjectRoot(projectRoot);
+  } else if (choice === "Import token from gh") {
+    await saveGitHubTokenLocally(projectRoot, readGhAuthToken(projectRoot, deps), slug, "manual-token", deps);
+  } else if (choice === "GitHub device flow") {
+    await runGitHubDeviceAuth(projectRoot, slug, ctx, deps);
+  } else {
+    const token = (await ctx.ui.editor("GitHub token", ""))?.trim();
+    if (!token)
+      throw new Error("GitHub token is required.");
+    await saveGitHubTokenLocally(projectRoot, token, slug, "manual-token", deps);
+  }
+  return validateGitHubAuth(projectRoot, slug, deps);
+}
+async function ensureGitHubLabels(input) {
+  const repo = parseRepoSlug(input.slug);
+  const token = input.token?.trim() || createGitHubAuthStore(input.projectRoot).readToken();
+  if (token) {
+    const fetchLabels = input.deps?.fetch ?? fetch;
+    for (const name of RIG_LABELS_TO_ENSURE) {
+      const metadata = RIG_LABEL_METADATA[name];
+      const response = await fetchLabels(`https://api.github.com/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.repo)}/labels`, {
+        method: "POST",
+        headers: {
+          accept: "application/vnd.github+json",
+          authorization: `Bearer ${token}`,
+          "content-type": "application/json",
+          "user-agent": "rig"
+        },
+        body: JSON.stringify({ name, color: metadata.color, description: metadata.description })
+      });
+      if (response.ok)
+        continue;
+      const text = await response.text().catch(() => "");
+      if (response.status === 422 && /already_exists|already exists|exists/i.test(text))
+        continue;
+      throw new Error(`Could not create GitHub label ${name}: ${response.status} ${text || response.statusText}`);
+    }
+    return { ok: true, method: "api", labels: RIG_LABELS_TO_ENSURE };
+  }
+  const gh = detectGhAuth(input.projectRoot, input.slug, input.deps);
+  if (!gh?.ok)
+    throw new Error("GitHub labels require a stored Rig token or gh auth. Run Setup \u2192 GitHub auth, paste a token, or run `gh auth login`.");
+  for (const name of RIG_LABELS_TO_ENSURE) {
+    const metadata = RIG_LABEL_METADATA[name];
+    const result = runSyncCommand(["gh", "label", "create", name, "--repo", input.slug, "--color", metadata.color, "--description", metadata.description, "--force"], { cwd: input.projectRoot, timeoutMs: 1e4, spawn: input.deps?.spawn });
+    if (result.status !== 0 || result.error)
+      throw new Error(`gh label create ${name} failed: ${(result.stderr || result.stdout || result.error?.message || "unknown error").trim()}`);
+  }
+  return { ok: true, method: "gh", labels: RIG_LABELS_TO_ENSURE };
+}
+function piListContainsRigExtension(output) {
+  return output.split(/\r?\n/).some((line) => line.includes("@h-rig/pi-rig") || /(?:^|[\\/])packages[\\/]pi-rig(?:$|\s)/.test(line));
+}
+function splitInstallCommand(value) {
+  return value.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => part.replace(/^['"]|['"]$/g, "")) ?? [];
+}
+function ensurePiRigInstalledForSetup(projectRoot, deps = {}) {
+  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1")
+    return { ok: true, detail: "fake-pi" };
+  let version = runSyncCommand(["pi", "--version"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
+  if (version.status !== 0 || version.error) {
+    const installCommand = process.env.RIG_PI_INSTALL_COMMAND?.trim();
+    if (!installCommand)
+      throw new Error(`Pi/OMP is not available: ${(version.stderr || version.stdout || version.error?.message || "pi --version failed").trim()}. Install Pi/OMP or set RIG_PI_INSTALL_COMMAND.`);
+    const parts = splitInstallCommand(installCommand);
+    if (parts.length === 0)
+      throw new Error("RIG_PI_INSTALL_COMMAND is empty.");
+    const install = runSyncCommand(parts, { cwd: projectRoot, timeoutMs: 120000, spawn: deps.spawn });
+    if (install.status !== 0 || install.error)
+      throw new Error(`Pi/OMP install command failed: ${(install.stderr || install.stdout || install.error?.message || "unknown error").trim()}`);
+    version = runSyncCommand(["pi", "--version"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
+    if (version.status !== 0 || version.error)
+      throw new Error(`Pi/OMP is still unavailable after install: ${(version.stderr || version.stdout || version.error?.message || "pi --version failed").trim()}`);
+  }
+  let list = runSyncCommand(["pi", "list"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
+  if (!piListContainsRigExtension(`${list.stdout}
+${list.stderr}`)) {
+    const packageSource = existsSync(resolve(projectRoot, "packages", "pi-rig", "package.json")) ? resolve(projectRoot, "packages", "pi-rig") : "npm:@h-rig/pi-rig";
+    const install = runSyncCommand(["pi", "install", packageSource], { cwd: projectRoot, timeoutMs: 120000, spawn: deps.spawn });
+    if (install.status !== 0 || install.error)
+      throw new Error(`Could not install/register the Rig OMP extension: ${(install.stderr || install.stdout || install.error?.message || "pi install failed").trim()}`);
+    list = runSyncCommand(["pi", "list"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
+    if (!piListContainsRigExtension(`${list.stdout}
+${list.stderr}`))
+      throw new Error("Pi/OMP is installed, but `pi list` does not show the Rig extension. Run `pi install npm:@h-rig/pi-rig` and retry Setup.");
+  }
+  return { ok: true, detail: (version.stdout || version.stderr).trim() || "pi available; rig extension registered" };
+}
+async function applyRigSetupProject(input) {
+  const repo = parseRepoSlug(input.slug);
+  ensureRigPrivateDirs(input.projectRoot);
+  ensureGitignoreEntries(input.projectRoot);
+  writeRigConnectionState(input.projectRoot, repo.slug, input.placement);
+  if (input.rewriteConfig)
+    writeRigConfig(input.projectRoot, repo.slug);
+  const labels = await ensureGitHubLabels({ projectRoot: input.projectRoot, slug: repo.slug, deps: input.deps });
+  const pi = input.ensurePi === false ? { skipped: true } : ensurePiRigInstalledForSetup(input.projectRoot, input.deps);
+  return { repoSlug: repo.slug, placement: input.placement.alias, configWritten: input.rewriteConfig, labels, pi };
+}
+function hasInteractiveSetupTerminal(ctx) {
+  return Boolean(ctx.hasUI && process.stdin.isTTY && process.stdout.isTTY);
+}
+async function promptSetupPlacement(ctx, bridge) {
+  const targets = await listServerTargets(ctx, bridge);
+  const options = [
+    ...targets.map((target2) => `${target2.alias} (${target2.kind})`),
+    "Add saved remote alias"
+  ];
+  const selected = await ctx.ui.select("Rig execution placement", options);
+  if (!selected)
+    throw new Error("Setup cancelled during placement selection.");
+  if (selected === "Add saved remote alias") {
+    const target2 = await addRemoteTarget(ctx, bridge);
+    if (!target2)
+      throw new Error("Remote placement was not saved.");
+    return { alias: target2.alias, kind: target2.kind };
+  }
+  const alias = selected.replace(/\s+\((local|remote)\)$/, "");
+  const target = targets.find((entry) => entry.alias === alias);
+  if (!target)
+    throw new Error(`Unknown placement selected: ${selected}`);
+  return { alias: target.alias, kind: target.kind };
+}
+async function runRigSetupFlow(api, ctx, injectedBridge, deps = {}) {
+  if (!hasInteractiveSetupTerminal(ctx))
+    throw new Error("Rig Setup requires an interactive OMP cockpit terminal.");
+  const projectRoot = projectRootFromContext(ctx);
+  const existingConfig = readRigConfigStatus(projectRoot);
+  let configAction = existingConfig.exists ? "repair" : "reconfigure";
+  if (existingConfig.exists) {
+    const choice = await ctx.ui.select("rig.config.ts already exists", [
+      "Repair generated config",
+      "Reconfigure and rewrite config",
+      "Leave config unchanged; update private state only",
+      "Cancel"
+    ]);
+    if (!choice || choice === "Cancel")
+      throw new Error("Setup cancelled.");
+    if (choice === "Reconfigure and rewrite config")
+      configAction = "reconfigure";
+    else if (choice === "Leave config unchanged; update private state only")
+      configAction = "private-state-only";
+    else
+      configAction = "repair";
+  }
+  const detectedSlug = detectOriginRepoSlug(projectRoot, deps) ?? existingConfig.slug ?? readRigConnectionStatus(projectRoot).project ?? "";
+  const slugInput = (await ctx.ui.editor("GitHub repo slug", detectedSlug))?.trim();
+  if (!slugInput)
+    throw new Error("GitHub repo slug is required.");
+  const repo = parseRepoSlug(slugInput);
+  const placement = await promptSetupPlacement(ctx, selectedServerBridge(ctx, injectedBridge));
+  const auth = await ensureGitHubAuthForSetup(projectRoot, repo.slug, ctx, deps);
+  if (!auth.ok)
+    throw new Error(auth.detail);
+  const token = createGitHubAuthStore(projectRoot).readToken();
+  const probe = await probeGitHubRepository({
+    owner: repo.owner,
+    repo: repo.repo,
+    token,
+    scopes: auth.status?.scopes ?? [],
+    ...deps.fetch ? { fetchRepository: deps.fetch } : {}
+  });
+  if (!probe.ok)
+    throw new Error(probe.message);
+  const rewriteConfig = configAction === "reconfigure" || configAction === "repair" && (!existingConfig.valid || existingConfig.slug !== repo.slug);
+  const result = await applyRigSetupProject({
+    projectRoot,
+    slug: repo.slug,
+    placement,
+    rewriteConfig,
+    deps
+  });
+  const status = await detectRigStartupStatus(ctx, deps);
+  if (!status.configured)
+    throw new Error(`Setup wrote state but doctor still reports: ${status.reasons.join("; ")}`);
+  appendOperatorNote(api, `Rig Setup completed for ${repo.slug} (${placement.alias})`);
+  const labelsPayload = result.labels;
+  const labelsReady = Boolean(labelsPayload && typeof labelsPayload === "object" && "labels" in labelsPayload && Array.isArray(labelsPayload.labels));
+  ctx.ui.notify(`Rig Setup complete for ${repo.slug}: ${result.placement}, labels ${labelsReady ? "ready" : "checked"}, Pi ready.`, "info");
+}
+function stringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+}
+var TASK_STATUSES = new Set(["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]);
+function normalizeTaskStatus(value) {
+  const normalized = value?.trim().replace(/\s+/g, "_").replace(/-/g, "_");
+  return normalized && TASK_STATUSES.has(normalized) ? normalized : "unknown";
+}
+function normalizeTaskPriority(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function taskBadgeProjection(task) {
+  const metadata = isRecord(task.metadata) ? task.metadata : {};
+  return {
+    id: task.id,
+    title: taskTitle(task),
+    status: normalizeTaskStatus(task.status),
+    priority: normalizeTaskPriority(task.priority ?? (typeof metadata.priority === "number" || typeof metadata.priority === "string" ? metadata.priority : null)),
+    metadata,
+    source: task.source,
+    url: task.url,
+    body: task.body,
+    assignedTo: task.assignedTo,
+    assignees: task.assignees,
+    dependencies: [...stringList(task.dependencies), ...stringList(metadata.dependencies)],
+    parentChildDeps: [...stringList(task.parentChildDeps), ...stringList(metadata.parentChildDeps)]
+  };
+}
+function taskAssigneeText(task) {
+  const assignees = [
+    ...stringList(task.assignees),
+    ...typeof task.assignedTo === "string" ? [task.assignedTo] : stringList(task.assignedTo),
+    ...stringList(task.metadata?.assignees),
+    ...stringList(task.metadata?.assignedTo)
+  ];
+  return assignees.length > 0 ? `assigned ${assignees.join(",")}` : "unassigned";
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function readBridgeFromContainer(value) {
+  if (!isRecord(value))
+    return null;
+  const selectedServer = value.selectedServer;
+  return isRecord(selectedServer) ? selectedServer : null;
+}
+function selectedServerBridge(ctx, injectedBridge) {
+  if (injectedBridge)
+    return injectedBridge;
+  const fromContext = readBridgeFromContainer(ctx.rig);
+  if (fromContext)
+    return fromContext;
+  const globalBridge = globalThis[RIG_EXTENSION_BRIDGE_GLOBAL];
+  return readBridgeFromContainer(globalBridge);
+}
+function taskId(task) {
+  const id = task?.id.trim();
+  return id && id.length > 0 ? id : null;
+}
+function taskTitle(task) {
+  const title = task?.title?.trim();
+  return title && title.length > 0 ? title : taskId(task) ?? "Untitled task";
+}
+function taskStatus(task) {
+  const status = task?.status?.trim();
+  return status && status.length > 0 ? status : "unknown";
+}
+function taskDescription(task) {
+  return [task.source, task.url, task.body].flatMap((part) => {
+    const text = part?.trim();
+    return text ? [text] : [];
+  }).join(" \xB7 ");
+}
+function decodeActionValue(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function selectedTaskIdFromDispatchAction(id) {
+  const prefix = "task-detail:dispatch:";
+  if (!id.startsWith(prefix))
+    return null;
+  const decoded = decodeActionValue(id.slice(prefix.length)).trim();
+  return decoded.length > 0 ? decoded : null;
+}
+function appendTaskSelected(api, task) {
+  const id = taskId(task);
+  if (!id)
+    return;
+  api.appendEntry(RIG_WORKFLOW_TASK_SELECTED, createWorkflowTaskSelected({
+    taskId: id,
+    title: taskTitle(task)
+  }));
+}
+function notificationMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function dispatchSelectedTask(api, ctx, id, injectedBridge) {
+  const taskIdValue = selectedTaskIdFromDispatchAction(id);
+  if (!taskIdValue)
+    throw new Error("Task detail dispatch requires a selected task id.");
+  const bridge = selectedServerBridge(ctx, injectedBridge);
+  if (!bridge?.getTask || !bridge.dispatchTask) {
+    throw new Error("Rig selected-server task dispatch bridge is unavailable.");
+  }
+  const task = await bridge.getTask(taskIdValue);
+  if (!task)
+    throw new Error(`Selected task not found: ${taskIdValue}`);
+  appendTaskSelected(api, task);
+  appendStatus(api, "starting", `Dispatching selected task ${taskIdValue} through the selected server target.`);
+  const result = await bridge.dispatchTask({ taskId: taskIdValue, ...task.title ? { title: task.title } : {} });
+  appendStatus(api, "running", `Selected task ${taskIdValue} dispatched as run ${result.runId}.`);
+  if (bridge.attachRun) {
+    const attach = await bridge.attachRun({ runId: result.runId, ...taskIdValue ? { taskId: taskIdValue } : {} });
+    const joinLink = attach?.joinLink ?? result.joinLink ?? null;
+    if (joinLink) {
+      await joinCollab(ctx, { joinLink });
+      ctx.ui.notify(`Attached ${result.runId.slice(0, 8)} through OMP collab.`, "info");
+      return;
+    }
+    const sessionPath = attach?.sessionPath ?? result.sessionPath ?? null;
+    const switchSession = ctx.switchSession;
+    if (sessionPath && switchSession) {
+      const switched = await switchSession(sessionPath);
+      if (!switched.cancelled) {
+        ctx.ui.notify(`Attached ${result.runId.slice(0, 8)} through OMP collab.`, "info");
+        return;
+      }
+    }
+  }
+  ctx.ui.notify(`Dispatched ${taskIdValue} as ${result.runId.slice(0, 8)} \u2014 open Runs to attach when it comes online.`, "info");
+}
+function normalizeSpawnTargetState(server) {
+  if (!server)
+    return null;
+  return { ...server, status: "ready" };
+}
+async function collectDoctorChecks(api, ctx) {
+  const checks = [];
+  const identity = resolveRigIdentity(ctx);
+  checks.push({ label: "identity", level: identity ? "ok" : "warn", detail: identity?.source ?? "GitHub identity unavailable" });
+  const filter = resolveRigIdentityFilter(ctx);
+  checks.push({ label: "github-repo", level: filter?.selectedRepo ? "ok" : "warn", detail: filter?.selectedRepo ?? "repo not selected" });
+  const rigCtx = ctx;
+  checks.push({ label: "collab-host", level: rigCtx.collab?.startHost || rigCtx.collab?.startCollabHost ? "ok" : "fail", detail: "OMP host facade" });
+  checks.push({ label: "collab-join", level: rigCtx.collab?.join || rigCtx.collab?.joinCollabSession ? "ok" : "fail", detail: "OMP join facade" });
+  checks.push({ label: "collab-registry", level: rigCtx.collab?.listActive || rigCtx.collab?.listActiveCollabSessions || rigCtx.collab?.listSessions ? "ok" : "warn", detail: "live registry facade" });
+  try {
+    const sessions = identity ? await discoverRigSessions(ctx) : [];
+    checks.push({ label: "run-discovery", level: "ok", detail: `${sessions.length} run session(s)` });
+  } catch (error) {
+    checks.push({ label: "run-discovery", level: "fail", detail: notificationMessage(error) });
+  }
+  try {
+    const targets = await listServerTargets(ctx, selectedServerBridge(ctx));
+    checks.push({ label: "relay-targets", level: targets.length > 0 ? "ok" : "warn", detail: `${targets.length} target(s)` });
+  } catch (error) {
+    checks.push({ label: "relay-targets", level: "warn", detail: notificationMessage(error) });
+  }
+  const note = `Doctor session seam probe ${new Date().toISOString()}`;
+  appendOperatorNote(api, note);
+  checks.push({ label: "custom-entry", level: currentWorkflow(ctx).notes.some((entry) => entry.note === note) ? "ok" : "fail", detail: RIG_WORKFLOW_OPERATOR_NOTE });
+  checks.push({ label: "pi-extension", level: "ok", detail: "Rig extension registered" });
+  return checks;
+}
+function doctorCheckRows(checks) {
+  if (!checks) {
+    return [{ id: "doctor:loading", label: "CHECKS", currentValue: "loading", heading: true, description: "Doctor rows render persistent pass/warn/fail checks." }];
+  }
+  return checks.map((check) => ({
+    id: `doctor:check:${check.label}`,
+    label: check.label.toUpperCase(),
+    currentValue: check.level,
+    heading: true,
+    description: check.detail
+  }));
+}
+async function loadRigFlowState(ctx, screen, selectedTaskId, injectedBridge, api) {
+  const bridge = selectedServerBridge(ctx, injectedBridge);
+  try {
+    const needsServer = screen === "cockpit" || screen === "runs" || screen === "server" || screen === "tasks" || screen === "task-detail" || screen === "setup";
+    const server = needsServer ? normalizeSpawnTargetState(await bridge?.readServerState?.() ?? null) : null;
+    const serverTargets = screen === "server" || screen === "setup" ? await listServerTargets(ctx, bridge) : undefined;
+    const tasks = screen === "tasks" && bridge?.listTasks ? await bridge.listTasks() : undefined;
+    const currentUserLogin = resolveRigIdentity(ctx)?.owner.login ?? null;
+    const selectedTask = screen === "task-detail" && selectedTaskId && bridge?.getTask ? await bridge.getTask(selectedTaskId) : null;
+    const doctorChecks = screen === "doctor" && api ? await collectDoctorChecks(api, ctx) : undefined;
+    const setupStatus = screen === "setup" ? await detectRigStartupStatus(ctx) : undefined;
+    return {
+      ...server ? { server } : {},
+      ...serverTargets ? { serverTargets } : {},
+      ...tasks ? { tasks } : {},
+      ...currentUserLogin ? { currentUserLogin } : {},
+      ...selectedTask ? { selectedTask, selectedTaskId } : selectedTaskId ? { selectedTaskId } : {},
+      ...doctorChecks ? { doctorChecks } : {},
+      ...setupStatus ? { setupStatus } : {}
+    };
+  } catch (error) {
+    return { error: notificationMessage(error) };
+  }
+}
+function identityMatchesWorkflow(identity, workflow) {
+  const started = workflow.started;
+  if (!started)
+    return false;
+  if (started.selectedRepo !== identity.selectedRepo)
+    return false;
+  if (started.owner.githubUserId !== identity.owner.githubUserId)
+    return false;
+  if (started.owner.namespaceKey !== identity.owner.namespaceKey)
+    return false;
+  return true;
+}
+function collabMatchesIdentity(identity, collab) {
+  if (collab.selectedRepo && collab.selectedRepo !== identity.selectedRepo)
+    return false;
+  if (collab.owner?.githubUserId && collab.owner.githubUserId !== identity.owner.githubUserId)
+    return false;
+  if (collab.owner?.namespaceKey && collab.owner.namespaceKey !== identity.owner.namespaceKey)
+    return false;
+  return true;
+}
+function isJoinableCollab(collab) {
+  return Boolean(collab?.joinLink && !collab.stale);
+}
+function hasRigWorkflow(workflow, collab, run) {
+  return Boolean(collab || run?.status || Object.keys(run?.record ?? {}).length > 0 || workflow.started || workflow.target || workflow.task || workflow.status || workflow.notes.length > 0 || workflow.inbox.length > 0 || workflow.resolvedInbox.length > 0);
+}
+function sessionBelongsToWorkspace(session, workflow, collab, ctx) {
+  const cwd = resolve(ctx.sessionManager.getCwd());
+  const sessionCwd = session.cwd ? resolve(session.cwd) : "";
+  const collabCwd = collab?.cwd ? resolve(collab.cwd) : "";
+  const identity = resolveRigIdentity(ctx);
+  if (!identity) {
+    if (!collab)
+      return false;
+    const fallbackNamespace = resolveOwnerNamespaceKey(rigProjectRoot());
+    if (!fallbackNamespace || collab.owner?.namespaceKey !== fallbackNamespace)
+      return false;
+    return sessionCwd === cwd || collabCwd === cwd || !collab.cwd;
+  }
+  if (collab && !collabMatchesIdentity(identity, collab))
+    return false;
+  if (sessionCwd !== cwd && collabCwd !== cwd)
+    return Boolean(collab && !collab.cwd);
+  return collab ? true : identityMatchesWorkflow(identity, workflow);
+}
+function customEntries2(entries) {
+  const customs = [];
+  for (const entry of entries) {
+    if (entry.type === "custom")
+      customs.push(entry);
+  }
+  return customs;
+}
+function currentWorkflow(ctx) {
+  return projectWorkflowEntries(customEntries2(ctx.sessionManager.getBranch()));
+}
+function runIdForProjection(item) {
+  const title = item.collab?.title || item.session.title || item.session.firstMessage || item.session.id;
+  if (title.startsWith("Rig run "))
+    return title.slice("Rig run ".length).trim();
+  if (title.startsWith("rig-run-"))
+    return title.slice("rig-run-".length).trim();
+  return item.session.id;
+}
+function timelineEntriesFromCustomEntries(entries) {
+  return entries.flatMap((entry) => {
+    if (entry.customType !== CUSTOM_TYPE_FOR["timeline-entry"] || !isRecord(entry.data))
+      return [];
+    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 rigProjectRoot() {
+  return process.env.PROJECT_RIG_ROOT?.trim() || process.env.RIG_HOST_PROJECT_ROOT?.trim() || process.cwd();
+}
+function registrySecret() {
+  return resolveRegistrySecret(rigProjectRoot()) ?? null;
+}
+var RUN_PROCESS_STEER_TIMEOUT_MS = 10 * 60 * 1000;
+var TRACKED_RUN_STALL_MS = 20 * 60 * 1000;
+var RUN_PROCESS_STALL_SWEEP_MS = 60 * 1000;
+var RUN_PROCESS_STALL_DETAIL = "Run process made no OMP session progress for 20+ minutes; recording a stall so recovery can requeue or resume the session.";
+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 registryBaseUrl() {
+  return resolveRegistryBaseUrl(rigProjectRoot());
+}
+function rigRelayUrl() {
+  return resolveRelayUrl();
+}
+function registryClientFor(ctx, filter) {
+  const identity = resolveRigIdentity(ctx);
+  const namespaceKey = filter.namespaceKey ?? identity?.owner.namespaceKey ?? resolveOwnerNamespaceKey(rigProjectRoot());
+  const secret = registrySecret();
+  if (!namespaceKey || !secret)
+    return null;
+  return createRegistryClient({ baseUrl: registryBaseUrl(), namespaceKey, secret });
+}
+function collabFromRegistryEntry(entry) {
+  return {
+    sessionId: entry.roomId,
+    sessionPath: "",
+    cwd: "",
+    title: entry.title,
+    joinLink: entry.joinLink,
+    webLink: entry.webLink,
+    relayUrl: entry.relayUrl,
+    owner: entry.owner,
+    selectedRepo: entry.repo,
+    startedAt: entry.startedAt,
+    updatedAt: entry.heartbeatAt,
+    ...entry.pid === undefined ? {} : { pid: entry.pid },
+    stale: entry.stale
+  };
+}
+function sessionProjectionFromCollab(collab) {
+  const started = Date.parse(collab.startedAt);
+  const updated = Date.parse(collab.updatedAt);
+  const modified = new Date(Number.isFinite(updated) ? updated : Date.now());
+  return {
+    session: {
+      path: collab.sessionPath || collab.sessionId,
+      id: collab.sessionId,
+      cwd: collab.cwd,
+      title: collab.title,
+      created: new Date(Number.isFinite(started) ? started : modified.getTime()),
+      modified,
+      messageCount: 0,
+      size: 0,
+      firstMessage: collab.title || "Live OMP collab session",
+      allMessagesText: collab.title || "Live OMP collab session",
+      status: collab.stale ? "unknown" : "pending"
+    },
+    collab,
+    customEntries: [],
+    source: "collab-registry"
+  };
+}
+async function listActiveCollab(ctx, filter) {
+  const facade = ctx.collab;
+  if (facade?.listActive)
+    return facade.listActive(filter);
+  if (facade?.listActiveCollabSessions)
+    return facade.listActiveCollabSessions(filter);
+  const client = registryClientFor(ctx, filter);
+  if (!client)
+    return [];
+  return (await client.listRoomsByOwner(filter)).map(collabFromRegistryEntry);
+}
+async function listCollabSessionViews(ctx, filter) {
+  const facade = ctx.collab;
+  if (facade?.listSessions)
+    return facade.listSessions(filter);
+  return (await listActiveCollab(ctx, filter)).map(sessionProjectionFromCollab);
+}
+async function joinCollab(ctx, input) {
+  const facade = ctx.collab;
+  if (facade?.join) {
+    await facade.join(input);
+    return;
+  }
+  if (facade?.joinCollabSession) {
+    await facade.joinCollabSession(input);
+    return;
+  }
+  throw new Error("OMP collab facade is unavailable for this extension context.");
+}
+function appendStatus(api, status, detail) {
+  api.appendEntry(RIG_WORKFLOW_STATUS_CHANGED, createWorkflowStatusChanged({
+    status,
+    ...detail ? { detail } : {}
+  }));
+}
+function appendWorkflowStatus(sessionManager, status, detail) {
+  sessionManager.appendCustomEntry(RIG_WORKFLOW_STATUS_CHANGED, createWorkflowStatusChanged({
+    status,
+    ...detail ? { detail } : {}
+  }));
+}
+function hasRecordedWorkflow(workflow) {
+  return Boolean(workflow.started || workflow.target || workflow.task || workflow.status || workflow.notes.length > 0 || workflow.inbox.length > 0 || workflow.resolvedInbox.length > 0);
+}
+function workflowWithCollabMarker(workflow, collab) {
+  if (!collab || hasRecordedWorkflow(workflow))
+    return workflow;
+  return projectCollabWorkflowMarker(collab);
+}
+function collabHostStartedFromEntries(entries) {
+  let found = null;
+  for (const entry of entries) {
+    if (entry.customType !== CUSTOM_TYPE_FOR["timeline-entry"] || !isRecord(entry.data))
+      continue;
+    const payload = isRecord(entry.data.payload) ? entry.data.payload : entry.data;
+    if (payload.type !== "collab-host-started")
+      continue;
+    found = {
+      roomId: typeof payload.roomId === "string" ? payload.roomId : undefined,
+      joinLink: typeof payload.joinLink === "string" ? payload.joinLink : undefined,
+      webLink: typeof payload.webLink === "string" ? payload.webLink : undefined,
+      relayUrl: typeof payload.relayUrl === "string" ? payload.relayUrl : undefined,
+      at: typeof entry.data.at === "string" ? entry.data.at : typeof payload.at === "string" ? payload.at : undefined
+    };
+  }
+  return found;
+}
+async function discoverLocalRunSessions(ctx) {
+  const projectRoot = rigProjectRoot();
+  let runtimes;
+  try {
+    runtimes = await listAgentRuntimes(projectRoot);
+  } catch {
+    return [];
+  }
+  const identity = resolveRigIdentity(ctx);
+  const owner = identity?.owner ?? { githubUserId: "", login: "", namespaceKey: resolveOwnerNamespaceKey(projectRoot) ?? "" };
+  const out = [];
+  for (const runtime of runtimes) {
+    const sessionDir = runtime.sessionDir;
+    if (!sessionDir || !existsSync(sessionDir))
+      continue;
+    let sessionFiles;
+    try {
+      sessionFiles = readdirSync(sessionDir).filter((f) => f.endsWith(".jsonl")).sort().reverse().map((f) => resolve(sessionDir, f));
+    } catch {
+      continue;
+    }
+    for (const sessionFile of sessionFiles) {
+      try {
+        const manager = await SessionManager.open(sessionFile, sessionDir, undefined, { suppressBreadcrumb: true });
+        const customs = customEntries2(manager.getBranch());
+        const host = collabHostStartedFromEntries(customs);
+        if (!host?.joinLink)
+          continue;
+        const at = host.at ?? new Date().toISOString();
+        const collab = {
+          sessionId: host.roomId || sessionFile,
+          sessionPath: sessionFile,
+          cwd: manager.getCwd(),
+          title: manager.getSessionName() || `Rig run ${runtime.id}`,
+          joinLink: host.joinLink,
+          webLink: host.webLink ?? "",
+          relayUrl: host.relayUrl ?? "",
+          owner,
+          selectedRepo: identity?.selectedRepo ?? "",
+          startedAt: at,
+          updatedAt: at,
+          stale: false
+        };
+        out.push({ ...sessionProjectionFromCollab(collab), customEntries: customs, source: "session-list" });
+        break;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return out;
+}
+async function discoverRigSessions(ctx) {
+  const identityFilter = ctx ? resolveRigIdentityFilter(ctx) : undefined;
+  const fallbackNamespace = resolveOwnerNamespaceKey(rigProjectRoot());
+  const discoveryFilter = identityFilter ?? (fallbackNamespace ? { namespaceKey: fallbackNamespace } : {});
+  const [viaRunScan, viaRegistry, viaLocal, viaRigRegistry] = await Promise.all([
+    ctx ? discoverLocalRunSessions(ctx).catch(() => []) : Promise.resolve([]),
+    ctx ? listCollabSessionViews(ctx, discoveryFilter).catch(() => []) : Promise.resolve([]),
+    listCollabSessionProjections(discoveryFilter).catch(() => []),
+    ctx ? (async () => {
+      const client = registryClientFor(ctx, discoveryFilter);
+      if (!client)
+        return [];
+      return (await client.listRoomsByOwner(discoveryFilter)).map(collabFromRegistryEntry).map(sessionProjectionFromCollab);
+    })().catch(() => []) : Promise.resolve([])
+  ]);
+  const seen = new Set;
+  const discovered = [];
+  for (const item of [...viaRunScan, ...viaRegistry, ...viaLocal, ...viaRigRegistry]) {
+    const key = item.session.path || item.collab?.sessionId || item.session.id;
+    if (!key || seen.has(key))
+      continue;
+    seen.add(key);
+    discovered.push(item);
+  }
+  return discovered.map((item) => {
+    const entries = customEntries2(item.customEntries);
+    const workflow = workflowWithCollabMarker(projectWorkflowEntries(entries), item.collab);
+    const run = foldRunSessionEntries(entries, runIdForProjection(item));
+    const timeline = timelineEntriesFromCustomEntries(entries);
+    return { session: item.session, workflow, collab: item.collab, run, timeline };
+  }).filter((projection) => hasRigWorkflow(projection.workflow, projection.collab, projection.run)).filter((projection) => !ctx || sessionBelongsToWorkspace(projection.session, projection.workflow, projection.collab, ctx)).sort((a, b) => projectionUpdatedAt(b) - projectionUpdatedAt(a));
+}
+async function joinRun(ctx, encodedSessionPath) {
+  const sessionPath = decodeURIComponent(encodedSessionPath);
+  const session = (await discoverRigSessions(ctx)).find((item) => item.session.path === sessionPath);
+  if (!session) {
+    ctx.ui.notify("Run selection is stale; refresh runs before joining.", "warning");
+    return;
+  }
+  const collab = session.collab;
+  if (!isJoinableCollab(collab)) {
+    const stale = Boolean(collab?.stale);
+    ctx.ui.notify(stale ? "Selected OMP collab session is stale; refresh runs before joining." : "Selected OMP session is not currently available through collab.", "warning");
+    return;
+  }
+  await joinCollab(ctx, { joinLink: collab.joinLink, cwd: collab.cwd || session.session.cwd });
+  ctx.ui.notify(`Joined ${session.session.id.slice(0, 8)} through OMP collab: ${collabLinks(collab)}`, "info");
+}
+function stopSentinel(runId, reason) {
+  return buildStopSentinel(runId, reason, "rig-extension");
+}
+async function steerRun(_api, ctx, encodedSessionPath, stop = false) {
+  const sessionPath = decodeURIComponent(encodedSessionPath);
+  const session = (await discoverRigSessions(ctx)).find((item) => item.session.path === sessionPath);
+  if (!session)
+    throw new Error("Run selection is stale; refresh runs before steering.");
+  const runId = session.run?.record.runId ?? session.session.id;
+  const prompt = stop ? stopSentinel(runId, await ctx.ui.editor("Stop reason (optional)", "operator requested stop")) : (await ctx.ui.editor("Steer Rig run", ""))?.trim();
+  if (!prompt)
+    return;
+  let guest = ctx.collabGuest;
+  if (!guest?.sendPrompt) {
+    await joinRun(ctx, encodeURIComponent(session.session.path));
+    guest = ctx.collabGuest;
+  }
+  if (!guest?.sendPrompt)
+    throw new Error("Joined run did not expose an OMP collab guest prompt transport.");
+  guest.sendPrompt(prompt);
+  ctx.ui.notify(stop ? `Stop requested for ${runId}.` : `Steered ${runId}.`, "info");
+}
+function inboxActionId(session, request) {
+  return `inbox:${encodeURIComponent(session.path)}:${encodeURIComponent(request.requestId)}`;
+}
+function parseInboxActionTarget(id) {
+  if (!id.startsWith("inbox:"))
+    return null;
+  const [encodedSessionPath, encodedRequestId] = id.slice("inbox:".length).split(":");
+  if (!encodedSessionPath || !encodedRequestId)
+    return null;
+  try {
+    const sessionPath = decodeURIComponent(encodedSessionPath);
+    const requestId = decodeURIComponent(encodedRequestId);
+    return sessionPath && requestId ? { sessionPath, requestId } : null;
+  } catch {
+    return null;
+  }
+}
+function inboxPrompt(request) {
+  return request.body ? `${request.title}
+${request.body}` : request.title;
+}
+function inboxResolutionMessage(request, decision, answer) {
+  if (decision === "approved")
+    return `Rig workflow inbox request "${request.title}" was approved.`;
+  if (decision === "rejected")
+    return `Rig workflow inbox request "${request.title}" was rejected.`;
+  return `Rig workflow inbox request "${request.title}" was answered:
+${String(answer ?? "")}`;
+}
+async function appendInboxResolved(api, ctx, session, request, decision, answer) {
+  const data = createWorkflowInboxResolved({
+    requestId: request.requestId,
+    decision,
+    ...decision === "answered" ? { answer: answer ?? "" } : {}
+  });
+  const detail = `Resolved inbox request ${request.requestId}.`;
+  if (session.path === ctx.sessionManager.getSessionFile()) {
+    api.appendEntry(RIG_WORKFLOW_INBOX_RESOLVED, data);
+    appendStatus(api, "running", detail);
+    return;
+  }
+  const target = await SessionManager.open(session.path, undefined, undefined, { suppressBreadcrumb: true });
+  target.appendCustomEntry(RIG_WORKFLOW_INBOX_RESOLVED, data);
+  appendWorkflowStatus(target, "running", detail);
+}
+async function resolveInboxRequest(api, ctx, id) {
+  const target = parseInboxActionTarget(id);
+  if (!target) {
+    ctx.ui.notify("Inbox action is malformed; refresh the Rig Inbox.", "warning");
+    return;
+  }
+  const session = (await discoverRigSessions(ctx)).find((item) => item.session.path === target.sessionPath);
+  const request = session?.workflow.inbox.find((item) => item.requestId === target.requestId);
+  if (!session || !request) {
+    ctx.ui.notify("Inbox request is stale or already resolved; refresh the Rig Inbox.", "warning");
+    return;
+  }
+  if (request.kind === "approval") {
+    const choice = await ctx.ui.select(inboxPrompt(request), ["Approve", "Reject"]);
+    if (!choice) {
+      ctx.ui.notify("Inbox approval cancelled.", "info");
+      return;
+    }
+    const decision = choice === "Approve" ? "approved" : "rejected";
+    await appendInboxResolved(api, ctx, session.session, request, decision);
+    api.sendUserMessage(inboxResolutionMessage(request, decision), { deliverAs: "followUp" });
+    ctx.ui.notify(`Inbox request ${request.requestId} ${decision}.`, "info");
+    return;
+  }
+  const answer = request.options && request.options.length > 0 ? await ctx.ui.select(inboxPrompt(request), [...request.options]) : await ctx.ui.editor(`Rig workflow input: ${request.title}`, request.body ?? "");
+  if (answer === undefined) {
+    ctx.ui.notify("Inbox input cancelled.", "info");
+    return;
+  }
+  await appendInboxResolved(api, ctx, session.session, request, "answered", answer);
+  api.sendUserMessage(inboxResolutionMessage(request, "answered", answer), { deliverAs: "followUp" });
+  ctx.ui.notify(`Inbox request ${request.requestId} answered.`, "info");
+}
+function defaultFlowActions(api, ctx, injectedBridge) {
+  return {
+    async act(id) {
+      if (id === "setup:start") {
+        await runRigSetupFlow(api, ctx, injectedBridge);
+        return;
+      }
+      if (id === "setup:doctor") {
+        const status = await detectRigStartupStatus(ctx);
+        notifyDoctor(ctx, "Setup doctor", status.checks);
+        if (status.reasons.length > 0 && ctx.hasUI)
+          ctx.ui.notify(`Setup needs attention: ${status.reasons.join("; ")}`, "warning");
+        return;
+      }
+      if (id.startsWith("server:select:")) {
+        const alias = decodeActionValue(id.slice("server:select:".length));
+        await selectServerTarget(ctx, selectedServerBridge(ctx, injectedBridge), alias);
+        if (ctx.hasUI)
+          ctx.ui.notify(`Selected Rig target ${alias}.`, "info");
+        return;
+      }
+      if (id === "server:add-remote") {
+        await addRemoteTarget(ctx, selectedServerBridge(ctx, injectedBridge));
+        if (ctx.hasUI)
+          ctx.ui.notify("Rig remote target saved and selected.", "info");
+        return;
+      }
+      if (id === "server:refresh" || id === "tasks:refresh") {
+        if (ctx.hasUI)
+          ctx.ui.notify("Rig Cockpit refreshed selected server/task state.", "info");
+        return;
+      }
+      if (id.startsWith("task-detail:dispatch:")) {
+        await dispatchSelectedTask(api, ctx, id, injectedBridge);
+        return;
+      }
+      if (id.startsWith("run:")) {
+        await joinRun(ctx, id.slice("run:".length));
+        return;
+      }
+      if (id.startsWith("run-steer:")) {
+        await steerRun(api, ctx, id.slice("run-steer:".length));
+        return;
+      }
+      if (id.startsWith("run-stop:")) {
+        await steerRun(api, ctx, id.slice("run-stop:".length), true);
+        return;
+      }
+      if (id.startsWith("inbox:")) {
+        await resolveInboxRequest(api, ctx, id);
+        return;
+      }
+      if (id === "doctor:sessions") {
+        await runSessionDoctor(api, ctx);
+        return;
+      }
+      if (id === "doctor:collab") {
+        await runCollabDoctor(ctx);
+        return;
+      }
+      if (ctx.hasUI)
+        ctx.ui.notify(`Unknown Rig action: ${id}`, "warning");
+    }
+  };
+}
+function notifyDoctor(ctx, title, checks) {
+  const failed = checks.filter((check) => check.level === "fail");
+  const summary = checks.map((check) => `${check.level} ${check.label}: ${check.detail}`).join(" \xB7 ");
+  ctx.ui.notify(`${title}: ${failed.length === 0 ? "ok" : "failed"} \xB7 ${summary}`, failed.length === 0 ? "info" : "error");
+}
+function appendOperatorNote(api, note) {
+  api.appendEntry(RIG_WORKFLOW_OPERATOR_NOTE, createWorkflowOperatorNote({ note }));
+}
+async function runSessionDoctor(api, ctx) {
+  const checks = await collectDoctorChecks(api, ctx);
+  notifyDoctor(ctx, "Sessions doctor", checks);
+}
+async function runCollabDoctor(ctx) {
+  const rigCtx = ctx;
+  const filter = resolveRigIdentityFilter(ctx);
+  const checks = [
+    { label: "identity-filter", level: filter ? "ok" : "warn", detail: filter ? `${filter.selectedRepo ?? "(repo?)"} / ${filter.namespaceKey ?? "(namespace?)"}` : "unavailable" },
+    { label: "host-api", level: rigCtx.collab?.startHost || rigCtx.collab?.startCollabHost ? "ok" : "fail", detail: "OMP collab host facade" },
+    { label: "join-api", level: rigCtx.collab?.join || rigCtx.collab?.joinCollabSession ? "ok" : "fail", detail: "OMP collab join facade" },
+    { label: "registry-api", level: rigCtx.collab?.listActive || rigCtx.collab?.listActiveCollabSessions || rigCtx.collab?.listSessions ? "ok" : "warn", detail: "OMP live collab registry facade" }
+  ];
+  if (filter) {
+    const collabs = await listActiveCollab(ctx, filter);
+    checks.push({ label: "registry-read", level: "ok", detail: `${collabs.length} live collab projection(s)` });
+  }
+  notifyDoctor(ctx, "Collab doctor", checks);
+}
+function commandFlowActions(api, ctx, injectedBridge) {
+  return {
+    async act(id) {
+      if (id === "setup:start") {
+        await runRigSetupFlow(api, ctx, injectedBridge);
+        return;
+      }
+      if (id === "setup:doctor") {
+        const status = await detectRigStartupStatus(ctx);
+        notifyDoctor(ctx, "Setup doctor", status.checks);
+        if (status.reasons.length > 0)
+          ctx.ui.notify(`Setup needs attention: ${status.reasons.join("; ")}`, "warning");
+        return;
+      }
+      if (id.startsWith("server:select:")) {
+        const alias = decodeActionValue(id.slice("server:select:".length));
+        await selectServerTarget(ctx, selectedServerBridge(ctx, injectedBridge), alias);
+        ctx.ui.notify(`Selected Rig target ${alias}.`, "info");
+        return;
+      }
+      if (id === "server:add-remote") {
+        await addRemoteTarget(ctx, selectedServerBridge(ctx, injectedBridge));
+        ctx.ui.notify("Rig remote target saved and selected.", "info");
+        return;
+      }
+      if (id === "server:refresh") {
+        ctx.ui.notify("Server target state refreshed from Rig Cockpit.", "info");
+        return;
+      }
+      if (id === "tasks:refresh") {
+        ctx.ui.notify("Task list refreshed from the selected server target.", "info");
+        return;
+      }
+      if (id.startsWith("task-detail:dispatch:")) {
+        await dispatchSelectedTask(api, ctx, id, injectedBridge);
+        return;
+      }
+      if (id.startsWith("run:")) {
+        await joinRun(ctx, id.slice("run:".length));
+        return;
+      }
+      if (id.startsWith("run-steer:")) {
+        await steerRun(api, ctx, id.slice("run-steer:".length));
+        return;
+      }
+      if (id.startsWith("run-stop:")) {
+        await steerRun(api, ctx, id.slice("run-stop:".length), true);
+        return;
+      }
+      if (id.startsWith("inbox:")) {
+        await resolveInboxRequest(api, ctx, id);
+        return;
+      }
+      if (id === "doctor:sessions") {
+        await runSessionDoctor(api, ctx);
+        return;
+      }
+      if (id === "doctor:collab") {
+        await runCollabDoctor(ctx);
+        return;
+      }
+      ctx.ui.notify(`Unknown Rig action: ${id}`, "warning");
+    }
+  };
+}
+function projectionUpdatedAt(item) {
+  const workflowUpdated = item.workflow.updatedAt ? Date.parse(item.workflow.updatedAt) : 0;
+  const collabUpdated = item.collab?.updatedAt ? Date.parse(item.collab.updatedAt) : 0;
+  return Math.max(item.session.modified.getTime(), Number.isFinite(workflowUpdated) ? workflowUpdated : 0, Number.isFinite(collabUpdated) ? collabUpdated : 0);
+}
+function statusGlyph(status) {
+  const value = status.toLowerCase();
+  if (value === "stale")
+    return "\u25CB";
+  if (value === "running")
+    return "\u25CF";
+  if (value === "completed" || value === "merged")
+    return "\u2713";
+  if (value === "failed")
+    return "\u2717";
+  if (value.includes("needs"))
+    return "!";
+  if (["preparing", "created", "validating", "reviewing", "closing-out", "starting", "adopted"].includes(value))
+    return "\u25D0";
+  return "\xB7";
+}
+function sessionLabel(item) {
+  const title = item.session.title || item.session.firstMessage || item.session.id;
+  return `${statusGlyph(sessionValue(item))} ${title}`;
+}
+function sessionValue(item) {
+  if (item.collab?.stale)
+    return "stale";
+  if (item.run?.status)
+    return item.run.status;
+  if (item.collab)
+    return "collab";
+  return item.workflow.status?.status ?? item.session.status ?? "session";
+}
+function sessionDescription(item) {
+  const id = item.session.id.slice(0, 8);
+  const cwd = item.session.cwd || "(unknown cwd)";
+  const link = item.collab ? collabLinks(item.collab) : "";
+  return link ? `${id} \xB7 ${cwd} \xB7 ${link}` : `${id} \xB7 ${cwd}`;
+}
+function collabLinks(collab) {
+  const join = collab.joinLink ? `joinLink ${collab.joinLink}` : "";
+  const web = collab.webLink ? `webLink ${collab.webLink}` : "";
+  return join && web ? `${join} \xB7 ${web}` : join || web || "links unavailable";
+}
+function inboxItems(sessions) {
+  const pending = [];
+  for (const session of sessions) {
+    for (const request of session.workflow.inbox)
+      pending.push({ session: session.session, request });
+  }
+  return pending.sort((a, b) => Date.parse(b.request.requestedAt) - Date.parse(a.request.requestedAt));
+}
+function findSessionByPath(sessions, sessionPath) {
+  if (!sessionPath)
+    return null;
+  return sessions.find((item) => item.session.path === sessionPath) ?? null;
+}
+var RUN_DETAIL_STAGES = [
+  "Connect",
+  "GitHub-sync",
+  "Prepare",
+  "Launch",
+  "Plan",
+  "Implement",
+  "Validate",
+  "Commit",
+  "Open-PR",
+  "Review/CI",
+  "Merge",
+  "Complete/Needs-attention/Failed"
+];
+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 "prepare":
+    case "preparing":
+      return "Prepare";
+    case "launch":
+    case "running":
+      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 "review-ci":
+      return "Review/CI";
+    case "merge":
+      return "Merge";
+    case "completed":
+    case "complete":
+    case "needs-attention":
+    case "failed":
+    case "stopped":
+      return "Complete/Needs-attention/Failed";
+    default:
+      return null;
+  }
+}
+function stageRows(session) {
+  const statuses = new Map;
+  const details = new Map;
+  for (const stage of RUN_DETAIL_STAGES)
+    statuses.set(stage, "pending");
+  for (const history of session.run?.statusHistory ?? []) {
+    const stage = normalizeStageName(history.to);
+    if (stage) {
+      statuses.set(stage, history.to === "failed" || history.to === "needs-attention" || history.to === "stopped" ? history.to : "completed");
+      if (history.reason)
+        details.set(stage, history.reason);
+    }
+  }
+  for (const entry of session.timeline ?? []) {
+    const stage = normalizeStageName(entry.stage ?? entry.type);
+    if (!stage)
+      continue;
+    const status = entry.status === "failed" || entry.status === "needs-attention" || entry.status === "stopped" ? entry.status : entry.status === "completed" || entry.status === "complete" ? "completed" : entry.status === "running" || entry.status === "started" ? "running" : "completed";
+    statuses.set(stage, status);
+    if (entry.detail)
+      details.set(stage, entry.detail);
+  }
+  for (const phase of session.run?.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 terminal = session.run?.status;
+  if (terminal === "completed" || terminal === "needs-attention" || terminal === "failed" || terminal === "stopped") {
+    statuses.set("Complete/Needs-attention/Failed", terminal);
+  }
+  return RUN_DETAIL_STAGES.map((stage) => ({
+    id: `stage:${stage}`,
+    label: stage,
+    currentValue: statuses.get(stage) ?? "pending",
+    heading: true,
+    description: details.get(stage) ?? "rig.run timeline / closeout projection"
+  }));
+}
+function runDetailItems(session) {
+  const collab = session.collab;
+  const task = session.workflow.task;
+  const encodedPath = encodeURIComponent(session.session.path);
+  const joinState = collab?.stale ? "stale" : "unavailable";
+  const joinDescription = collab?.stale ? "Stale collab registry entry; BACK refreshes the Runs list before joining." : "No active collab link for this OMP session; BACK refreshes the Runs list after the host is live.";
+  const prUrl = session.run?.record.prUrl;
+  const sourceTask = session.run?.record.sourceTask;
+  const issueUrl = sourceTask && typeof sourceTask === "object" && "url" in sourceTask ? String(sourceTask.url ?? "") : null;
+  return [
+    { id: "title", label: "Run Detail", currentValue: "", heading: true },
+    { id: "detail:back", label: "BACK", currentValue: "runs", values: ["runs"], description: "refresh runs and return to the session list" },
+    ...task ? [{ id: "run-detail:task", label: "TASK", currentValue: task.taskId, heading: true, description: task.title ?? "selected task" }] : [],
+    isJoinableCollab(collab) ? { id: "detail:join", label: "JOIN", currentValue: "live", values: ["join"], description: collabLinks(collab) } : { id: "detail:join-state", label: "JOIN", currentValue: joinState, heading: true, description: joinDescription },
+    ...collab?.webLink ? [{ id: "detail:web", label: "OPEN WEB", currentValue: collab.webLink, heading: true, description: "OMP collab web link" }] : [],
+    { id: `run-steer:${encodedPath}`, label: "STEER", currentValue: "message", values: ["send"], description: "join this run and send a steering prompt over OMP collab guest transport" },
+    { id: `run-stop:${encodedPath}`, label: "STOP", currentValue: "graceful", values: ["stop"], description: "send Rig stop sentinel over collab and request host abort" },
+    { id: "detail:summary", label: "SUMMARY", currentValue: sessionValue(session), heading: true, description: sessionLabel(session) },
+    { id: "detail:cwd", label: "CWD", currentValue: session.session.cwd || "(unknown cwd)", heading: true, description: session.session.id },
+    { id: "detail:status", label: "STATUS", currentValue: session.run?.status ?? session.workflow.status?.status ?? session.session.status ?? "session", heading: true, description: session.workflow.status?.detail || sessionDescription(session) },
+    ...prUrl ? [{ id: "detail:pr", label: "PR", currentValue: prUrl, heading: true, description: "closeout pull request" }] : [],
+    ...issueUrl ? [{ id: "detail:issue", label: "ISSUE", currentValue: issueUrl, heading: true, description: "source task issue" }] : [],
+    { id: "detail:stages", label: "STAGES", currentValue: "", heading: true, description: "Connect \u2192 GitHub-sync \u2192 Prepare \u2192 Launch \u2192 Plan \u2192 Implement \u2192 Validate \u2192 Commit \u2192 Open-PR \u2192 Review/CI \u2192 Merge \u2192 Complete" },
+    ...stageRows(session),
+    { id: "detail:inbox", label: "INBOX", currentValue: String(session.workflow.inbox.length), heading: true, description: session.workflow.inbox.length > 0 ? "Actionable run inbox items below." : "No pending Rig workflow inbox requests." },
+    ...session.workflow.inbox.map((item) => ({
+      id: inboxActionId(session.session, item),
+      label: item.title,
+      currentValue: "resolve",
+      values: ["resolve"],
+      description: item.body || item.kind
+    }))
+  ];
+}
+function serverLabel(server) {
+  return server?.alias?.trim() || "unselected";
+}
+function serverTarget(server) {
+  if (!server)
+    return "unknown";
+  return server.kind === "remote" ? server.baseUrl?.trim() || "remote" : "local";
+}
+function nextStepHint(server, sessions) {
+  if (!server)
+    return "next: Server";
+  if (sessions.some((session) => session.run?.status && !["completed", "failed", "stopped"].includes(session.run.status)))
+    return "next: Runs";
+  return "next: Tasks";
+}
+function taskRows(tasks, currentUserLogin) {
+  if (!tasks) {
+    return [{ id: "tasks:loading", label: "TASKS", currentValue: "not loaded", heading: true, description: "Refresh reads tasks from the selected spawn target's task source." }];
+  }
+  if (tasks.length === 0) {
+    return [{ id: "tasks:empty", label: "No configured tasks", currentValue: "", heading: true, description: "The selected server task source returned no tasks." }];
+  }
+  const projected = tasks.map(taskBadgeProjection);
+  const visible = process.env.RIG_TASKS_ASSIGNED_TO_ME === "1" ? selectTasksAssignedToMe(projected, currentUserLogin ?? null) : projected;
+  const sourceById = new Map(tasks.map((task) => [task.id, task]));
+  const badgesByTaskId = computeTaskDependencyBadges(visible);
+  const groups = selectTasksGroupedByStatus({ tasks: visible });
+  const next = selectNextReadyTaskByPriority(visible);
+  const ordered = groups.flatMap((group) => group.tasks).slice(0, 20);
+  return ordered.flatMap((task) => {
+    const sourceTask = sourceById.get(task.id);
+    if (!sourceTask)
+      return [];
+    const summary = badgesByTaskId.get(task.id);
+    const badge = summary?.badges.find((entry) => entry.kind === "blocked" || entry.kind === "ready")?.label ?? taskStatus(sourceTask);
+    return [{
+      id: `task-detail:${encodeURIComponent(task.id)}`,
+      label: taskTitle(sourceTask),
+      currentValue: badge,
+      values: ["open"],
+      description: [next?.id === task.id ? "next-ready" : null, taskAssigneeText(sourceTask), summary?.badges.map((entry) => entry.description).join("; "), taskDescription(sourceTask) || task.id].filter(Boolean).join(" \xB7 ")
+    }];
+  });
+}
+function taskDetailRows(state, actionRowsEnabled) {
+  const task = state.selectedTask ?? null;
+  const id = taskId(task);
+  if (!task || !id) {
+    return [
+      { id: "title", label: "Task Detail", currentValue: "", heading: true },
+      { id: "detail:back", label: "BACK", currentValue: "tasks", values: ["tasks"], description: "return to the configured task list" },
+      { id: "task-detail:none", label: "No task selected", currentValue: state.selectedTaskId ?? "", heading: true, description: "Open a task row from Tasks before dispatch." }
+    ];
+  }
+  return [
+    { id: "title", label: "Task Detail", currentValue: "", heading: true },
+    { id: "detail:back", label: "BACK", currentValue: "tasks", values: ["tasks"], description: "return to the configured task list" },
+    { id: "task-detail:summary", label: "TASK", currentValue: id, heading: true, description: taskTitle(task) },
+    { id: "task-detail:status", label: "STATUS", currentValue: taskStatus(task), heading: true, description: task.source ?? "configured task source" },
+    ...task.url ? [{ id: "task-detail:url", label: "URL", currentValue: task.url, heading: true, description: "source task URL" }] : [],
+    ...task.body ? [{ id: "task-detail:body", label: "BODY", currentValue: task.body.slice(0, 120), heading: true, description: "source task body" }] : [],
+    actionRowsEnabled ? { id: `task-detail:dispatch:${encodeURIComponent(id)}`, label: "DISPATCH", currentValue: state.server?.kind ?? "selected target", values: ["dispatch"], description: "submit the selected task run through the selected server target, then attach OMP collab" } : { id: `task-detail:dispatch:${encodeURIComponent(id)}`, label: "DISPATCH", currentValue: "selected target", values: ["dispatch"], description: "direct dispatch through the selected server target" }
+  ];
+}
+function itemsFor(screen, sessions, actionRowsEnabled, selectedSessionPath, state = {}) {
+  const selectedSession = findSessionByPath(sessions, selectedSessionPath);
+  const server = state.server ?? null;
+  if (screen === "runs" && selectedSession)
+    return runDetailItems(selectedSession);
+  switch (screen) {
+    case "cockpit":
+      return [
+        { id: "title", label: "Project Cockpit", currentValue: "", heading: true },
+        { id: "next", label: "NEXT", currentValue: nextStepHint(server, sessions), heading: true, description: "guided path: Server \u2192 Tasks \u2192 Detail \u2192 Dispatch \u2192 Run Detail" },
+        { id: "to:server", label: "SERVER", currentValue: serverLabel(server), values: ["open"], description: "select/configure execution placement before listing tasks" },
+        { id: "to:tasks", label: "TASKS", currentValue: server?.taskSource ?? "configured source", values: ["open"], description: "list tasks from the selected server target's configured task source" },
+        { id: "to:runs", label: "RUNS", currentValue: String(sessions.length), values: ["open"], description: "attach to dispatched Rig runs and live OMP collaborative sessions" },
+        { id: "to:inbox", label: "INBOX", currentValue: String(inboxItems(sessions).length), values: ["open"], description: "pending Rig workflow requests recorded in OMP entries" },
+        { id: "to:doctor", label: "DOCTOR", currentValue: "open", values: ["open"], description: "diagnose session, collaboration, and selected-target seams" },
+        { id: "to:setup", label: "SETUP", currentValue: "open", values: ["open"], description: "repair project setup, auth, labels, placement, and local OMP extension registration" }
+      ];
+    case "runs":
+      return [
+        { id: "title", label: "Runs", currentValue: sessions.length > 0 ? String(sessions.length) : "", heading: true, description: "dispatched Rig runs; open one to attach its live OMP collaborative session" },
+        ...sessions.length > 0 ? sessions.slice(0, 12).map((item) => ({
+          id: `run-detail:${encodeURIComponent(item.session.path)}`,
+          label: sessionLabel(item),
+          currentValue: sessionValue(item),
+          values: ["open"],
+          description: sessionDescription(item)
+        })) : [{ id: "none", label: "No Rig runs discovered", currentValue: "", heading: true, description: "Dispatch a configured task from task detail to create one." }]
+      ];
+    case "server":
+      return [
+        { id: "title", label: "Spawn Target", currentValue: "", heading: true },
+        { id: "server:selected", label: "TARGET", currentValue: serverLabel(server), heading: true, description: serverTarget(server) },
+        ...(state.serverTargets ?? []).map((target) => ({
+          id: `server:select:${encodeURIComponent(target.alias)}`,
+          label: target.alias === server?.alias ? `ACTIVE ${target.alias}` : `SELECT ${target.alias}`,
+          currentValue: target.kind,
+          values: ["select"],
+          description: `${target.status ?? "ready"} \xB7 ${target.projectRoot ?? target.baseUrl ?? "target"} \xB7 ${target.taskSource ?? "tasks"}`
+        })),
+        { id: "server:placement", label: "PLACEMENT", currentValue: server?.kind ?? "unknown", heading: true, description: "collaboration is invariant OMP session capability, not a target" },
+        { id: "server:root", label: "PROJECT ROOT", currentValue: server?.projectRoot ?? "(unscoped)", heading: true, description: server?.detail ?? "remote dispatch preserves the spawn target project-root link; local dispatch scopes to this checkout" },
+        { id: "server:status", label: "STATUS", currentValue: server?.status ?? "unknown", heading: true, description: server?.taskSource ? `task source: ${server.taskSource}` : "spawn target status" },
+        { id: "server:add-remote", label: "ADD REMOTE", currentValue: "alias", values: ["add"], description: "save a remote alias to remotes.toml/authority and select it" },
+        actionRowsEnabled ? { id: "server:refresh", label: "REFRESH", currentValue: "spawn target", values: ["refresh"], description: "refresh spawn-placement state before reading tasks" } : { id: "server:refresh", label: "REFRESH", currentValue: "spawn target", values: ["refresh"], description: "refresh spawn-placement state before reading tasks" }
+      ];
+    case "tasks":
+      return [
+        { id: "title", label: "Configured Tasks", currentValue: "", heading: true },
+        { id: "tasks:source", label: "TASKS", currentValue: server?.taskSource ?? "configured source", heading: true, description: `rows come from ${serverLabel(server)} on the selected target; no synthetic tasks` },
+        ...taskRows(state.tasks, state.currentUserLogin),
+        actionRowsEnabled ? { id: "tasks:refresh", label: "REFRESH", currentValue: "task source", values: ["refresh"], description: "read configured tasks from the selected target" } : { id: "tasks:refresh", label: "REFRESH", currentValue: "task source", values: ["refresh"], description: "read configured tasks from the selected target" }
+      ];
+    case "task-detail":
+      return taskDetailRows({ ...state, server }, actionRowsEnabled);
+    case "inbox": {
+      const pending = inboxItems(sessions);
+      return [
+        { id: "title", label: "Inbox", currentValue: "", heading: true },
+        ...pending.length > 0 ? pending.slice(0, 12).map(({ session, request }) => ({
+          id: inboxActionId(session, request),
+          label: request.title,
+          currentValue: actionRowsEnabled ? "resolve" : "open",
+          values: [actionRowsEnabled ? "resolve" : "open"],
+          description: request.body || `${request.kind} \xB7 ${session.id.slice(0, 8)} \xB7 ${session.cwd || "(unknown cwd)"}`
+        })) : [{ id: "empty", label: "No pending Rig workflow inbox requests", currentValue: "", heading: true, description: `${RIG_WORKFLOW_INBOX_REQUESTED} entries will appear here until ${RIG_WORKFLOW_INBOX_RESOLVED}.` }]
+      ];
+    }
+    case "setup": {
+      const status = state.setupStatus;
+      return [
+        { id: "title", label: "Setup", currentValue: status?.configured ? "configured" : "needs setup", heading: true },
+        { id: "setup:repo", label: "REPO", currentValue: status?.slug ?? "unknown", heading: true, description: status?.projectRoot ?? "current workspace" },
+        { id: "setup:config", label: "CONFIG", currentValue: status?.config.valid ? "ok" : "needs repair", heading: true, description: status?.config.reason ?? status?.config.path ?? "rig.config.ts" },
+        { id: "setup:state", label: "STATE", currentValue: status?.state.valid ? "ok" : "needs repair", heading: true, description: status?.state.reason ?? `${status?.state.selected ?? "placement"} -> ${status?.state.project ?? "project"}` },
+        { id: "setup:auth", label: "GITHUB AUTH", currentValue: status?.auth.ok ? status.auth.source : "needs auth", heading: true, description: status?.auth.detail ?? "stored token or gh auth required" },
+        { id: "setup:placement", label: "PLACEMENT", currentValue: process.env.RIG_SSH_TARGET?.trim() ? "remote" : "local", heading: true, description: process.env.RIG_SSH_TARGET?.trim() ? `ssh ${process.env.RIG_SSH_TARGET.trim()} \xB7 set via rig config set sshTarget <t>` : "runs execute locally \xB7 rig config set sshTarget <ubuntu@host> for remote" },
+        { id: "setup:backbone", label: "BACKBONE", currentValue: rigRelayUrl().replace(/^wss?:\/\//, ""), heading: true, description: `relay ${rigRelayUrl()} \xB7 registry ${registryBaseUrl()}` },
+        ...status?.reasons.length ? [{ id: "setup:reasons", label: "NEEDS ATTENTION", currentValue: String(status.reasons.length), heading: true, description: status.reasons.join(" \xB7 ") }] : [],
+        ...(state.serverTargets ?? []).map((target) => ({
+          id: `server:select:${encodeURIComponent(target.alias)}`,
+          label: target.alias === server?.alias ? `ACTIVE ${target.alias}` : `PLACEMENT ${target.alias}`,
+          currentValue: target.kind,
+          values: ["select"],
+          description: `${target.status ?? "ready"} \xB7 ${target.projectRoot ?? target.baseUrl ?? "target"}`
+        })),
+        { id: "setup:start", label: status?.configured ? "RECONFIGURE" : "START SETUP", currentValue: "wizard", values: ["run"], description: "detect repo, choose placement, authenticate GitHub, write state/config, labels, and verify OMP extension" },
+        { id: "setup:doctor", label: "CHECK SETUP", currentValue: "doctor", values: ["check"], description: "run cheap setup checks without changing files" }
+      ];
+    }
+    case "doctor":
+      return [
+        { id: "title", label: "Doctor", currentValue: "", heading: true },
+        ...doctorCheckRows(state.doctorChecks),
+        actionRowsEnabled ? { id: "doctor:sessions", label: "RE-PROBE SESSIONS", currentValue: "probe", values: ["probe"], description: "refresh persistent doctor rows" } : { id: "doctor:sessions", label: "RE-PROBE SESSIONS", currentValue: "probe", values: ["probe"], description: "probe SessionManager visibility directly from Rig chrome" },
+        { id: "doctor:truth", label: "TRUTH", currentValue: "Rig Cockpit", heading: true, description: "Rig reads selected server/task state and OMP session entries" }
+      ];
+  }
+}
+
+class RigFlowComponent {
+  tui;
+  api;
+  done;
+  onQuit;
+  refreshSessions;
+  refreshState;
+  actions;
+  actionRowsEnabled;
+  #view;
+  #sessions;
+  #state;
+  #error = "";
+  #runsList = new RunsList;
+  #tasksView = new TasksView;
+  #inboxView = new InboxView;
+  #helpView = new HelpView;
+  #serverLabel = "resolving target\u2026";
+  #notice = null;
+  #inputLine = null;
+  #tick = 0;
+  #sessionByRunId = new Map;
+  #inboxPathByKey = new Map;
+  #discoveryFiber;
+  #refreshing = false;
+  constructor(tui, api, done, onQuit, screen, sessions, state, refreshSessions, refreshState, actions, actionRowsEnabled) {
+    this.tui = tui;
+    this.api = api;
+    this.done = done;
+    this.onQuit = onQuit;
+    this.refreshSessions = refreshSessions;
+    this.refreshState = refreshState;
+    this.actions = actions;
+    this.actionRowsEnabled = actionRowsEnabled;
+    this.#sessions = sessions;
+    this.#state = state;
+    this.#view = screen === "tasks" ? "tasks" : screen === "inbox" ? "inbox" : "board";
+    this.#feedViews();
+    this.#startDiscoveryStream();
+  }
+  #startDiscoveryStream() {
+    try {
+      const root = rigProjectRoot();
+      const remote = this.#remoteRunChangesStream(root);
+      const sources = [
+        { source: "local", stream: localRunChanges(root) },
+        ...remote ? [{ source: "remote", stream: remote }] : []
+      ];
+      const onChange = () => this.#refreshFromEvent();
+      const program = Effect.gen(function* () {
+        const events = yield* forkDiscoverySources(sources);
+        yield* Stream.runForEach(events.pipe(Stream.debounce(Duration.millis(500))), () => Effect.promise(onChange));
+      }).pipe(Effect.provide(RunDiscoveryBus.layer));
+      this.#discoveryFiber = Effect.runFork(program);
+    } catch {}
+  }
+  #remoteRunChangesStream(projectRoot) {
+    try {
+      if (!resolveSelectedRemote(projectRoot))
+        return null;
+      const secret = registrySecret();
+      const namespaceKey = resolveOwnerNamespaceKey(projectRoot);
+      if (!secret || !namespaceKey)
+        return null;
+      const base = registryBaseUrl().replace(/\/+$/, "");
+      const url = `${base}/subscribe?namespaceKey=${encodeURIComponent(namespaceKey)}`;
+      return remoteRunChanges({ url, token: deriveOwnerToken(namespaceKey, secret) });
+    } catch {
+      return null;
+    }
+  }
+  async#refreshFromEvent() {
+    if (this.#refreshing)
+      return;
+    this.#refreshing = true;
+    try {
+      await this.#refreshCurrent();
+      this.tui.requestRender();
+    } catch {} finally {
+      this.#refreshing = false;
+    }
+  }
+  #feedViews() {
+    this.#serverLabel = serverLabel(this.#state.server ?? null);
+    this.#sessionByRunId.clear();
+    this.#serverLabel = serverLabel(this.#state.server ?? null);
+    this.#sessionByRunId.clear();
+    const runs = this.#sessions.map((entry) => {
+      const runId = entry.session.id;
+      this.#sessionByRunId.set(runId, entry);
+      return { runId, status: sessionValue(entry), title: entry.session.title || entry.session.firstMessage || entry.session.id };
+    });
+    this.#runsList.setRuns(runs);
+    this.#tasksView.setTasks((this.#state.tasks ?? []).map((task) => ({
+      id: String(task.id),
+      status: typeof task.status === "string" ? task.status : "open",
+      title: typeof task.title === "string" ? task.title : "(untitled)"
+    })));
+    this.#inboxPathByKey.clear();
+    const items = inboxItems(this.#sessions).map((entry) => {
+      const requestId = String(entry.request.requestId ?? "");
+      const runId = entry.session.id;
+      const kind = entry.request.kind === "approval" ? "approval" : "input";
+      this.#inboxPathByKey.set(`${runId}:${requestId}`, entry.session.path);
+      return { kind, runId, requestId, summary: entry.request.title ?? (kind === "approval" ? "approval requested" : "input requested"), questionId: null, options: [] };
+    });
+    this.#inboxView.setItems(items);
+    this.#runsList.tick = this.#tick;
+    this.#tasksView.tick = this.#tick;
+    this.#inboxView.tick = this.#tick;
+  }
+  #activeView() {
+    return this.#view === "tasks" ? this.#tasksView : this.#view === "inbox" ? this.#inboxView : this.#runsList;
+  }
+  #setView(next) {
+    this.#view = next;
+    this.#notice = null;
+    this.tui.requestRender();
+  }
+  async#refreshCurrent() {
+    this.#sessions = await this.refreshSessions();
+    const screen = this.#view === "tasks" ? "tasks" : this.#view === "inbox" ? "inbox" : "runs";
+    this.#state = await this.refreshState(screen, null);
+    if (this.#state.error)
+      this.#error = this.#state.error;
+    this.#feedViews();
+  }
+  async#runAction(action) {
+    try {
+      this.#error = "";
+      await action();
+      await this.#refreshCurrent();
+      this.tui.requestRender();
+    } catch (error) {
+      this.#error = error instanceof Error ? error.message : String(error);
+      this.tui.requestRender();
+    }
+  }
+  #headerLine() {
+    const crumb = this.#view === "help" ? ` ${ink4("\u203A")} ${ink2("help")}` : this.#view === "tasks" ? ` ${ink4("\u203A")} ${ink2("new run")}` : this.#view === "inbox" ? ` ${ink4("\u203A")} ${ink2("inbox")}` : "";
+    return ` ${accent("\u258D")}${bold(ink("rig"))} ${ink3("\u2014 operate the drones")}${crumb}   ${ink4("\xB7")} ${cyan(this.#serverLabel)}`;
+  }
+  #footerLines() {
+    if (this.#inputLine) {
+      const label = this.#inputLine.kind === "search" ? `${accent("/")}${ink(this.#inputLine.buffer)}` : `${accentDim("answer")} ${ink3(`(${this.#inputLine.item.runId.slice(0, 8)})`)} ${accent("\u276F")} ${ink(this.#inputLine.buffer)}`;
+      return [
+        ` ${label}${accent("\u2588")}`,
+        ` ${accent("enter")}${ink3(this.#inputLine.kind === "search" ? " keep filter" : " send answer")}  ${accent("esc")}${ink3(this.#inputLine.kind === "search" ? " clear" : " cancel")}`
+      ];
+    }
+    if (this.#error)
+      return [` ${red(`error: ${this.#error}`)}`, ` ${accent("esc")}${ink3(" board")}  ${accent("q")}${ink3(" quit")}`];
+    if (this.#view === "help")
+      return [` ${accent("\u2190")}${ink3(" back")}  ${accent("esc")}${ink3(" board")}  ${accent("q")}${ink3(" quit")}`];
+    if (this.#view === "tasks") {
+      return [
+        ` ${this.#notice ? accentDim(this.#notice) : ink4("pick a task \u2014 a drone launches with project defaults")}`,
+        ` ${accent("\u2190")}${ink3(" back")}  ${accent("enter")}${ink3(" dispatch")}  ${accent("r")}${ink3(" reload")}  ${accent("esc")}${ink3(" board")}  ${accent("q")}${ink3(" quit")}`
+      ];
+    }
+    if (this.#view === "inbox") {
+      return [
+        ` ${this.#notice ? accentDim(this.#notice) : ink4("gates the fleet is waiting on \u2014 resolve them here")}`,
+        ` ${accent("\u2190")}${ink3(" back")}  ${accent("a")}${ink3(" approve")}  ${accent("d")}${ink3(" reject")}  ${accent("enter")}${ink3(" answer input")}  ${accent("r")}${ink3(" reload")}  ${accent("esc")}${ink3(" board")}`
+      ];
+    }
+    const pending = this.#inboxView.items.length;
+    const status = this.#notice ?? (pending > 0 ? `${RIG_SPINNER_FRAMES[this.#tick % RIG_SPINNER_FRAMES.length]} ${pending} inbox gate${pending === 1 ? "" : "s"} waiting \u2014 press i` : "fleet idle gates clear");
+    return [
+      ` ${pending > 0 && !this.#notice ? accentDim(status) : ink4(status)}`,
+      ` ${accent("enter")}${ink3(" attach")}  ${accent("n")}${ink3(" new run")}  ${accent("i")}${ink3(" inbox")}  ${accent("/")}${ink3(" search")}  ${accent("o")}${ink3(" sort")}  ${accent("x")}${ink3(" stop")}  ${accent("?")}${ink3(" help")}  ${accent("q")}${ink3(" quit")}`
+    ];
+  }
+  async#attach(run) {
+    const session = this.#sessionByRunId.get(run.runId);
+    if (!session)
+      return;
+    await this.#runAction(() => this.actions.act(`run:${encodeURIComponent(session.session.path)}`));
+    if (!this.#error)
+      this.done();
+  }
+  async#dispatch(task) {
+    this.#notice = `dispatching drone for ${task.id}\u2026`;
+    this.tui.requestRender();
+    await this.#runAction(() => this.actions.act(`task-detail:dispatch:${encodeURIComponent(task.id)}`));
+    this.#setView("board");
+    this.#notice = `drone dispatched on ${task.id}`;
+  }
+  async#stop(run) {
+    const session = this.#sessionByRunId.get(run.runId);
+    if (!session)
+      return;
+    this.#notice = `stop requested for ${run.runId.slice(0, 8)}\u2026`;
+    this.tui.requestRender();
+    await this.#runAction(() => this.actions.act(`run-stop:${encodeURIComponent(session.session.path)}`));
+  }
+  async#resolveInbox(item) {
+    const path = this.#inboxPathByKey.get(`${item.runId}:${item.requestId}`);
+    if (!path)
+      return;
+    await this.#runAction(() => this.actions.act(`inbox:${encodeURIComponent(path)}:${encodeURIComponent(item.requestId)}`));
+  }
+  render(width) {
+    const lines = [this.#headerLine(), hairline(width)];
+    const view = this.#view === "help" ? this.#helpView : this.#activeView();
+    for (const line of view.render(width))
+      lines.push(line);
+    lines.push(hairline(width));
+    for (const line of this.#footerLines())
+      lines.push(line);
+    return lines;
+  }
+  invalidate() {
+    this.#runsList.invalidate();
+    this.#tasksView.invalidate();
+    this.#inboxView.invalidate();
+    this.#helpView.invalidate();
+  }
+  handleInput(data) {
+    if (data === "q") {
+      this.onQuit();
+      return;
+    }
+    if (isKeyRelease(data))
+      return;
+    if (this.#inputLine) {
+      const line = this.#inputLine;
+      if (matchesKey(data, "escape")) {
+        if (line.kind === "search")
+          this.#runsList.setFilter("");
+        this.#inputLine = null;
+      } else if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+        this.#inputLine = null;
+        if (line.kind === "answer" && line.buffer.trim())
+          this.#resolveInbox(line.item);
+      } else if (matchesKey(data, "backspace")) {
+        const buffer = line.buffer.slice(0, -1);
+        this.#inputLine = line.kind === "search" ? { kind: "search", buffer } : { kind: "answer", buffer, item: line.item };
+        if (line.kind === "search")
+          this.#runsList.setFilter(buffer);
+      } else if (data.length === 1 && data >= " ") {
+        const buffer = line.buffer + data;
+        this.#inputLine = line.kind === "search" ? { kind: "search", buffer } : { kind: "answer", buffer, item: line.item };
+        if (line.kind === "search")
+          this.#runsList.setFilter(buffer);
+      }
+      this.tui.requestRender();
+      return;
+    }
+    if (matchesKey(data, "ctrl+c")) {
+      this.done();
+      return;
+    }
+    if (this.#view === "help") {
+      if (matchesKey(data, "up") || data === "k")
+        this.#helpView.scroll(-1);
+      else if (matchesKey(data, "down") || data === "j")
+        this.#helpView.scroll(1);
+      else if (matchesKey(data, "pageUp"))
+        this.#helpView.scroll(-15);
+      else if (matchesKey(data, "pageDown") || data === " ")
+        this.#helpView.scroll(15);
+      else if (matchesKey(data, "left") || matchesKey(data, "escape") || data === "?")
+        this.#setView("board");
+      this.tui.requestRender();
+      return;
+    }
+    if (this.#view === "tasks") {
+      if (matchesKey(data, "up") || data === "k")
+        this.#tasksView.moveSelection(-1);
+      else if (matchesKey(data, "down") || data === "j")
+        this.#tasksView.moveSelection(1);
+      else if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+        const task = this.#tasksView.selectedTask();
+        if (task)
+          this.#dispatch(task);
+      } else if (data === "r")
+        this.#runAction(async () => {});
+      else if (matchesKey(data, "left") || matchesKey(data, "escape"))
+        this.#setView("board");
+      this.tui.requestRender();
+      return;
+    }
+    if (this.#view === "inbox") {
+      if (matchesKey(data, "up") || data === "k")
+        this.#inboxView.moveSelection(-1);
+      else if (matchesKey(data, "down") || data === "j")
+        this.#inboxView.moveSelection(1);
+      else if (data === "a") {
+        const item = this.#inboxView.selectedItem();
+        if (item?.kind === "approval")
+          this.#resolveInbox(item);
+      } else if (data === "d") {
+        const item = this.#inboxView.selectedItem();
+        if (item?.kind === "approval")
+          this.#resolveInbox(item);
+      } else if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+        const item = this.#inboxView.selectedItem();
+        if (item?.kind === "input")
+          this.#inputLine = { kind: "answer", buffer: "", item };
+        else if (item?.kind === "approval")
+          this.#resolveInbox(item);
+      } else if (data === "r")
+        this.#runAction(async () => {});
+      else if (matchesKey(data, "left") || matchesKey(data, "escape"))
+        this.#setView("board");
+      this.tui.requestRender();
+      return;
+    }
+    if (matchesKey(data, "up") || data === "k") {
+      this.#runsList.moveSelection(-1);
+      this.tui.requestRender();
+      return;
+    }
+    if (matchesKey(data, "down") || data === "j") {
+      this.#runsList.moveSelection(1);
+      this.tui.requestRender();
+      return;
+    }
+    if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+      const run = this.#runsList.selectedRun();
+      if (run)
+        this.#attach(run);
+      return;
+    }
+    if (data === "?" || data === "h") {
+      this.#setView("help");
+      return;
+    }
+    if (data === "n") {
+      this.#setView("tasks");
+      this.#runAction(async () => {});
+      return;
+    }
+    if (data === "i") {
+      this.#setView("inbox");
+      this.#runAction(async () => {});
+      return;
+    }
+    if (data === "/") {
+      this.#inputLine = { kind: "search", buffer: this.#runsList.filter };
+      this.tui.requestRender();
+      return;
+    }
+    if (data === "o") {
+      const mode = this.#runsList.cycleSort();
+      this.#notice = `sorted: ${mode}`;
+      this.tui.requestRender();
+      return;
+    }
+    if (data === "x") {
+      const run = this.#runsList.selectedRun();
+      if (run)
+        this.#stop(run);
+      return;
+    }
+    if (data === "r") {
+      this.#runAction(async () => {});
+      return;
+    }
+    if (matchesKey(data, "escape")) {
+      if (this.#runsList.filter) {
+        this.#runsList.setFilter("");
+        this.tui.requestRender();
+        return;
+      }
+      this.done();
+      return;
+    }
+  }
+  dispose() {
+    const fiber = this.#discoveryFiber;
+    this.#discoveryFiber = undefined;
+    if (fiber)
+      Effect.runFork(Fiber.interrupt(fiber));
+  }
+}
+var EMPTY_SCENE_LINES = [];
+
+class FullscreenSceneProxy {
+  inner;
+  onDispose;
+  constructor(inner, onDispose) {
+    this.inner = inner;
+    this.onDispose = onDispose;
+  }
+  render() {
+    return EMPTY_SCENE_LINES;
+  }
+  handleInput(data) {
+    this.inner.handleInput?.(data);
+  }
+  invalidate() {
+    this.inner.invalidate?.();
+  }
+  dispose() {
+    this.onDispose();
+    this.inner.dispose?.();
+  }
+}
+async function openRigFlow(api, ctx, screen, actions = defaultFlowActions(api, ctx), actionRowsEnabled = true, injectedBridge, quitExits = false) {
+  const refreshSessions = async () => discoverRigSessions(ctx);
+  const refreshState = (nextScreen, selectedTaskId) => loadRigFlowState(ctx, nextScreen, selectedTaskId, injectedBridge, api);
+  const [sessions, state] = await Promise.all([refreshSessions(), refreshState(screen, null)]);
+  await ctx.ui.custom((tui, _theme, _keybindings, done) => {
+    let handle;
+    const hideScene = () => {
+      handle?.hide();
+      handle = undefined;
+    };
+    const finish = () => {
+      hideScene();
+      done(undefined);
+    };
+    const onQuit = quitExits ? () => {
+      hideScene();
+      ctx.shutdown();
+    } : finish;
+    const component = new RigFlowComponent(tui, api, finish, onQuit, screen, sessions, state, refreshSessions, refreshState, actions, actionRowsEnabled);
+    handle = tui.showOverlay(component, { width: "100%", maxHeight: "100%", anchor: "top-left", margin: 0, fullscreen: true });
+    tui.setFocus(component);
+    return new FullscreenSceneProxy(component, hideScene);
+  });
+}
+function launchRigFlow(api, ctx, screen, actions = defaultFlowActions(api, ctx), actionRowsEnabled = true, injectedBridge, quitExits = false) {
+  openRigFlow(api, ctx, screen, actions, actionRowsEnabled, injectedBridge, quitExits).catch((error) => {
+    ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+  });
+}
+function registerWorkflowInboxTool(api) {
+  const { Type } = api.typebox;
+  const parameters = Type.Object({
+    kind: Type.Union([Type.Literal("approval"), Type.Literal("input")], { description: "Whether the operator must approve/reject or provide input." }),
+    title: Type.String({ minLength: 1, description: "Short title shown in the Rig Inbox row." }),
+    body: Type.Optional(Type.String({ description: "Optional context shown before resolving the inbox request." })),
+    options: Type.Optional(Type.Array(Type.String({ minLength: 1 }), { description: "Optional answer choices for input requests." })),
+    requestId: Type.Optional(Type.String({ minLength: 1, description: "Stable workflow request id. Defaults to the tool call id." }))
+  }, { additionalProperties: false });
+  api.registerTool({
+    name: "rig_workflow_inbox_request",
+    label: "Request Rig workflow inbox action",
+    description: "Create a pending Rig workflow inbox request backed by OMP custom entries. Use this when a Rig workflow needs operator approval or input before continuing.",
+    parameters,
+    approval: "write",
+    async execute(toolCallId, params, _signal, _onUpdate, ctx) {
+      const input = params;
+      const requestId = input.requestId?.trim() || toolCallId;
+      const title = input.title.trim();
+      const body = input.body?.trim();
+      const options = input.options?.map((option) => option.trim()).filter((option) => option.length > 0);
+      const request = createWorkflowInboxRequested({
+        requestId,
+        kind: input.kind,
+        title,
+        ...body ? { body } : {},
+        ...options && options.length > 0 ? { options } : {}
+      });
+      api.appendEntry(RIG_WORKFLOW_INBOX_REQUESTED, request);
+      appendStatus(api, input.kind === "approval" ? "waiting-approval" : "waiting-input", `Rig workflow inbox request ${requestId}: ${title}`);
+      if (ctx.hasUI)
+        ctx.ui.notify(`Rig inbox request queued: ${title}`, "info");
+      return {
+        content: [{ type: "text", text: `Rig workflow inbox request ${requestId} is pending in the Rig Inbox.` }],
+        details: { requestId, kind: input.kind }
+      };
+    }
+  });
+}
+async function createRunJournal(sessionManager, runId) {
+  try {
+    const mod = await import("@rig/runtime/control-plane/run-session-writer");
+    const loadedModule = mod;
+    const maybeJournal = loadedModule && typeof loadedModule === "object" && "RunSessionJournal" in loadedModule ? loadedModule.RunSessionJournal : null;
+    const Journal = typeof maybeJournal === "function" ? maybeJournal : null;
+    return Journal ? new Journal(sessionManager, runId) : null;
+  } catch (error) {
+    console.warn(`[rig-run] RunSessionJournal unavailable; run-state arming deferred: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+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);
+}
+function createRunProcessStopController(journal, stopHost, exit = (code) => {
+  process.exitCode = code;
+  setTimeout(() => process.exit(code), 0);
+}, deps = {}) {
+  let stopRequested = null;
+  let finished = false;
+  const finishStopped = async () => {
+    if (finished)
+      return;
+    finished = true;
+    journal?.appendTimeline({ type: "stopped", stage: "stopped", status: "completed", detail: stopRequested?.reason ?? "operator requested stop" });
+    journal?.appendStatus("stopped", { actor: { kind: "operator" }, reason: stopRequested?.reason ?? "operator requested stop", force: true });
+    await stopHost?.("rig stop requested").catch(() => {
+      return;
+    });
+    exit(0);
+  };
+  return {
+    isStopRequested: () => Boolean(stopRequested),
+    requestStop: (reason) => {
+      if (stopRequested)
+        return;
+      stopRequested = { reason };
+      journal?.appendTimeline({ type: "stop-requested", stage: "stopped", status: "running", detail: reason ?? "operator requested stop" });
+      if (deps.isIdle?.()) {
+        finishStopped();
+      } else {
+        deps.interrupt?.();
+      }
+    },
+    finishStopped
+  };
+}
+function createRunProcessStopHandlers(runId, stopController) {
+  const detectStopText = (text) => {
+    const stop = parseStopSentinel(text, runId);
+    if (stop)
+      stopController.requestStop(stop.reason);
+  };
+  return {
+    beforeAgentStart: (event) => detectStopText(event.prompt),
+    messageStart: (event) => detectStopText(messageText(event.message))
+  };
+}
+function createRunProcessSteerDriver(api, journal, timeoutMs = RUN_PROCESS_STEER_TIMEOUT_MS) {
+  let pendingSteer = null;
+  const resolvePending = (reason) => {
+    const pending = pendingSteer;
+    if (!pending)
+      return false;
+    pendingSteer = null;
+    clearTimeout(pending.timer);
+    if (reason === "timeout")
+      journal?.appendTimeline({ type: "closeout-steer-timeout", timeoutMs });
+    pending.resolve();
+    return true;
+  };
+  return {
+    steerPi: async (message) => {
+      if (pendingSteer)
+        throw new Error("A run closeout steer turn is already pending.");
+      await new Promise((resolve2, reject) => {
+        const timer = setTimeout(() => {
+          resolvePending("timeout");
+        }, timeoutMs);
+        pendingSteer = { resolve: resolve2, timer };
+        try {
+          journal?.appendTimeline({ type: "closeout-steer", message });
+          api.sendUserMessage(message, { deliverAs: "steer" });
+        } catch (error) {
+          pendingSteer = null;
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+    },
+    resolvePendingSteerOnAgentEnd: () => resolvePending("agent_end")
+  };
+}
+function messageText(value) {
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value))
+    return value.map(messageText).join(`
+`);
+  if (!isRecord(value))
+    return "";
+  if (typeof value.text === "string")
+    return value.text;
+  if (typeof value.content === "string")
+    return value.content;
+  return messageText(value.content);
+}
+function readOperatorSteerTexts(sessionFile) {
+  let raw;
+  try {
+    raw = readFileSync(sessionFile, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object" || !("customType" in parsed) || parsed.customType !== RIG_RUN_STEERING)
+      continue;
+    const data = "data" in parsed && parsed.data && typeof parsed.data === "object" ? parsed.data : null;
+    if (!data)
+      continue;
+    const actor = "actor" in data && data.actor && typeof data.actor === "object" ? data.actor : null;
+    const actorKind = actor && "kind" in actor && typeof actor.kind === "string" ? actor.kind : null;
+    if (actorKind !== "operator")
+      continue;
+    const text = "text" in data && typeof data.text === "string" ? data.text : null;
+    if (text)
+      out.push(text);
+  }
+  return out;
+}
+async function applyOperatorSteers(opts) {
+  const steers = readOperatorSteerTexts(opts.sessionFile);
+  for (let index = opts.appliedCount;index < steers.length; index += 1) {
+    const stop = parseStopSentinel(steers[index], opts.runId);
+    if (!stop)
+      continue;
+    try {
+      opts.requestStop(stop.reason);
+    } catch (error) {
+      console.warn(`[rig-run] stop apply failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  let applied = opts.appliedCount;
+  while (applied < steers.length) {
+    const text = steers[applied];
+    applied += 1;
+    if (parseStopSentinel(text, opts.runId))
+      continue;
+    try {
+      await opts.steerPi(text);
+    } catch (error) {
+      console.warn(`[rig-run] steer apply failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return applied;
+}
+function startOperatorSteerConsumer(opts) {
+  let applied = readOperatorSteerTexts(opts.sessionFile).length;
+  const apply = async () => {
+    applied = await applyOperatorSteers({
+      sessionFile: opts.sessionFile,
+      runId: opts.runId,
+      appliedCount: applied,
+      requestStop: opts.requestStop,
+      steerPi: opts.steerPi
+    });
+  };
+  Effect.runFork(Stream.runForEach(localRunChanges(opts.projectRoot).pipe(Stream.debounce(Duration.millis(500))), () => Effect.promise(apply)));
+}
+async function dispatchRunNotifications(projectRoot, runId, taskId2, outcome, detail) {
+  try {
+    const config = await loadNotificationConfig(resolve(projectRoot, ".rig", "notifications.json"));
+    if (config.targets.length === 0)
+      return;
+    const event = { runId, type: `run.${outcome}`, timestamp: new Date().toISOString(), payload: { taskId: taskId2, detail } };
+    await Promise.race([
+      dispatchEventToTargets(event, config.targets),
+      new Promise((resolveCap) => setTimeout(resolveCap, 5000))
+    ]);
+  } catch {}
+}
+async function maybeStartRunProcessAutohost(api, ctx) {
+  if (process.env.RIG_RUN_PROCESS !== "1")
+    return false;
+  const envRunId = process.env.RIG_RUN_ID?.trim();
+  if (!envRunId)
+    throw new Error("RIG_RUN_ID is required when RIG_RUN_PROCESS=1");
+  const runId = sessionIdFromSessionFile(ctx.sessionManager.getSessionFile()) ?? envRunId;
+  console.log(`[rig-run] session_start hasUI=${ctx.hasUI ? "true" : "false"}`);
+  if (!ctx.hasUI)
+    return true;
+  const collab = ctx.collab;
+  const startHost = collab?.startCollabHost ?? collab?.startHost;
+  if (!startHost)
+    throw new Error("OMP collab host facade is unavailable for Rig run process.");
+  const identity = resolveRigIdentity(ctx);
+  const journal = await createRunJournal(ctx.sessionManager, runId);
+  const projectRoot = process.env.PROJECT_RIG_ROOT ?? process.cwd();
+  let runProjection = projectRunFromSession(customEntries2(ctx.sessionManager.getBranch()), runId);
+  const taskIdAtStart = process.env.RIG_TASK_ID?.trim() || runProjection.record.taskId;
+  const runDisplayTitle = (() => {
+    const base = process.env.RIG_RUN_TITLE?.trim() || `Rig run ${runId}`;
+    return taskIdAtStart && !base.includes(taskIdAtStart) ? `[${taskIdAtStart}] ${base}` : base;
+  })();
+  const stopHost = collab?.stopHost?.bind(collab);
+  let closeoutStarted = false;
+  let forcedSteerUsed = false;
+  let lastRunActivityAt = Date.now();
+  const markRunActivity = () => {
+    lastRunActivityAt = Date.now();
+  };
+  let runRegistryHeartbeat = null;
+  let runRegistryRoomId = null;
+  const runRegistryNamespace = identity?.owner?.namespaceKey ?? resolveOwnerNamespaceKey(rigProjectRoot()) ?? null;
+  const runRegistrySecret = registrySecret();
+  const runRegistry = runRegistryNamespace && runRegistrySecret ? createRegistryClient({ baseUrl: registryBaseUrl(), namespaceKey: runRegistryNamespace, secret: runRegistrySecret }) : null;
+  const stopRunRegistry = () => {
+    if (runRegistryHeartbeat) {
+      clearInterval(runRegistryHeartbeat);
+      runRegistryHeartbeat = null;
+    }
+    if (runRegistry && runRegistryRoomId) {
+      runRegistry.removeRoom(runRegistryRoomId).catch(() => {});
+    }
+  };
+  const stopController = createRunProcessStopController(journal, stopHost, undefined, {
+    interrupt: () => ctx.abort(),
+    isIdle: () => ctx.isIdle()
+  });
+  const stopHandlers = createRunProcessStopHandlers(runId, stopController);
+  const stopRunStallMonitor = startRunProcessStallMonitor({
+    journal,
+    lastActivityAt: () => lastRunActivityAt,
+    alreadyStalled: runProjection.stallCount > 0
+  });
+  const startRunCollabHost = async () => {
+    try {
+      const projection = await startHost.call(collab, {
+        title: runDisplayTitle,
+        ...identity?.owner ? { owner: identity.owner } : {},
+        ...identity?.selectedRepo ? { selectedRepo: identity.selectedRepo } : {},
+        relayUrl: rigRelayUrl()
+      });
+      const timeline = {
+        type: "collab-host-started",
+        roomId: projection.sessionId,
+        joinLink: projection.joinLink,
+        webLink: projection.webLink,
+        relayUrl: projection.relayUrl
+      };
+      journal?.appendTimeline(timeline);
+      console.log(`[rig-run] collab-host-started joinLink=${projection.joinLink || "(empty)"} relayUrl=${projection.relayUrl || "(empty)"}`);
+      ctx.ui.notify("Rig run collab host started.", "info");
+      if (runRegistry && identity?.owner) {
+        try {
+          runRegistryRoomId = projection.sessionId;
+          await runRegistry.registerRoom({
+            roomId: projection.sessionId,
+            owner: identity.owner,
+            repo: identity.selectedRepo ?? "",
+            title: runDisplayTitle,
+            status: "running",
+            joinLink: projection.joinLink ?? "",
+            webLink: projection.webLink ?? "",
+            relayUrl: projection.relayUrl ?? rigRelayUrl(),
+            startedAt: new Date().toISOString(),
+            pid: process.pid
+          });
+          journal?.appendTimeline({ type: "registry-registered", roomId: projection.sessionId });
+          console.log(`[rig-run] registry-registered roomId=${projection.sessionId}`);
+          runRegistryHeartbeat = setInterval(() => {
+            runRegistry.heartbeatRoom(projection.sessionId, "running").catch((err) => console.error(`[rig-run] registry-heartbeat-failed ${err instanceof Error ? err.message : String(err)}`));
+          }, 15000);
+          if (typeof runRegistryHeartbeat.unref === "function")
+            runRegistryHeartbeat.unref();
+        } catch (error) {
+          console.error(`[rig-run] registry-register-failed ${error instanceof Error ? error.message : String(error)}`);
+          ctx.ui.notify("Rig run could not register to the discovery registry; it may not appear in Runs.", "warning");
+        }
+      } else {
+        console.error(`[rig-run] registry-skip namespace=${runRegistryNamespace ? "set" : "MISSING"} secret=${runRegistrySecret ? "set" : "MISSING"}`);
+        ctx.ui.notify("Rig run NOT registered (registry namespace/secret missing) \u2014 it won't appear in Runs.", "warning");
+      }
+    } catch (error) {
+      console.error(`[rig-run] collab-host-start-failed ${error instanceof Error ? error.message : String(error)}`);
+      ctx.ui.notify("Rig run collab host could not reach the relay; session remains local.", "warning");
+    }
+  };
+  journal?.appendTimeline({ type: "stage", stage: "Connect", status: "running", detail: "run process session_start" });
+  journal?.appendTimeline({ type: "stage", stage: "Prepare", status: "completed", detail: "run process prepared" });
+  journal?.appendStatus("running", { actor: { kind: "agent" }, reason: "run process session started", force: true });
+  await startRunCollabHost();
+  if (taskIdAtStart) {
+    journal?.appendTimeline({ type: "stage", stage: "GitHub-sync", status: "running", detail: "reflecting rig:running to task source" });
+    try {
+      await updateRunTaskSourceLifecycle(projectRoot, {
+        runId,
+        taskId: taskIdAtStart,
+        sourceTask: runProjection.record.sourceTask,
+        worktreePath: process.cwd(),
+        logRoot: runProjection.record.logRoot ?? null,
+        sessionPath: runProjection.record.sessionPath ?? null
+      }, "running", "Rig started work on this task.");
+      journal?.appendTimeline({ type: "stage", stage: "GitHub-sync", status: "completed", detail: "reflected running" });
+    } catch (error) {
+      journal?.appendTimeline({ type: "stage", stage: "GitHub-sync", status: "failed", detail: error instanceof Error ? error.message : String(error) });
+      console.error(`[rig-run] running-reflection-failed ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const steerDriver = createRunProcessSteerDriver(api, journal);
+  const operatorSteerSessionFile = ctx.sessionManager.getSessionFile();
+  if (operatorSteerSessionFile) {
+    startOperatorSteerConsumer({
+      runId,
+      projectRoot,
+      sessionFile: operatorSteerSessionFile,
+      requestStop: (reason) => stopController.requestStop(reason),
+      steerPi: steerDriver.steerPi
+    });
+  }
+  api.on("before_agent_start", (event) => {
+    markRunActivity();
+    stopHandlers.beforeAgentStart(event);
+  });
+  api.on("message_start", (event) => {
+    markRunActivity();
+    stopHandlers.messageStart(event);
+  });
+  if (process.env.RIG_RUN_FORCE_STOP_ONCE === "1" || process.env.RIG_RUN_FORCE_STOP === "1")
+    stopController.requestStop("force stop hook");
+  api.on("agent_end", async () => {
+    markRunActivity();
+    if (stopController.isStopRequested()) {
+      stopRunStallMonitor();
+      stopRunRegistry();
+      await stopController.finishStopped();
+      return;
+    }
+    if (steerDriver.resolvePendingSteerOnAgentEnd())
+      return;
+    if (closeoutStarted)
+      return;
+    stopRunRegistry();
+    if (process.env.RIG_RUN_FORCE_STEER_ONCE === "1" && !forcedSteerUsed) {
+      forcedSteerUsed = true;
+      journal?.appendTimeline({ type: "force-steer-once-started" });
+      await steerDriver.steerPi("now reply with the word FIXED");
+      journal?.appendTimeline({ type: "force-steer-once-completed" });
+    }
+    closeoutStarted = true;
+    runProjection = projectRunFromSession(customEntries2(ctx.sessionManager.getBranch()), runId);
+    const taskId2 = process.env.RIG_TASK_ID?.trim() || runProjection.record.taskId;
+    if (!taskId2) {
+      journal?.appendTimeline({ type: "closeout-skipped", reason: "missing-task-id" });
+      return;
+    }
+    const { command, gitCommand } = createEnvCloseoutRunners(process.env);
+    try {
+      await runInProcessCloseout({
+        projectRoot,
+        runId,
+        taskId: taskId2,
+        branch: runProjection.record.branch ?? `rig/${taskId2}-${runId}`,
+        workspace: process.cwd(),
+        artifactRoot: runProjection.record.artifactRoot ?? null,
+        sourceTask: runProjection.record.sourceTask && typeof runProjection.record.sourceTask === "object" && !Array.isArray(runProjection.record.sourceTask) ? runProjection.record.sourceTask : null,
+        command,
+        gitCommand,
+        steerPi: steerDriver.steerPi,
+        journalPhase: (phase, outcome, detail) => journal?.appendCloseoutPhase({ phase, outcome, detail: detail ?? null }),
+        reflect: async (status, summary, opts) => {
+          await updateRunTaskSourceLifecycle(projectRoot, {
+            runId,
+            taskId: taskId2,
+            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 dispatchRunNotifications(projectRoot, runId, taskId2, "completed", "closeout completed");
+      stopRunStallMonitor();
+      process.exitCode = 0;
+      setTimeout(() => process.exit(0), 0);
+    } catch (error) {
+      journal?.appendStatus("failed", { actor: { kind: "agent" }, errorText: error instanceof Error ? error.message : String(error), force: true });
+      await dispatchRunNotifications(projectRoot, runId, taskId2, "failed", error instanceof Error ? error.message : String(error));
+      stopRunStallMonitor();
+      process.exitCode = 1;
+      setTimeout(() => process.exit(1), 0);
+    }
+  });
+  return true;
+}
+async function maybeStartSpikeAutohost(ctx) {
+  if (process.env.RIG_SPIKE_AUTOHOST !== "1")
+    return;
+  const relayUrl = process.env.RIG_SPIKE_RELAY?.trim();
+  if (!relayUrl)
+    throw new Error("RIG_SPIKE_RELAY is required when RIG_SPIKE_AUTOHOST=1");
+  const collab = ctx.collab;
+  const startHost = collab?.startHost ?? collab?.startCollabHost;
+  if (!startHost)
+    throw new Error("OMP collab host facade is unavailable for detached PTY spike.");
+  const identity = resolveRigIdentity(ctx);
+  await startHost.call(collab, {
+    relayUrl,
+    title: "Rig detached PTY spike",
+    ...identity?.owner ? { owner: identity.owner } : {},
+    ...identity?.selectedRepo ? { selectedRepo: identity.selectedRepo } : {}
+  });
+}
+async function startCockpitOrSetup(api, ctx, injectedBridge) {
+  const actions = defaultFlowActions(api, ctx, injectedBridge);
+  const status = await detectRigStartupStatus(ctx);
+  if (status.configured) {
+    launchRigFlow(api, ctx, "runs", actions, true, injectedBridge, true);
+    return;
+  }
+  if (!hasInteractiveSetupTerminal(ctx)) {
+    ctx.ui.notify(`Rig Setup needed: ${status.reasons.join("; ")}`, "warning");
+    launchRigFlow(api, ctx, "setup", actions, true, injectedBridge, true);
+    return;
+  }
+  try {
+    await runRigSetupFlow(api, ctx, injectedBridge);
+    launchRigFlow(api, ctx, "runs", actions, true, injectedBridge, true);
+  } catch (error) {
+    ctx.ui.notify(notificationMessage(error), "error");
+    launchRigFlow(api, ctx, "setup", actions, true, injectedBridge, true);
+  }
+}
+var __rigExtensionTest = {
+  itemsFor,
+  defaultFlowActions,
+  commandFlowActions,
+  loadRigFlowState,
+  createRunProcessSteerDriver,
+  createRunProcessStopController,
+  createRunProcessStopHandlers,
+  detectRigStartupStatus,
+  applyRigSetupProject,
+  ensureGitHubLabels,
+  ensurePiRigInstalledForSetup,
+  parseRepoSlugFromRemote,
+  stopSentinel,
+  parseStopSentinel,
+  applyOperatorSteers,
+  readOperatorSteerTexts,
+  computeRunStall,
+  appendRunStallDetected,
+  buildStopSentinel
+};
+function rigExtension(api, options = {}) {
+  const injectedBridge = options.selectedServerBridge ?? null;
+  api.registerMessageRenderer(RIG_WORKFLOW_STARTED, () => {
+    return;
+  });
+  api.registerMessageRenderer(RIG_WORKFLOW_TARGET_SELECTED, () => {
+    return;
+  });
+  api.registerMessageRenderer(RIG_WORKFLOW_TASK_SELECTED, () => {
+    return;
+  });
+  api.registerMessageRenderer(RIG_WORKFLOW_STATUS_CHANGED, () => {
+    return;
+  });
+  api.registerMessageRenderer(RIG_WORKFLOW_OPERATOR_NOTE, () => {
+    return;
+  });
+  api.registerMessageRenderer(RIG_WORKFLOW_INBOX_REQUESTED, () => {
+    return;
+  });
+  api.registerMessageRenderer(RIG_WORKFLOW_INBOX_RESOLVED, () => {
+    return;
+  });
+  registerWorkflowInboxTool(api);
+  api.on("session_start", async (_event, ctx) => {
+    const isRunProcess = await maybeStartRunProcessAutohost(api, ctx);
+    if (isRunProcess)
+      return;
+    if (!ctx.hasUI)
+      return;
+    ctx.ui.setTitle("RIG");
+    await maybeStartSpikeAutohost(ctx);
+    await startCockpitOrSetup(api, ctx, injectedBridge);
+  });
+  api.registerShortcut("g", {
+    description: "Rig cockpit",
+    handler: async (ctx) => {
+      launchRigFlow(api, ctx, "cockpit", defaultFlowActions(api, ctx, injectedBridge), true, injectedBridge);
+    }
+  });
+  api.registerShortcut("r", {
+    description: "Rig runs",
+    handler: async (ctx) => {
+      launchRigFlow(api, ctx, "runs", defaultFlowActions(api, ctx, injectedBridge), true, injectedBridge);
+    }
+  });
+  api.registerShortcut("s", {
+    description: "Rig server target",
+    handler: async (ctx) => {
+      launchRigFlow(api, ctx, "server", defaultFlowActions(api, ctx, injectedBridge), true, injectedBridge);
+    }
+  });
+  api.registerShortcut("i", {
+    description: "Rig inbox",
+    handler: async (ctx) => {
+      launchRigFlow(api, ctx, "inbox", defaultFlowActions(api, ctx, injectedBridge), true, injectedBridge);
+    }
+  });
+  api.registerShortcut("d", {
+    description: "Rig doctor",
+    handler: async (ctx) => {
+      launchRigFlow(api, ctx, "doctor", defaultFlowActions(api, ctx, injectedBridge), true, injectedBridge);
+    }
+  });
+  api.registerShortcut("n", {
+    description: "Rig new run (tasks)",
+    handler: async (ctx) => {
+      launchRigFlow(api, ctx, "tasks", defaultFlowActions(api, ctx, injectedBridge), true, injectedBridge);
+    }
+  });
+  api.registerCommand("rig", {
+    description: "Open the Rig operator flow",
+    handler: async (args, ctx) => {
+      const requested = args.trim();
+      const actions = commandFlowActions(api, ctx, injectedBridge);
+      if (requested.startsWith("action ")) {
+        await actions.act(requested.slice("action ".length).trim());
+        return;
+      }
+      if (requested.startsWith("run ")) {
+        await actions.act(`run:${requested.slice("run ".length).trim()}`);
+        return;
+      }
+      const lower = requested.toLowerCase();
+      const screen = isRigScreen(lower) ? lower : "cockpit";
+      launchRigFlow(api, ctx, screen, actions, true, injectedBridge);
+    }
+  });
+}
+export {
+  rigExtension as default,
+  __rigExtensionTest
+};