@h-rig/omp-extension-plugin 0.0.6-alpha.186

package/dist/src/cockpit/plugin.js

@@ -0,0 +1,2277 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/omp-extension-plugin/src/cockpit/board-views.ts
+import { truncateToWidth } from "@oh-my-pi/pi-tui";
+import {
+  accent,
+  accentDim,
+  bold,
+  cyan,
+  ink,
+  ink2,
+  ink3,
+  ink4,
+  red,
+  DRONE_WIDTH,
+  renderDroneFrame,
+  renderMicroDroneFrame,
+  RIG_SPINNER_FRAMES,
+  screenGlyph,
+  sectionDivider,
+  statusColor,
+  statusGlyph,
+  statusPill,
+  wrapText,
+  yellow
+} from "@rig/std-shared/board-theme";
+function hairline(width) {
+  return ink4("\u2500".repeat(Math.max(0, width)));
+}
+
+class BoardSettingsList {
+  items = [];
+  selected = 0;
+  title = "";
+  emptyMessage = "nothing to show";
+  setItems(items) {
+    this.items = [...items];
+    if (!this.selectableAt(this.selected))
+      this.selected = this.firstSelectable();
+  }
+  setTitle(title) {
+    this.title = title;
+  }
+  selectableAt(index) {
+    const item = this.items[index];
+    return !!item && item.heading !== true;
+  }
+  firstSelectable() {
+    const i = this.items.findIndex((_, idx) => this.selectableAt(idx));
+    return i >= 0 ? i : 0;
+  }
+  moveSelection(delta) {
+    if (this.items.length === 0)
+      return;
+    const step = delta < 0 ? -1 : 1;
+    for (let i = this.selected + step;i >= 0 && i < this.items.length; i += step) {
+      if (this.selectableAt(i)) {
+        this.selected = i;
+        return;
+      }
+    }
+  }
+  selectedItem() {
+    return this.selectableAt(this.selected) ? 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.items.length === 0) {
+      return ["", ` ${ink2(this.emptyMessage)}`, ""];
+    }
+    const maxVisible = Math.max(8, Math.min(16, (process.stdout.rows ?? 30) - 10));
+    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 valueWidth = Math.min(24, Math.max(10, Math.floor(width * 0.24)));
+    const labelWidth = Math.min(24, Math.max(10, Math.floor(width * 0.26)));
+    const lines = window.flatMap((item, index) => {
+      const absolute = start + index;
+      const isSelected = absolute === this.selected;
+      const marker = isSelected ? accent("\u258C") : " ";
+      const navGlyph = item.id.startsWith("to:") ? `${screenGlyph(item.id.slice(3))} ` : "";
+      const labelText = truncateToWidth(`${navGlyph}${item.label}`, labelWidth).padEnd(labelWidth);
+      const isTitle = item.id === "title";
+      const isStatus = item.id.endsWith(":status");
+      const label = isTitle ? accent(labelText) : isSelected ? ink(labelText) : item.heading ? ink3(labelText) : ink2(labelText);
+      const value = !item.currentValue ? ink4("".padEnd(valueWidth)) : isStatus ? statusColor(item.currentValue)(truncateToWidth(`${statusGlyph(item.currentValue)} ${item.currentValue}`, valueWidth).padEnd(valueWidth)) : item.heading ? ink2(truncateToWidth(item.currentValue, valueWidth).padEnd(valueWidth)) : ink3(truncateToWidth(item.currentValue, valueWidth).padEnd(valueWidth));
+      const action = item.values?.[0] && item.values[0] !== item.currentValue ? isSelected ? accent(item.values[0]) : accentDim(item.values[0]) : "";
+      const row = `${marker} ${label} ${value}${action ? ` ${action}` : ""}`;
+      if (isSelected && item.description) {
+        return [row, `   ${ink4(truncateToWidth(item.description, Math.max(12, width - 5)))}`];
+      }
+      return [row];
+    });
+    const meta = [];
+    if (this.items.length > maxVisible)
+      meta.push(`${this.selected + 1}/${this.items.length}`);
+    if (this.title)
+      meta.push(this.title);
+    if (meta.length > 0)
+      lines.push(ink4(`   ${meta.join("  \xB7  ")}`));
+    return ["", ...lines, ""];
+  }
+}
+
+class HelpView {
+  catalog;
+  group;
+  offset = 0;
+  #built = null;
+  constructor(catalog, group) {
+    this.catalog = catalog;
+    this.group = group;
+  }
+  #build(width) {
+    if (this.#built)
+      return this.#built;
+    const { sections, groups } = this.catalog;
+    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)`) : ""
+    ];
+  }
+}
+
+class DetailComposer {
+  model = EMPTY_DETAIL;
+  selected = 0;
+  tick = 0;
+  bodyScroll = 0;
+  setModel(model) {
+    const prevId = this.enabledActions()[this.selected]?.id;
+    this.model = model;
+    const actions = this.enabledActions();
+    const idx = prevId ? actions.findIndex((action) => action.id === prevId) : -1;
+    this.selected = idx >= 0 ? idx : 0;
+    this.clamp();
+  }
+  enabledActions() {
+    return this.model.actions.filter((action) => action.enabled !== false);
+  }
+  clamp() {
+    const count = this.enabledActions().length;
+    this.selected = count === 0 ? 0 : Math.max(0, Math.min(this.selected, count - 1));
+  }
+  moveSelection(delta) {
+    const count = this.enabledActions().length;
+    if (count === 0)
+      return;
+    this.selected = Math.max(0, Math.min(count - 1, this.selected + delta));
+  }
+  selectedAction() {
+    return this.enabledActions()[this.selected] ?? null;
+  }
+  scrollBody(delta) {
+    this.bodyScroll = Math.max(0, this.bodyScroll + delta);
+  }
+  resetScroll() {
+    this.bodyScroll = 0;
+  }
+  invalidate() {}
+  render(width) {
+    const model = this.model;
+    const inner = Math.max(12, width - 2);
+    const budget = Math.max(8, (process.stdout.rows ?? 40) - 5);
+    const top = [""];
+    top.push(` ${accent(model.icon)}  ${accent(model.ref)}${model.status ? `   ${statusPill(model.status)}` : ""}`);
+    for (const line of wrapText(model.title, inner - 1))
+      top.push(` ${ink(line)}`);
+    top.push("");
+    const bottom = [];
+    if (model.facts.length > 0) {
+      bottom.push(sectionDivider("details", width));
+      const labelWidth = Math.min(16, Math.max(...model.facts.map((fact) => fact.label.length)) + 1);
+      for (const fact of model.facts) {
+        const label = ink3(fact.label.toUpperCase().padEnd(labelWidth));
+        const value = fact.status ? statusColor(fact.status)(`${statusGlyph(fact.status)} ${fact.value}`) : fact.tone === "link" ? cyan(truncateToWidth(fact.value, inner - labelWidth - 3)) : fact.tone === "warn" ? yellow(fact.value) : ink2(truncateToWidth(fact.value, inner - labelWidth - 3));
+        bottom.push(`  ${label} ${value}`);
+      }
+      bottom.push("");
+    }
+    if (model.stages && model.stages.length > 0) {
+      bottom.push(sectionDivider("pipeline", width));
+      const parts = model.stages.map((stage) => `${statusColor(stage.status)(statusGlyph(stage.status))} ${ink3(stage.label)}`);
+      bottom.push(truncateToWidth(`  ${parts.join(ink4(" \u2192 "))}`, inner));
+      bottom.push("");
+    }
+    if (model.actions.length > 0) {
+      bottom.push(sectionDivider("actions", width));
+      const selId = this.selectedAction()?.id;
+      for (const action of model.actions) {
+        const on = action.enabled !== false;
+        const isSel = on && action.id === selId;
+        const rail = isSel ? accent("\u258C") : " ";
+        const labelText = `${action.glyph ? `${action.glyph} ` : ""}${action.label}`;
+        const label = !on ? ink4(labelText) : action.danger ? red(labelText) : isSel ? accent(labelText) : ink2(labelText);
+        const tail = !on ? ink4(action.value ?? "unavailable") : isSel ? ink3(action.hint ?? action.value ?? "") : ink3(action.value ?? "");
+        bottom.push(`${rail} ${label}${tail ? `  ${tail}` : ""}`);
+      }
+    }
+    const body = [];
+    if (model.body && model.body.trim()) {
+      const bodyCap = budget - top.length - bottom.length;
+      if (bodyCap >= 3) {
+        const bodyLines = wrapText(model.body, inner - 3);
+        const contentCap = bodyCap - 2;
+        const needScroll = bodyLines.length > contentCap;
+        const shownCount = needScroll ? Math.max(1, contentCap - 1) : bodyLines.length;
+        const maxScroll = Math.max(0, bodyLines.length - shownCount);
+        const scroll = Math.min(this.bodyScroll, maxScroll);
+        body.push(sectionDivider(model.bodyLabel ?? "body", width));
+        for (const line of bodyLines.slice(scroll, scroll + shownCount))
+          body.push(` ${ink4("\u2502")} ${ink2(line)}`);
+        if (needScroll) {
+          const up = scroll > 0 ? "\u2191 " : "";
+          const down = scroll < maxScroll ? `\u2193 ${maxScroll - scroll} more` : "";
+          body.push(` ${ink4("\u2502")} ${accentDim(`${up}${down}`.trim())}`);
+        }
+        body.push("");
+      }
+    }
+    const out = [...top, ...body, ...bottom];
+    if (out.length > budget) {
+      const keepTail = Math.min(bottom.length, budget - top.length);
+      return [...top, ...out.slice(out.length - keepTail)].map((line) => truncateToWidth(line, Math.max(10, width - 1)));
+    }
+    return out.map((line) => truncateToWidth(line, Math.max(10, width - 1)));
+  }
+}
+var EMPTY_DETAIL;
+var init_board_views = __esm(() => {
+  EMPTY_DETAIL = { screen: "task-detail", icon: "", ref: "", title: "", facts: [], actions: [] };
+});
+
+// packages/omp-extension-plugin/src/cockpit/drone-preloader.ts
+function classOf(ch) {
+  if (ch === "$" || ch === "@")
+    return "d";
+  if (ch === "=" || ch === "%")
+    return "m";
+  if (ch === "\\" || ch === "/")
+    return "r";
+  if (ch === "(" || ch === ")" || ch === "-" || ch === "|" || ch === "'" || ch === ".")
+    return "c";
+  return "b";
+}
+function colorFor(key) {
+  switch (key) {
+    case "d":
+      return bolden(COL.d);
+    case "m":
+      return COL.m;
+    case "c":
+      return COL.c;
+    case "r":
+      return COL.r;
+    case "rb":
+      return bolden(COL.rb);
+    case "eye":
+      return bolden(COL.eye);
+    default:
+      return (text) => text;
+  }
+}
+function composeGrid(t) {
+  const phase = Math.floor(t / 4);
+  const blade = BL[phase % 4];
+  const p = Math.sin(t * 0.07);
+  const core = p > 0.45 ? "@" : p > -0.1 ? "o" : ".";
+  const grid = Array.from({ length: GH }, () => Array.from({ length: GW }, () => " "));
+  for (const d of FLEET) {
+    const oy = d.y + Math.round(d.amp * Math.sin(t * d.sp + d.ph));
+    const ox = d.x + Math.round(d.dx * Math.sin(t * d.dsp + d.ph));
+    for (let i = 0;i < d.s.length; i++) {
+      const ln = d.s[i];
+      const ry = oy + i;
+      if (ry < 0 || ry >= GH)
+        continue;
+      for (let j = 0;j < ln.length; j++) {
+        const ch = ln[j];
+        if (ch === " ")
+          continue;
+        const rx = ox + j;
+        if (rx < 0 || rx >= GW)
+          continue;
+        grid[ry][rx] = ch;
+      }
+    }
+  }
+  const eyes = [];
+  const rows = grid.map((row, r) => {
+    const line = row.join("");
+    const cells = new Array(GW);
+    let k = 0;
+    while (k < GW) {
+      if (line.substr(k, 3) === "!!!") {
+        cells[k] = { ch: blade[0], key: "rb" };
+        cells[k + 1] = { ch: blade[1], key: "rb" };
+        cells[k + 2] = { ch: blade[2], key: "rb" };
+        k += 3;
+      } else if (line[k] === "?") {
+        eyes.push([r, k]);
+        cells[k] = { ch: core, key: "eye" };
+        k += 1;
+      } else {
+        cells[k] = { ch: line[k], key: classOf(line[k]) };
+        k += 1;
+      }
+    }
+    return cells;
+  });
+  return { rows, eyes };
+}
+function buildGlow(eyes) {
+  const glow = Array.from({ length: GH }, () => new Array(GW).fill(0));
+  for (const [er, ec] of eyes) {
+    for (let r = Math.max(0, er - GLOW_RADIUS);r <= Math.min(GH - 1, er + GLOW_RADIUS); r++) {
+      for (let c = Math.max(0, ec - GLOW_RADIUS);c <= Math.min(GW - 1, ec + GLOW_RADIUS); c++) {
+        const d2 = (r - er) * (r - er) + (c - ec) * (c - ec);
+        if (d2 > GLOW_RADIUS * GLOW_RADIUS)
+          continue;
+        const v = Math.exp(-d2 / GLOW_SIGMA2);
+        if (v > glow[r][c])
+          glow[r][c] = v;
+      }
+    }
+  }
+  return glow;
+}
+function bgLevel(intensity) {
+  return Math.round(Math.min(1, Math.max(0, intensity)) * GLOW_LEVELS);
+}
+function bgOpen(level) {
+  const f = level / GLOW_LEVELS * GLOW_MAX_BG;
+  return `\x1B[48;2;${Math.round(GLOW_RGB[0] * f)};${Math.round(GLOW_RGB[1] * f)};${Math.round(GLOW_RGB[2] * f)}m`;
+}
+function renderRow(cells, glowRow) {
+  const outs = [];
+  for (let c = 0;c < GW; c++) {
+    outs.push({ ch: cells[c].ch, key: cells[c].key, bg: bgLevel(glowRow[c]) });
+    if (GAP && c < GW - 1)
+      outs.push({ ch: GAP, key: "b", bg: bgLevel(Math.max(glowRow[c], glowRow[c + 1])) });
+  }
+  let out = "";
+  let i = 0;
+  while (i < outs.length) {
+    const { key, bg } = outs[i];
+    let chunk = "";
+    while (i < outs.length && outs[i].key === key && outs[i].bg === bg) {
+      chunk += outs[i].ch;
+      i += 1;
+    }
+    out += bg > 0 ? bgOpen(bg) + colorFor(key)(chunk) + BG_CLOSE : colorFor(key)(chunk);
+  }
+  return out;
+}
+function composeFleet(t) {
+  const { rows, eyes } = composeGrid(t);
+  const glow = buildGlow(eyes);
+  return rows.map((cells, r) => renderRow(cells, glow[r]));
+}
+
+class DronePreloaderComponent {
+  tui;
+  #start = Date.now();
+  #timer;
+  constructor(tui) {
+    this.tui = tui;
+    this.#timer = setInterval(() => this.tui.requestRender(), Math.round(RENDER_MS));
+  }
+  render(width) {
+    const t = Math.round((Date.now() - this.#start) * ANIM_HZ / 1000);
+    const sprite = composeFleet(t);
+    const left = Math.max(0, Math.floor((width - SPACED_WIDTH) / 2));
+    const indent = " ".repeat(left);
+    const rows = typeof process.stdout.rows === "number" && process.stdout.rows > 0 ? process.stdout.rows : 0;
+    const topPad = rows > sprite.length ? Math.max(0, Math.floor((rows - sprite.length) / 2)) : 0;
+    const lines = [];
+    for (let i = 0;i < topPad; i++)
+      lines.push("");
+    for (const row of sprite)
+      lines.push(indent + row);
+    return lines;
+  }
+  handleInput(_data) {}
+  invalidate() {}
+  dispose() {
+    if (this.#timer) {
+      clearInterval(this.#timer);
+      this.#timer = undefined;
+    }
+  }
+}
+var ART, MINI, BL, GW = 52, GH = 27, FLEET, fg = (r, g, b) => (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[39m`, COL, GAP = "", SPACED_WIDTH, bolden = (f) => (t) => `\x1B[1m${f(t)}\x1B[22m`, GLOW_RGB, GLOW_RADIUS = 2, GLOW_SIGMA2, GLOW_MAX_BG = 0.15, GLOW_LEVELS = 10, BG_CLOSE = "\x1B[49m", ANIM_HZ = 120, RENDER_MS;
+var init_drone_preloader = __esm(() => {
+  ART = [
+    "  .-=-.                   .-=-.   ",
+    " ( !!! )                 ( !!! )  ",
+    "  '-=-'._               _.'-=-'   ",
+    "        '._           _.'         ",
+    "           '=$$$$$$$=.'           ",
+    "          =$$$$$$$$$$$=           ",
+    "         $$$@@@@@@@@@@$$$         ",
+    "        $$$@@        @@$$$        ",
+    "        $$@    ?     @$$$         ",
+    "        $$$@   '-'   @$$$         ",
+    "        $$$@@        @@$$$        ",
+    "         $$$@@@@@@@@@@$$$         ",
+    "          =$$$$$$$$$$$=           ",
+    "           '=$$$$$$$=.'           ",
+    "        _.'           '._         ",
+    "  .-=-.'                 '.-=-.   ",
+    " ( !!! )                 ( !!! )  ",
+    "  '-=-'                   '-=-'   "
+  ];
+  MINI = [
+    "(!!!)   (!!!)",
+    "  \\%==%/  ",
+    "   %%?%%   ",
+    "  /%==%\\  ",
+    "(!!!)   (!!!)"
+  ];
+  BL = ["---", "\\\\\\", "|||", "///"];
+  FLEET = [
+    { s: MINI, x: 0, y: 2, amp: 1, sp: 0.05, ph: 0, dx: 1, dsp: 0.02 },
+    { s: MINI, x: 39, y: 2, amp: 1, sp: 0.044, ph: 2.1, dx: 1, dsp: 0.017 },
+    { s: MINI, x: 1, y: 20, amp: 1, sp: 0.048, ph: 4.2, dx: 1, dsp: 0.023 },
+    { s: MINI, x: 38, y: 20, amp: 1, sp: 0.041, ph: 1.3, dx: 1, dsp: 0.015 },
+    { s: ART, x: 10, y: 5, amp: 2, sp: 0.04, ph: 0, dx: 0, dsp: 0.011 }
+  ];
+  COL = {
+    d: fg(204, 255, 77),
+    m: fg(169, 214, 63),
+    c: fg(86, 216, 255),
+    r: fg(95, 107, 58),
+    rb: fg(125, 158, 52),
+    eye: fg(234, 255, 176)
+  };
+  SPACED_WIDTH = GW + GAP.length * (GW - 1);
+  GLOW_RGB = [204, 255, 77];
+  GLOW_SIGMA2 = 2 * 1.05 * 1.05;
+  RENDER_MS = 1000 / 60;
+});
+
+// packages/omp-extension-plugin/src/cockpit/screen-catalog.ts
+function buildScreenFromPanel(panel) {
+  const meta = panel.screen ?? {};
+  const id = panel.id;
+  return {
+    id,
+    title: meta.title || panel.title || id,
+    ...meta.label !== undefined ? { label: meta.label } : {},
+    ...meta.shortcutKey ? { shortcut: { key: meta.shortcutKey, description: meta.shortcutDescription ?? panel.title } } : {},
+    ...meta.navOrder !== undefined ? {
+      nav: {
+        order: meta.navOrder,
+        label: meta.navLabel ?? panel.title.toUpperCase(),
+        description: meta.navDescription ?? panel.description ?? ""
+      }
+    } : {},
+    ...panel.disabled !== undefined ? { disabled: panel.disabled } : {}
+  };
+}
+function resolveScreenCatalog(panels = []) {
+  const contributed = panels.filter((panel) => panel.slot === "cockpit" && panel.screen).map(buildScreenFromPanel);
+  const seen = new Set(DEFAULT_SCREEN_CATALOG.map((screen) => screen.id));
+  const merged = [...DEFAULT_SCREEN_CATALOG];
+  for (const screen of contributed) {
+    if (seen.has(screen.id))
+      continue;
+    seen.add(screen.id);
+    merged.push(screen);
+  }
+  return merged;
+}
+function findScreen(catalog, screen) {
+  return catalog.find((entry) => entry.id === screen);
+}
+function isRigScreen(value, catalog = DEFAULT_SCREEN_CATALOG) {
+  return typeof value === "string" && catalog.some((screen) => screen.id === value);
+}
+function screenTitle(screen, catalog = DEFAULT_SCREEN_CATALOG) {
+  return findScreen(catalog, screen)?.title ?? screen;
+}
+function screenLabel(screen, catalog = DEFAULT_SCREEN_CATALOG) {
+  const descriptor = findScreen(catalog, screen);
+  return descriptor?.label ?? descriptor?.id ?? screen;
+}
+function screenShortcuts(catalog = DEFAULT_SCREEN_CATALOG) {
+  return catalog.flatMap((entry) => entry.shortcut ? [{ screen: entry.id, shortcut: entry.shortcut }] : []);
+}
+function cockpitNavScreens(catalog = DEFAULT_SCREEN_CATALOG) {
+  return catalog.flatMap((entry) => entry.nav && !entry.disabled ? [{ screen: entry.id, nav: entry.nav }] : []).sort((left, right) => left.nav.order - right.nav.order);
+}
+var DEFAULT_SCREEN_CATALOG;
+var init_screen_catalog = __esm(() => {
+  DEFAULT_SCREEN_CATALOG = [
+    { id: "cockpit", title: "Project Cockpit", shortcut: { key: "g", description: "Rig cockpit" } },
+    { id: "task-detail", title: "Task Detail" },
+    { id: "run-detail", title: "Run Detail", label: "run detail" }
+  ];
+});
+
+// packages/omp-extension-plugin/src/cockpit/cockpit-product.ts
+import {
+  DISPATCH_OUTCOME_CAPABILITY_ID,
+  TASK_PROJECTION_CAPABILITY_ID
+} from "@rig/contracts";
+import { defineServiceCapability } from "@rig/core";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function resolveCockpitCapabilities(host) {
+  if (!host)
+    return defaultCockpitCapabilities;
+  const [taskProjection, dispatchOutcome] = await Promise.all([
+    TaskProjectionCapability.requireService(host),
+    DispatchOutcomeCapability.resolveService(host)
+  ]);
+  return {
+    taskProjection,
+    dispatchOutcome: dispatchOutcome ?? defaultCockpitCapabilities.dispatchOutcome
+  };
+}
+var unavailableTaskProjection, unavailableDispatchOutcome, defaultCockpitCapabilities, TaskProjectionCapability, DispatchOutcomeCapability;
+var init_cockpit_product = __esm(() => {
+  unavailableTaskProjection = {
+    normalizeStatus: () => "unknown",
+    normalizePriority: () => null,
+    project: (task) => ({
+      id: task.id,
+      title: "",
+      status: "unknown",
+      priority: null,
+      metadata: { projection: "unavailable" }
+    }),
+    assigneeText: () => "",
+    title: () => "",
+    id: () => null,
+    status: () => "unknown",
+    description: () => "",
+    listRows: () => [],
+    boardTasks: () => [],
+    stats: () => null
+  };
+  unavailableDispatchOutcome = {
+    humanize: () => null
+  };
+  defaultCockpitCapabilities = {
+    taskProjection: unavailableTaskProjection,
+    dispatchOutcome: unavailableDispatchOutcome
+  };
+  TaskProjectionCapability = defineServiceCapability(TASK_PROJECTION_CAPABILITY_ID);
+  DispatchOutcomeCapability = defineServiceCapability(DISPATCH_OUTCOME_CAPABILITY_ID);
+});
+
+// packages/omp-extension-plugin/src/cockpit/extension.ts
+var exports_extension = {};
+__export(exports_extension, {
+  default: () => rigExtension,
+  __rigExtensionTest: () => __rigExtensionTest
+});
+import { postmortem } from "@oh-my-pi/pi-utils";
+import {
+  HELP_CATALOG,
+  PLACEMENT_SERVICE,
+  RIG_WORKFLOW_JOURNAL_WRITER,
+  RIG_WORKFLOW_TASK_SELECTED,
+  RIG_WORKFLOW_TARGET_SELECTED,
+  RIG_WORKFLOW_STATUS_CHANGED,
+  RIG_WORKFLOW_STARTED,
+  RIG_WORKFLOW_OPERATOR_NOTE,
+  RUN_CONTROL,
+  RUN_IDENTITY_ENV,
+  RUN_READ_MODEL,
+  TASK_IO_SERVICE_CAPABILITY,
+  PROJECT_SETUP
+} from "@rig/contracts";
+import { RUN_DISPATCH, RUN_DISCOVERY } from "@rig/contracts";
+import { DOCTOR } from "@rig/contracts";
+import { RIG_COCKPIT_PANEL_SLOT } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { loadCapabilityForRoot, requireCapabilityForRoot } from "@rig/core/capability-loaders";
+import { isKeyRelease, matchesKey } from "@oh-my-pi/pi-tui";
+import { Duration, Effect, Fiber, Stream } from "effect";
+import { accent as accent2, accentDim as accentDim2, bold as bold2, cyan as cyan2, ink as ink5, ink2 as ink22, ink3 as ink32, ink4 as ink42, red as red2, RIG_SPINNER_FRAMES as RIG_SPINNER_FRAMES2, screenGlyph as screenGlyph2 } from "@rig/std-shared/board-theme";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+import { rigProjectRootFromEnv as rigProjectRoot } from "@rig/core/root-resolver";
+function isProjectedRunClassification(value) {
+  return Boolean(value && typeof value === "object" && "status" in value && "phase" in value && "rank" in value && "role" in value);
+}
+function runClassificationFor(run, source) {
+  if (isProjectedRunClassification(source))
+    return source;
+  return source?.runClassifications?.get(run.runId) ?? UNCLASSIFIED_RUN_CLASSIFICATION;
+}
+function runActionAffordanceFor(run, source) {
+  return isProjectedRunClassification(source) ? null : source?.runActionAffordances?.get(run.runId) ?? null;
+}
+function runStageRowsFor(run, source) {
+  return isProjectedRunClassification(source) ? [] : source?.runStageRows?.get(run.runId) ?? [];
+}
+function canSteer(run, source) {
+  const affordance = runActionAffordanceFor(run, source);
+  if (affordance)
+    return affordance.steer;
+  if (isProjectedRunClassification(source))
+    return false;
+  const classification = runClassificationFor(run, source);
+  return classification.phase === "active" || classification.phase === "starting";
+}
+function canStop(run, source) {
+  const affordance = runActionAffordanceFor(run, source);
+  if (affordance)
+    return affordance.stop;
+  if (isProjectedRunClassification(source))
+    return false;
+  const classification = runClassificationFor(run, source);
+  return classification.isActive && !classification.isTerminal;
+}
+function canPause(run, source) {
+  const affordance = runActionAffordanceFor(run, source);
+  if (affordance)
+    return affordance.pause;
+  if (isProjectedRunClassification(source))
+    return false;
+  const phase = runClassificationFor(run, source).phase;
+  return phase === "active" || phase === "starting";
+}
+function canResume(run, source) {
+  const affordance = runActionAffordanceFor(run, source);
+  if (affordance)
+    return affordance.resume;
+  if (isProjectedRunClassification(source))
+    return false;
+  return runClassificationFor(run, source).phase === "paused";
+}
+function workflowTargetForPlacement(placement) {
+  return placement?.kind === "remote" ? "remote" : "local";
+}
+async function loadRunIdentityEnv(projectRoot) {
+  return loadCapabilityForRoot(projectRoot, RunIdentityEnvCap);
+}
+async function loadWorkflowJournalWriter(projectRoot) {
+  return loadCapabilityForRoot(projectRoot, WorkflowJournalWriterCap);
+}
+async function identityFilterForContext(ctx) {
+  return (await loadRunIdentityEnv(projectRootFromContext(ctx)))?.resolveRigIdentityFilter(ctx) ?? {};
+}
+function projectRootFromContext(ctx) {
+  return ctx.cwd || ctx.sessionManager.getCwd?.() || process.cwd();
+}
+async function requireProjectSetupService(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, ProjectSetupCap, "Project setup capability unavailable: load @rig/init-plugin before running setup.");
+}
+function withPlacementDetail(target, projectRoot, service) {
+  const status = target.status ?? "ready";
+  return {
+    ...target,
+    projectRoot: target.projectRoot ?? projectRoot,
+    status,
+    taskSource: target.taskSource ?? "configured source",
+    detail: target.kind === "remote" ? target.baseUrl ?? target.host ?? "saved remote alias" : "this checkout",
+    dispatchReady: service.isDispatchReady({ status })
+  };
+}
+async function readCurrentPlacement(ctx) {
+  const projectRoot = projectRootFromContext(ctx);
+  const service = await loadPlacementService(projectRoot);
+  return withPlacementDetail(await service.readPlacement({ projectRoot }), projectRoot, service);
+}
+async function placementChoices(ctx) {
+  const projectRoot = projectRootFromContext(ctx);
+  const service = await loadPlacementService(projectRoot);
+  return [...await service.listPlacements({ projectRoot })].map((target) => withPlacementDetail(target, projectRoot, service));
+}
+async function promptForNewRemote(ctx) {
+  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", "22"))?.trim() || "22";
+  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;
+  const projectRoot = projectRootFromContext(ctx);
+  const service = await loadPlacementService(projectRoot);
+  return withPlacementDetail(await service.addPlacement({ projectRoot, placement: { alias, host, port, token, select: true } }), projectRoot, service);
+}
+async function chooseSetupPlacement(ctx) {
+  const targets = await placementChoices(ctx);
+  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 promptForNewRemote(ctx);
+    if (!target2)
+      throw new Error("Remote placement was not saved.");
+    return { alias: target2.alias, kind: target2.kind, ...target2.host ? { host: target2.host } : {}, ...target2.port ? { port: target2.port } : {} };
+  }
+  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, ...target.host ? { host: target.host } : {}, ...target.port ? { port: target.port } : {} };
+}
+function setupPlacementFromTarget(target) {
+  return {
+    alias: target.alias,
+    kind: target.kind,
+    ...target.host ? { host: target.host } : {},
+    ...target.port ? { port: target.port } : {}
+  };
+}
+async function chooseAutomaticSetupPlacement(ctx) {
+  const current = await readCurrentPlacement(ctx).catch(() => null);
+  if (current)
+    return setupPlacementFromTarget(current);
+  const targets = await placementChoices(ctx);
+  const remote = targets.find((target) => target.kind === "remote");
+  const fallback = remote ?? targets[0] ?? { alias: "local", kind: "local" };
+  return setupPlacementFromTarget(fallback);
+}
+function hasInteractiveSetupTerminal(ctx) {
+  return Boolean(ctx.hasUI && process.stdin.isTTY && process.stdout.isTTY);
+}
+async function detectRigStartupStatus(ctx) {
+  const projectRoot = projectRootFromContext(ctx);
+  const setup = await requireProjectSetupService(projectRoot);
+  return setup.detectStartupStatus({ projectRoot });
+}
+async function promptSetupAuth(ctx, status) {
+  const choices = [
+    ...status.auth.ok ? ["Use current GitHub auth"] : [],
+    "Import token from gh",
+    "Paste token"
+  ];
+  const choice = await ctx.ui.select("GitHub auth", choices);
+  if (!choice)
+    throw new Error("Setup cancelled during GitHub auth.");
+  if (choice === "Use current GitHub auth")
+    return {};
+  if (choice === "Import token from gh")
+    return { importGhToken: true };
+  const token = (await ctx.ui.editor("GitHub token", ""))?.trim();
+  if (!token)
+    throw new Error("GitHub token is required.");
+  return { githubToken: token };
+}
+async function runRigSetupFlow(api, ctx) {
+  if (!hasInteractiveSetupTerminal(ctx))
+    throw new Error("Rig Setup requires an interactive OMP cockpit terminal.");
+  const projectRoot = projectRootFromContext(ctx);
+  const setup = await requireProjectSetupService(projectRoot);
+  const status = await setup.detectStartupStatus({ projectRoot });
+  const existingConfig = status.config;
+  let configAction = existingConfig.exists ? "repair" : "reconfigure";
+  if (existingConfig.exists) {
+    const choice = await ctx.ui.select("Rig config 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 slugInput = (await ctx.ui.editor("GitHub repo slug", status.slug ?? ""))?.trim();
+  if (!slugInput)
+    throw new Error("GitHub repo slug is required.");
+  const repo = setup.parseRepoSlug(slugInput);
+  const placement = await chooseSetupPlacement(ctx);
+  const auth = await promptSetupAuth(ctx, status);
+  const rewriteConfig = configAction === "reconfigure" || configAction === "repair" && (!existingConfig.valid || existingConfig.slug !== repo.slug);
+  const result = await setup.runSetup({
+    projectRoot,
+    slug: repo.slug,
+    placement,
+    rewriteConfig,
+    ...auth
+  });
+  await appendOperatorNote(api, projectRoot, `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");
+}
+async function runRigAutomaticSetup(api, ctx, status) {
+  const projectRoot = projectRootFromContext(ctx);
+  const setup = await requireProjectSetupService(projectRoot);
+  const slugInput = status.slug?.trim();
+  if (!slugInput)
+    return false;
+  const repo = setup.parseRepoSlug(slugInput);
+  const placement = await chooseAutomaticSetupPlacement(ctx);
+  const rewriteConfig = !status.config.exists || !status.config.valid;
+  try {
+    const result = await setup.runSetup({
+      projectRoot,
+      slug: repo.slug,
+      placement,
+      rewriteConfig,
+      importGhToken: status.auth.source === "gh"
+    });
+    await appendOperatorNote(api, projectRoot, `Rig auto-setup completed for ${repo.slug} (${placement.alias})`);
+    ctx.ui.notify(`Rig auto-setup ready: ${repo.slug} on ${result.placement}.`, "info");
+    return true;
+  } catch (error) {
+    ctx.ui.notify(`Rig auto-setup needs attention: ${notificationMessage(error)}`, "warning");
+    return false;
+  }
+}
+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;
+}
+async function appendTaskSelected(api, projectRoot, task, projection) {
+  const id = projection.id(task);
+  if (!id)
+    return;
+  try {
+    (await loadWorkflowJournalWriter(projectRoot))?.appendTaskSelected(api, {
+      taskId: id,
+      title: projection.title(task)
+    });
+  } catch {}
+}
+function notificationMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function loadPlacementService(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, defineCapability(PLACEMENT_SERVICE), "No placement service plugin provides local/remote placement for this project root.");
+}
+async function loadTaskIo(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, defineCapability(TASK_IO_SERVICE_CAPABILITY), "No task-io plugin provides task IO for this project root.");
+}
+async function loadRunControl(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, defineCapability(RUN_CONTROL), "No run-control plugin provides run control for this project root.");
+}
+async function loadRunReadModel(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, defineCapability(RUN_READ_MODEL), "No run-read-model plugin provides run read-model for this project root.");
+}
+async function dispatchSelectedTask(api, ctx, id, onProgress) {
+  const taskIdValue = selectedTaskIdFromDispatchAction(id);
+  if (!taskIdValue)
+    throw new Error("Task detail dispatch requires a selected task id.");
+  const projectRoot = projectRootFromContext(ctx);
+  onProgress?.(`dispatch \xB7 loading task ${taskIdValue}\u2026`);
+  const task = await (await loadTaskIo(projectRoot)).getTask(projectRoot, taskIdValue);
+  if (!task)
+    throw new Error(`Selected task not found: ${taskIdValue}`);
+  const { caps } = await resolveCockpitRegistry(ctx);
+  await appendTaskSelected(api, projectRoot, task, caps.taskProjection);
+  onProgress?.("dispatch \xB7 provisioning target and waiting for OMP session\u2026");
+  const dispatcher = await requireCapabilityForRoot(projectRoot, defineCapability(RUN_DISPATCH), "No transport plugin provides run dispatch for this project root.");
+  const result = await dispatcher.dispatchRun({ projectRoot, taskId: taskIdValue, ...task.title ? { title: task.title } : {} });
+  onProgress?.(`dispatch \xB7 session ${result.runId.slice(0, 8)} online; attaching\u2026`);
+  const discovery = await loadCapabilityForRoot(projectRoot, defineCapability(RUN_DISCOVERY));
+  const attach = discovery ? await discovery.attachViaRelay({
+    projectRoot,
+    runId: result.runId,
+    taskId: taskIdValue,
+    identityFilter: await identityFilterForContext(ctx)
+  }) : null;
+  const joinLink = attach?.joinLink ?? null;
+  if (joinLink) {
+    await joinCollab(ctx, { joinLink });
+    onProgress?.(`dispatch \xB7 attached ${result.runId.slice(0, 8)}`);
+    ctx.ui.notify(`Attached ${result.runId.slice(0, 8)} through OMP collab.`, "info");
+    return;
+  }
+  const sessionPath = attach?.sessionPath ?? null;
+  const switchSession = ctx.switchSession;
+  if (sessionPath && switchSession) {
+    const switched = await switchSession(sessionPath);
+    if (!switched.cancelled) {
+      onProgress?.(`dispatch \xB7 attached ${result.runId.slice(0, 8)}`);
+      ctx.ui.notify(`Attached ${result.runId.slice(0, 8)} through OMP collab.`, "info");
+      return;
+    }
+  }
+  onProgress?.(`dispatch \xB7 run ${result.runId.slice(0, 8)} online; attach from Runs`);
+  ctx.ui.notify(`Dispatched ${taskIdValue} as ${result.runId.slice(0, 8)} \u2014 open Runs to attach when it comes online.`, "info");
+}
+async function collectDoctorChecks(_api, ctx) {
+  const projectRoot = projectRootFromContext(ctx);
+  const service = await loadCapabilityForRoot(projectRoot, defineCapability(DOCTOR));
+  if (!service)
+    return [];
+  return service.runDoctorChecks({ projectRoot, identityContext: ctx });
+}
+async function producePanelContent(projectRoot, panelId, context) {
+  const host = await resolvePluginHost(projectRoot).then((r) => r.host).catch(() => null);
+  const panel = host?.listExecutablePanels().find((p) => p.slot === RIG_COCKPIT_PANEL_SLOT && p.id === panelId);
+  if (!panel)
+    return { rows: [], board: undefined };
+  const rows = panel.produce ? await panel.produce(context) : [];
+  const board = panel.produceBoard ? await panel.produceBoard(context) : undefined;
+  return {
+    rows: Array.isArray(rows) ? rows : [],
+    board: board && typeof board === "object" && "kind" in board ? board : undefined
+  };
+}
+async function loadRigFlowState(ctx, screen, selectedTaskId, api, runs = [], actionRowsEnabled = true) {
+  const projectRoot = projectRootFromContext(ctx);
+  try {
+    const needsServer = screen === "cockpit" || screen === "runs" || screen === "run-detail" || screen === "server" || screen === "tasks" || screen === "task-detail";
+    const needsRunSummaries = screen === "cockpit" || screen === "runs" || screen === "run-detail";
+    const server = needsServer ? await readCurrentPlacement(ctx) : null;
+    const taskIo = screen === "task-detail" && selectedTaskId ? await loadTaskIo(projectRoot) : null;
+    const selectedTask = screen === "task-detail" && selectedTaskId ? await taskIo?.getTask(projectRoot, selectedTaskId) ?? null : null;
+    const readModel = needsRunSummaries ? await loadRunReadModel(projectRoot) : null;
+    const runControl = readModel ? await loadRunControl(projectRoot) : null;
+    const readModelDiscoveryFilter = readModel ? await identityFilterForContext(ctx) : {};
+    const runClassifications = readModel ? new Map(runs.map((run) => [run.runId, readModel.classifyRun(run)])) : undefined;
+    const runStageRows = readModel ? new Map(runs.map((run) => [run.runId, readModel.projectRunStages(run)])) : undefined;
+    const runActionAffordances = runControl ? new Map(await Promise.all(runs.map(async (run) => {
+      const [attach, steer, stop, pause, resume] = await Promise.all([
+        runControl.resolveControlTarget({ projectRoot, runId: run.runId, purpose: "attach", discoveryFilter: readModelDiscoveryFilter }),
+        runControl.resolveControlTarget({ projectRoot, runId: run.runId, purpose: "steer", discoveryFilter: readModelDiscoveryFilter }),
+        runControl.resolveControlTarget({ projectRoot, runId: run.runId, purpose: "stop", discoveryFilter: readModelDiscoveryFilter }),
+        runControl.resolveControlTarget({ projectRoot, runId: run.runId, purpose: "pause", discoveryFilter: readModelDiscoveryFilter }),
+        runControl.resolveControlTarget({ projectRoot, runId: run.runId, purpose: "resume", discoveryFilter: readModelDiscoveryFilter })
+      ]).catch(() => [null, null, null, null, null]);
+      return [run.runId, { attach: attach?.canDeliver === true, steer: steer?.canDeliver === true, stop: stop?.canDeliver === true, pause: pause?.canDeliver === true, resume: resume?.canDeliver === true }];
+    }))) : undefined;
+    const { rows: panelRows, board } = await producePanelContent(projectRoot, screen, { projectRoot, identityContext: ctx, actionRowsEnabled, runs, ...runClassifications ? { runClassifications } : {} });
+    return {
+      projectRoot,
+      ...server ? { server } : {},
+      ...selectedTask ? { selectedTask, selectedTaskId } : selectedTaskId ? { selectedTaskId } : {},
+      ...panelRows.length ? { panelRows } : {},
+      ...board ? { board } : {},
+      ...runClassifications ? { runClassifications } : {},
+      ...runStageRows ? { runStageRows } : {},
+      ...runActionAffordances ? { runActionAffordances } : {}
+    };
+  } catch (error) {
+    return { projectRoot, error: notificationMessage(error) };
+  }
+}
+function isMissingRigConfigError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("no .rig/rig.config") || message.includes("no rig.config.{ts,mts,json}") || message.includes("no rig.config");
+}
+async function resolveCockpitRegistry(ctx) {
+  const projectRoot = projectRootFromContext(ctx);
+  const resolved = await (async () => {
+    try {
+      return await resolvePluginHost(projectRoot);
+    } catch (error) {
+      if (isMissingRigConfigError(error))
+        return null;
+      throw error;
+    }
+  })();
+  if (!resolved)
+    return { catalog: DEFAULT_SCREEN_CATALOG, caps: defaultCockpitCapabilities };
+  const { host } = resolved;
+  return { catalog: resolveScreenCatalog(host.listPanels()), caps: await resolveCockpitCapabilities(host) };
+}
+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.");
+}
+async function discoverRuns(ctx) {
+  const projectRoot = ctx ? projectRootFromContext(ctx) : rigProjectRoot();
+  const readModel = await loadRunReadModel(projectRoot);
+  return [...await readModel.listRuns({ projectRoot, discoveryFilter: ctx ? await identityFilterForContext(ctx) : {} })];
+}
+async function joinRun(ctx, encodedRunId) {
+  const runId = decodeURIComponent(encodedRunId);
+  const projectRoot = projectRootFromContext(ctx);
+  const runControl = await loadRunControl(projectRoot);
+  const target = await runControl.resolveControlTarget({ projectRoot, runId, purpose: "attach", discoveryFilter: await identityFilterForContext(ctx) });
+  if (!target?.joinLink || target.canDeliver !== true) {
+    ctx.ui.notify(target?.reason ?? "Selected run is not currently available through collab.", "warning");
+    return;
+  }
+  await joinCollab(ctx, { joinLink: target.joinLink, ...target.collabCwd != null ? { cwd: target.collabCwd } : {} });
+  ctx.ui.notify(`Joined ${runId.slice(0, 8)} through OMP collab.`, "info");
+}
+async function steerRun(_api, ctx, encodedRunId, stop = false, input) {
+  const runId = decodeURIComponent(encodedRunId);
+  const message = stop ? input ?? await ctx.ui.editor("Stop reason (optional)", "operator requested stop") : (input ?? await ctx.ui.editor("Steer Rig run", ""))?.trim();
+  if (!message)
+    return;
+  const projectRoot = projectRootFromContext(ctx);
+  const runControl = await loadRunControl(projectRoot);
+  const result = await runControl.deliverControl({ projectRoot, runId, control: stop ? { kind: "stop", reason: message } : { kind: "steer", message }, discoveryFilter: await identityFilterForContext(ctx) });
+  if (!result.delivered)
+    throw new Error(result.detail ?? `Could not ${result.kind} run ${runId}.`);
+  ctx.ui.notify(stop ? `Stop requested for ${runId}.` : `Steered ${runId}.`, "info");
+}
+async function controlRun(ctx, encodedRunId, kind) {
+  const runId = decodeURIComponent(encodedRunId);
+  const projectRoot = projectRootFromContext(ctx);
+  const runControl = await loadRunControl(projectRoot);
+  const result = await runControl.deliverControl({ projectRoot, runId, control: { kind }, discoveryFilter: await identityFilterForContext(ctx) });
+  if (!result.delivered)
+    throw new Error(result.detail ?? `Could not ${kind} run ${runId}.`);
+  ctx.ui.notify(kind === "pause" ? `Pause requested for ${runId}.` : `Resume requested for ${runId}.`, "info");
+}
+function inboxActionId(request, decision) {
+  const base = `inbox:${encodeURIComponent(request.runId)}:${encodeURIComponent(request.requestId)}`;
+  return decision ? `${base}:${decision}` : base;
+}
+function parseInboxActionTarget(id) {
+  if (!id.startsWith("inbox:"))
+    return null;
+  const [encodedRunId, encodedRequestId, encodedDecision] = id.slice("inbox:".length).split(":");
+  if (!encodedRunId || !encodedRequestId)
+    return null;
+  try {
+    const runId = decodeURIComponent(encodedRunId);
+    const requestId = decodeURIComponent(encodedRequestId);
+    const decision = encodedDecision === "approved" || encodedDecision === "rejected" || encodedDecision === "answered" ? encodedDecision : null;
+    return runId && requestId ? { runId, requestId, decision } : null;
+  } catch {
+    return null;
+  }
+}
+function inboxPrompt(request) {
+  return request.body ? `${request.title}
+${request.body}` : request.title;
+}
+async function resolveInboxRequest(_api, ctx, id, answerInput) {
+  const target = parseInboxActionTarget(id);
+  if (!target) {
+    ctx.ui.notify("Inbox action is malformed; refresh the Rig Inbox.", "warning");
+    return;
+  }
+  const projectRoot = projectRootFromContext(ctx);
+  const readModel = await loadRunReadModel(projectRoot);
+  const runControl = await loadRunControl(projectRoot);
+  const run = await readModel.getRun({ projectRoot, selector: { id: target.runId, kind: "run-id" }, discoveryFilter: await identityFilterForContext(ctx) });
+  const request = run?.inbox.find((item) => item.requestId === target.requestId);
+  if (!run || !request) {
+    ctx.ui.notify("Inbox request is stale or already resolved; refresh the Rig Inbox.", "warning");
+    return;
+  }
+  if (request.kind === "approval") {
+    const decision = target.decision === "approved" || target.decision === "rejected" ? target.decision : await (async () => {
+      const choice = await ctx.ui.select(inboxPrompt(request), ["Approve", "Reject"]);
+      return choice === "Approve" ? "approved" : choice === "Reject" ? "rejected" : null;
+    })();
+    const approvalDecision = decision === "approved" ? "approve" : decision === "rejected" ? "reject" : null;
+    if (!approvalDecision) {
+      ctx.ui.notify("Inbox approval cancelled.", "info");
+      return;
+    }
+    const result2 = await runControl.resolveInboxRequest({ projectRoot, runId: run.runId, resolution: { kind: "approval", requestId: request.requestId, decision: approvalDecision }, discoveryFilter: await identityFilterForContext(ctx) });
+    if (!result2.delivered)
+      throw new Error(result2.detail ?? `Inbox request ${request.requestId} was not delivered.`);
+    ctx.ui.notify(`Inbox request ${request.requestId} ${decision}.`, "info");
+    return;
+  }
+  const answer = answerInput !== undefined ? answerInput : request.options && request.options.length > 0 ? await ctx.ui.select(inboxPrompt(request), [...request.options]) : await ctx.ui.editor(`Rig input: ${request.title}`, request.body ?? "");
+  if (answer === undefined) {
+    ctx.ui.notify("Inbox input cancelled.", "info");
+    return;
+  }
+  const result = await runControl.resolveInboxRequest({ projectRoot, runId: run.runId, resolution: { kind: "input", requestId: request.requestId, answers: { answer: String(answer) } }, discoveryFilter: await identityFilterForContext(ctx) });
+  if (!result.delivered)
+    throw new Error(result.detail ?? `Inbox request ${request.requestId} was not delivered.`);
+  ctx.ui.notify(`Inbox request ${request.requestId} answered.`, "info");
+}
+function defaultFlowActions(api, ctx) {
+  return {
+    async act(id, input, onProgress) {
+      if (id === "setup:start") {
+        await runRigSetupFlow(api, ctx);
+        return;
+      }
+      if (id === "setup:doctor") {
+        const status = await detectRigStartupStatus(ctx);
+        const checks = await collectDoctorChecks(api, ctx);
+        notifyDoctor(ctx, "Setup doctor", 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));
+        const projectRoot = projectRootFromContext(ctx);
+        const service = await loadPlacementService(projectRoot);
+        await service.selectPlacement({ projectRoot, alias });
+        await appendCurrentTargetSelected(api, service, projectRoot, `selected target ${alias}`);
+        if (ctx.hasUI)
+          ctx.ui.notify(`Selected Rig target ${alias}.`, "info");
+        return;
+      }
+      if (id === "server:add-remote") {
+        const target = await promptForNewRemote(ctx);
+        if (target)
+          await appendTargetSelected(api, projectRootFromContext(ctx), target, `added remote target ${target.alias}`);
+        if (ctx.hasUI)
+          ctx.ui.notify("Rig remote target saved and selected.", "info");
+        return;
+      }
+      if (id.startsWith("remote:use:")) {
+        const alias = decodeActionValue(id.slice("remote:use:".length));
+        const projectRoot = projectRootFromContext(ctx);
+        const service = await loadPlacementService(projectRoot);
+        await service.selectPlacement({ projectRoot, alias });
+        await appendCurrentTargetSelected(api, service, projectRoot, `selected remote endpoint ${alias}`);
+        if (ctx.hasUI)
+          ctx.ui.notify(`Selected Rig remote endpoint ${alias}.`, "info");
+        return;
+      }
+      if (id === "remote:add") {
+        const target = await promptForNewRemote(ctx);
+        if (target)
+          await appendTargetSelected(api, projectRootFromContext(ctx), target, `added remote endpoint ${target.alias}`);
+        if (ctx.hasUI)
+          ctx.ui.notify("Rig remote endpoint saved and selected.", "info");
+        return;
+      }
+      if (id.startsWith("remote:remove:")) {
+        const alias = decodeActionValue(id.slice("remote:remove:".length));
+        const projectRoot = projectRootFromContext(ctx);
+        const removed = (await (await loadPlacementService(projectRoot)).removePlacement({ projectRoot, alias })).removed;
+        if (ctx.hasUI)
+          ctx.ui.notify(removed ? `Removed Rig remote endpoint ${alias}.` : `Rig remote endpoint ${alias} was not found.`, removed ? "info" : "warning");
+        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, onProgress);
+        return;
+      }
+      if (id.startsWith("view-pr:")) {
+        const url = decodeActionValue(id.slice("view-pr:".length));
+        if (ctx.hasUI)
+          ctx.ui.notify(`Pull request: ${url}`, "info");
+        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), false, input);
+        return;
+      }
+      if (id.startsWith("run-stop:")) {
+        await steerRun(api, ctx, id.slice("run-stop:".length), true, input);
+        return;
+      }
+      if (id.startsWith("run-pause:")) {
+        await controlRun(ctx, id.slice("run-pause:".length), "pause");
+        return;
+      }
+      if (id.startsWith("run-resume:")) {
+        await controlRun(ctx, id.slice("run-resume:".length), "resume");
+        return;
+      }
+      if (id.startsWith("inbox:")) {
+        await resolveInboxRequest(api, ctx, id, input);
+        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" || check.status === "fail");
+  const summary = checks.map((check) => `${check.level ?? check.status ?? "warn"} ${check.label}: ${check.detail ?? ""}`).join(" \xB7 ");
+  ctx.ui.notify(`${title}: ${failed.length === 0 ? "ok" : "failed"} \xB7 ${summary}`, failed.length === 0 ? "info" : "error");
+}
+async function appendTargetSelected(api, projectRoot, placement, reason) {
+  try {
+    (await loadWorkflowJournalWriter(projectRoot))?.appendTargetSelected(api, {
+      target: workflowTargetForPlacement(placement),
+      ...reason ? { reason } : {}
+    });
+  } catch {}
+}
+async function appendCurrentTargetSelected(api, service, projectRoot, reason) {
+  try {
+    await appendTargetSelected(api, projectRoot, await service.readPlacement({ projectRoot }), reason);
+  } catch {}
+}
+async function appendWorkflowStarted(api, ctx, state) {
+  const projectRoot = state.projectRoot ?? projectRootFromContext(ctx);
+  try {
+    const identity = (await loadRunIdentityEnv(projectRoot))?.resolveRigIdentity(ctx) ?? null;
+    if (!identity)
+      return;
+    (await loadWorkflowJournalWriter(projectRoot))?.appendStarted(api, {
+      workflowId: ctx.sessionManager.getSessionId(),
+      target: workflowTargetForPlacement(state.server),
+      selectedRepo: identity.selectedRepo,
+      owner: identity.owner
+    });
+  } catch {}
+}
+async function appendOperatorNote(api, projectRoot, note) {
+  try {
+    (await loadWorkflowJournalWriter(projectRoot))?.appendOperatorNote(api, { note });
+  } catch {}
+}
+async function runSessionDoctor(api, ctx) {
+  const checks = await collectDoctorChecks(api, ctx);
+  notifyDoctor(ctx, "Sessions doctor", checks);
+}
+async function runCollabDoctor(ctx) {
+  const runs = await discoverRuns(ctx);
+  const identityFilter = (await loadRunIdentityEnv(projectRootFromContext(ctx)))?.resolveRigIdentityFilter(ctx) ?? null;
+  notifyDoctor(ctx, "Collab doctor", [
+    { label: "identity-filter", level: identityFilter ? "ok" : "warn", detail: identityFilter ? "available" : "unavailable" },
+    { label: "run-discovery", level: "ok", detail: `${runs.length} run record(s)` },
+    { label: "join-links", level: runs.some((run) => run.joinLink) ? "ok" : "warn", detail: `${runs.filter((run) => run.joinLink).length} joinable run(s)` }
+  ]);
+}
+function sessionDescription(run) {
+  const id = run.runId.slice(0, 8);
+  const cwd = run.collabCwd || run.worktreePath || run.sessionPath || "(unknown cwd)";
+  const link = collabLinks(run);
+  return link ? `${id} \xB7 ${cwd} \xB7 ${link}` : `${id} \xB7 ${cwd}`;
+}
+function collabLinks(run) {
+  const join = run.joinLink ? `joinLink ${run.joinLink}` : "";
+  const web = run.webLink ? `webLink ${run.webLink}` : "";
+  return join && web ? `${join} \xB7 ${web}` : join || web || "";
+}
+function findRunById(runs, runId) {
+  if (!runId)
+    return null;
+  return runs.find((item) => item.runId === runId) ?? null;
+}
+function canAttachRun(run, source) {
+  const affordance = runActionAffordanceFor(run, source);
+  if (affordance)
+    return affordance.attach;
+  return Boolean(run.joinLink && !run.stale);
+}
+function canSteerFromCockpit(run, source) {
+  return canSteer(run, source);
+}
+function runListActionHints(run, source) {
+  const encodedRunId = encodeURIComponent(run.runId);
+  return [
+    ...canAttachRun(run, source) ? [{ key: "a", label: "attach", id: `run:${encodedRunId}` }] : [],
+    ...canSteerFromCockpit(run, source) ? [{ key: "s", label: "steer", id: `run-steer:${encodedRunId}` }] : [],
+    ...canStop(run, source) ? [{ key: "x", label: "stop", id: `run-stop:${encodedRunId}` }] : [],
+    ...canPause(run, source) ? [{ key: "p", label: "pause", id: `run-pause:${encodedRunId}` }] : [],
+    ...canResume(run, source) ? [{ key: "u", label: "resume", id: `run-resume:${encodedRunId}` }] : []
+  ];
+}
+function serverLabel(server) {
+  return server?.alias?.trim() || "unselected";
+}
+function nextStepHint(server, runs, state) {
+  if (!server)
+    return "next: Server";
+  if (runs.some((run) => {
+    const classification = state.runClassifications?.get(run.runId);
+    return classification ? classification.isActive && !classification.isTerminal : false;
+  }))
+    return "next: Runs";
+  return "next: Tasks";
+}
+function taskDetailModel(state, server, projection) {
+  const task = state.selectedTask ?? null;
+  const id = projection.id(task);
+  if (!task || !id) {
+    return {
+      screen: "task-detail",
+      icon: screenGlyph2("task-detail"),
+      ref: "TASK",
+      title: "No task selected",
+      facts: [{ label: "hint", value: "Open a task row from Tasks before dispatch." }],
+      actions: []
+    };
+  }
+  const placement = serverLabel(server);
+  const dispatchReady = server ? server.dispatchReady !== false : true;
+  const dispatchAction = dispatchReady ? [{
+    id: `task-detail:dispatch:${encodeURIComponent(id)}`,
+    label: "DISPATCH",
+    glyph: "\uF0E7",
+    value: `\u2192 ${placement}`,
+    hint: "submit this run to the selected target, then attach"
+  }] : [];
+  return {
+    screen: "task-detail",
+    icon: screenGlyph2("task-detail"),
+    ref: `TASK ${id}`,
+    title: projection.title(task),
+    status: projection.status(task),
+    body: projection.description(task),
+    bodyLabel: "task",
+    facts: [
+      ...task.url ? [{ label: "url", value: task.url, tone: "link" }] : [],
+      { label: "source", value: task.source ?? "configured task source" },
+      { label: "placement", value: placement }
+    ],
+    actions: dispatchAction
+  };
+}
+function runDetailModel(run, source) {
+  const classification = runClassificationFor(run, source);
+  const encodedRunId = encodeURIComponent(run.runId);
+  const status = classification.status;
+  const joinable = canAttachRun(run, source);
+  const shortId = run.runId.slice(0, 8);
+  const sourceTask = run.projection.record.sourceTask;
+  const sourceTaskId = isRecord(sourceTask) && typeof sourceTask.id === "string" ? sourceTask.id : null;
+  const recoveryTaskId = run.taskId || sourceTaskId;
+  const issueUrl = isRecord(sourceTask) && typeof sourceTask.url === "string" ? sourceTask.url : null;
+  const isFailed = classification.offersRecovery;
+  const stages = runStageRowsFor(run, source).map((row) => ({ label: row.label, status: String(row.currentValue ?? "pending") }));
+  return {
+    screen: "run-detail",
+    icon: screenGlyph2("run-detail"),
+    ref: `RUN ${shortId}`,
+    title: run.title || `Run ${shortId}`,
+    status,
+    body: run.errorSummary || sessionDescription(run),
+    bodyLabel: "summary",
+    facts: [
+      ...run.taskId ? [{ label: "task", value: run.taskId }] : [],
+      { label: "cwd", value: run.collabCwd || run.worktreePath || run.sessionPath || "(unknown cwd)" },
+      ...run.webLink ? [{ label: "web", value: run.webLink, tone: "link" }] : [],
+      ...run.prUrl ? [{ label: "pr", value: run.prUrl, tone: "link" }] : [],
+      ...issueUrl ? [{ label: "issue", value: issueUrl, tone: "link" }] : [],
+      ...run.inbox.length > 0 ? [{ label: "gates", value: `${run.inbox.length} waiting`, tone: "warn" }] : []
+    ],
+    ...stages.length > 0 ? { stages } : {},
+    actions: [
+      ...run.inbox.map((request) => ({
+        id: inboxActionId({ runId: run.runId, requestId: request.requestId }),
+        label: request.kind === "approval" ? "GATE" : "INPUT",
+        glyph: "\uF0E0",
+        value: request.title.slice(0, 32) || request.requestId,
+        hint: request.kind === "approval" ? "approve or reject this pending gate" : "answer this pending input"
+      })),
+      ...joinable ? [{ id: "detail:join", label: "JOIN", glyph: "\uF090", value: "live", hint: "attach to this run's live OMP collab session" }] : [],
+      ...canSteerFromCockpit(run, source) ? [{ id: `run-steer:${encodedRunId}`, label: "STEER", glyph: "\uF1D8", value: "message", hint: classification.isNeedsAttention ? "nudge the stalled live agent with operator guidance" : "send a steering prompt to the running agent" }] : [],
+      ...canStop(run, source) ? [{ id: `run-stop:${encodedRunId}`, label: "STOP", glyph: "\uF04D", value: "graceful", hint: "stop this run (terminal)", danger: true }] : [],
+      ...canPause(run, source) ? [{ id: `run-pause:${encodedRunId}`, label: "PAUSE", glyph: "\uF04C", value: "park", hint: "park this run without finalizing" }] : [],
+      ...canResume(run, source) ? [{ id: `run-resume:${encodedRunId}`, label: "RESUME", glyph: "\uF04B", value: "re-engage", hint: "resume a paused run" }] : [],
+      ...isFailed && recoveryTaskId ? [{ id: `task-detail:${encodeURIComponent(recoveryTaskId)}`, label: "OPEN TASK", glyph: "\uF08E", value: recoveryTaskId, hint: "open the source task before choosing the next recovery step" }] : [],
+      ...isFailed && run.prUrl ? [{ id: `view-pr:${encodeURIComponent(run.prUrl)}`, label: "VIEW PR", glyph: "\uF09B", value: "url", hint: "show the pull request URL for recovery/review" }] : [],
+      ...isFailed && recoveryTaskId ? [{ id: `task-detail:dispatch:${encodeURIComponent(recoveryTaskId)}`, label: "REDISPATCH", glyph: "\uF0E7", value: "fresh run", hint: "launch a clean run for the same task" }] : []
+    ]
+  };
+}
+function cockpitNavValue(screen, server, runs, state) {
+  switch (screen) {
+    case "server":
+      return serverLabel(server);
+    case "tasks":
+      return server?.taskSource ?? "configured source";
+    case "runs":
+      return String(runs.length);
+    default:
+      return "";
+  }
+}
+function cockpitNavRows(server, runs, state, catalog) {
+  return cockpitNavScreens(catalog).map(({ screen, nav }) => ({
+    id: `to:${screen}`,
+    label: nav.label,
+    currentValue: cockpitNavValue(screen, server, runs, state),
+    values: ["\u203A"],
+    description: nav.description
+  }));
+}
+function itemsFor(screen, runs, actionRowsEnabled, _selectedRunId, state = {}, catalog = DEFAULT_SCREEN_CATALOG, projection = defaultCockpitCapabilities.taskProjection) {
+  const server = state.server ?? null;
+  const projectRoot = state.projectRoot ?? rigProjectRoot();
+  const loadError = state.error?.trim();
+  if (screen === "task-detail" || screen === "run-detail")
+    return [];
+  if (loadError) {
+    return [
+      { id: "title", label: screenTitle(screen, catalog), currentValue: "load failed", heading: true },
+      { id: `${screen}:error`, label: "LOAD FAILED", currentValue: "error", heading: true, description: loadError }
+    ];
+  }
+  switch (screen) {
+    case "cockpit":
+      return [
+        { id: "title", label: screenTitle("cockpit", catalog), currentValue: "", heading: true },
+        { id: "next", label: "NEXT", currentValue: nextStepHint(server, runs, state), heading: true, description: "guided path: Server \u2192 Tasks \u2192 Detail \u2192 Dispatch \u2192 Run Detail" },
+        ...cockpitNavRows(server, runs, state, catalog)
+      ];
+    default: {
+      const producedRows = state.panelRows ?? [];
+      if (producedRows.length > 0)
+        return [...producedRows];
+      return [
+        { id: "title", label: screenTitle(screen, catalog), currentValue: "unavailable", heading: true },
+        { id: `${screen}:unavailable`, label: "UNAVAILABLE", currentValue: "reload", values: ["reload"], heading: true, description: "This screen's content could not be loaded right now \u2014 press r to reload." }
+      ];
+    }
+  }
+}
+
+class RigFlowComponent {
+  tui;
+  api;
+  done;
+  onQuit;
+  refreshRuns;
+  refreshState;
+  actions;
+  actionRowsEnabled;
+  catalog;
+  caps;
+  #view;
+  #runs;
+  #state;
+  #error = "";
+  #domainViews = new Map;
+  #helpView;
+  #genericView = new BoardSettingsList;
+  #detailComposer = new DetailComposer;
+  #serverLabel = "resolving target\u2026";
+  #notice = null;
+  #inputLine = null;
+  #tick = 0;
+  #runById = new Map;
+  #screenStack = [];
+  #selectedRunId = null;
+  #selectedTaskId = null;
+  #discoveryFiber;
+  #refreshing = false;
+  #busyDepth = 0;
+  #animationTimer;
+  constructor(tui, api, done, onQuit, screen, runs, state, refreshRuns, refreshState, actions, actionRowsEnabled, catalog = DEFAULT_SCREEN_CATALOG, caps = defaultCockpitCapabilities, helpCatalog) {
+    this.tui = tui;
+    this.api = api;
+    this.done = done;
+    this.onQuit = onQuit;
+    this.refreshRuns = refreshRuns;
+    this.refreshState = refreshState;
+    this.actions = actions;
+    this.actionRowsEnabled = actionRowsEnabled;
+    this.catalog = catalog;
+    this.caps = caps;
+    this.#helpView = new HelpView(helpCatalog);
+    this.#runs = runs;
+    this.#state = state;
+    this.#view = screen;
+    this.#feedViews();
+    this.#startDiscoveryStream();
+  }
+  #startDiscoveryStream() {
+    const root = this.#state.projectRoot ?? rigProjectRoot();
+    const onChange = () => this.#refreshFromEvent();
+    (async () => {
+      try {
+        const discovery = await loadCapabilityForRoot(root, defineCapability(RUN_DISCOVERY));
+        if (!discovery)
+          return;
+        this.#discoveryFiber = Effect.runFork(discovery.runDiscoveryStream(root).pipe(Stream.debounce(Duration.millis(500)), Stream.runForEach(() => Effect.promise(onChange))));
+      } catch {}
+    })();
+  }
+  #beginBusy() {
+    this.#busyDepth += 1;
+    this.#tick += 1;
+    this.#feedViews();
+    this.tui.requestRender();
+    if (!this.#animationTimer) {
+      this.#animationTimer = setInterval(() => {
+        if (this.#busyDepth <= 0)
+          return;
+        this.#tick += 1;
+        this.#feedViews();
+        this.tui.requestRender();
+      }, 100);
+      this.#animationTimer.unref?.();
+    }
+    let ended = false;
+    return () => {
+      if (ended)
+        return;
+      ended = true;
+      this.#busyDepth = Math.max(0, this.#busyDepth - 1);
+      if (this.#busyDepth === 0 && this.#animationTimer) {
+        clearInterval(this.#animationTimer);
+        this.#animationTimer = undefined;
+      }
+    };
+  }
+  async#refreshFromEvent() {
+    if (this.#refreshing)
+      return;
+    this.#refreshing = true;
+    const endBusy = this.#beginBusy();
+    try {
+      await this.#refreshCurrent();
+      this.tui.requestRender();
+    } catch {} finally {
+      endBusy();
+      this.#refreshing = false;
+    }
+  }
+  registerDomainView(screenId, view) {
+    this.#domainViews.set(screenId, view);
+  }
+  viewHost() {
+    return {
+      requestRender: () => this.tui.requestRender(),
+      act: (actionId) => this.#actOnItem({ id: actionId, label: "", values: ["go"] }),
+      reload: () => this.#runAction(async () => {}),
+      attach: (runId) => this.#attach(runId),
+      openSteer: (runId) => {
+        this.#inputLine = { kind: "steer", buffer: "", run: { runId } };
+        this.tui.requestRender();
+      },
+      openSearch: (current, apply) => {
+        this.#inputLine = { kind: "search", buffer: current, apply };
+        this.tui.requestRender();
+      },
+      navigate: (screenId) => this.#navigate(screenId),
+      back: () => this.#back(),
+      toCockpit: () => this.#navigate("cockpit", false),
+      showHelp: () => this.#setView("help"),
+      setNotice: (text) => {
+        this.#notice = text;
+      }
+    };
+  }
+  #feedViews() {
+    if (this.#state.server)
+      this.#serverLabel = serverLabel(this.#state.server);
+    this.#runById.clear();
+    for (const entry of this.#runs)
+      this.#runById.set(entry.runId, entry);
+    const board = this.#state.board;
+    if (board)
+      this.#domainViews.get(board.kind)?.setBoard(board);
+    if (this.#state.error)
+      this.#domainViews.get(this.#view)?.setError(this.#state.error);
+    if (this.#activeView() === this.#genericView) {
+      const genericScreen = this.#view === "help" ? "cockpit" : this.#view;
+      this.#genericView.setTitle(screenLabel(genericScreen, this.catalog));
+      this.#genericView.setItems(itemsFor(genericScreen, this.#runs, this.actionRowsEnabled, this.#selectedRunId, this.#state, this.catalog, this.caps.taskProjection));
+    }
+    if (this.#view === "task-detail") {
+      this.#detailComposer.setModel(this.#state.error ? { screen: "task-detail", icon: screenGlyph2("task-detail"), ref: "TASK", title: "Task failed to load", body: this.#state.error, bodyLabel: "error", facts: [{ label: "hint", value: "Refresh or return to Tasks." }], actions: [] } : taskDetailModel(this.#state, this.#state.server ?? null, this.caps.taskProjection));
+    } else if (this.#view === "run-detail") {
+      const run = findRunById(this.#runs, this.#selectedRunId);
+      this.#detailComposer.setModel(this.#state.error ? { screen: "run-detail", icon: screenGlyph2("run-detail"), ref: "RUN", title: "Run failed to load", body: this.#state.error, bodyLabel: "error", facts: [{ label: "hint", value: "Refresh or return to Runs." }], actions: [] } : run ? runDetailModel(run, this.#state) : { screen: "run-detail", icon: screenGlyph2("run-detail"), ref: "RUN", title: "Run unavailable", facts: [{ label: "hint", value: "The selected run is no longer discoverable; back to Runs." }], actions: [] });
+    }
+    for (const view of this.#domainViews.values())
+      view.setTick(this.#tick);
+    this.#detailComposer.tick = this.#tick;
+  }
+  #activeView() {
+    const domainView = this.#domainViews.get(this.#view);
+    if (domainView)
+      return domainView;
+    if (this.#view === "task-detail")
+      return this.#detailComposer;
+    if (this.#view === "run-detail")
+      return this.#detailComposer;
+    return this.#genericView;
+  }
+  #setView(next) {
+    this.#view = next;
+    this.#notice = null;
+    this.#feedViews();
+    this.tui.requestRender();
+  }
+  async#navigate(next, push = true) {
+    if (push && this.#view !== "help")
+      this.#screenStack.push(this.#view);
+    this.#view = next;
+    this.#notice = null;
+    const endBusy = this.#beginBusy();
+    try {
+      await this.#refreshCurrent();
+    } finally {
+      endBusy();
+    }
+  }
+  async#back() {
+    const previous = this.#screenStack.pop() ?? "cockpit";
+    await this.#navigate(previous, false);
+  }
+  async#refreshCurrent() {
+    let runLoadError = null;
+    try {
+      this.#runs = await this.refreshRuns();
+    } catch (error) {
+      runLoadError = notificationMessage(error);
+      this.#runs = [];
+    }
+    if (this.#view !== "help") {
+      const loadedState = await this.refreshState(this.#view, this.#selectedTaskId, this.#runs);
+      this.#state = runLoadError ? { ...loadedState, error: loadedState.error ? `${runLoadError}; ${loadedState.error}` : runLoadError } : loadedState;
+      if (this.#state.error)
+        this.#error = this.#state.error;
+    } else if (runLoadError) {
+      this.#error = runLoadError;
+    }
+    this.#feedViews();
+    this.tui.requestRender();
+  }
+  async#runAction(action) {
+    const endBusy = this.#beginBusy();
+    const onProgress = (message) => {
+      this.#notice = message;
+      this.#feedViews();
+      this.tui.requestRender();
+    };
+    try {
+      this.#error = "";
+      await action(onProgress);
+      await this.#refreshCurrent();
+      this.tui.requestRender();
+    } catch (error) {
+      this.#error = this.caps.dispatchOutcome.humanize(error) ?? notificationMessage(error);
+      this.tui.requestRender();
+    } finally {
+      endBusy();
+    }
+  }
+  #headerLine() {
+    const crumb = this.#view === "help" ? ` ${ink42("\u203A")} ${ink22("help")}` : ` ${ink42("\u203A")} ${ink22(screenLabel(this.#view, this.catalog))}`;
+    return ` ${accent2("\u258D")}${bold2(ink5("rig"))} ${ink32("\u2014 operate the drones")}${crumb}   ${ink42("\xB7")} ${cyan2(this.#serverLabel)}`;
+  }
+  #noticeText() {
+    if (!this.#notice)
+      return null;
+    const prefix = this.#busyDepth > 0 ? `${RIG_SPINNER_FRAMES2[this.#tick % RIG_SPINNER_FRAMES2.length]} ` : "";
+    return `${prefix}${this.#notice}`;
+  }
+  #footerLines() {
+    if (this.#inputLine) {
+      const line = this.#inputLine;
+      const label = line.kind === "search" ? `${accent2("/")}${ink5(line.buffer)}` : `${accentDim2("steer")} ${ink32(`(${line.run.runId.slice(0, 8)})`)} ${accent2("\u276F")} ${ink5(line.buffer)}`;
+      return [
+        ` ${label}${accent2("\u2588")}`,
+        ` ${accent2("enter")}${ink32(line.kind === "search" ? " keep filter" : " send steer")}  ${accent2("esc")}${ink32(line.kind === "search" ? " clear" : " cancel")}`
+      ];
+    }
+    if (this.#error)
+      return [` ${red2(`error: ${this.#error}`)}`, ` ${accent2("esc")}${ink32(" cockpit")}  ${accent2("q")}${ink32(" quit")}`];
+    if (this.#view === "help")
+      return [` ${accent2("\u2190")}${ink32(" back")}  ${accent2("esc")}${ink32(" cockpit")}  ${accent2("q")}${ink32(" quit")}`];
+    const domainFooter = this.#domainViews.get(this.#view)?.footer;
+    if (domainFooter)
+      return domainFooter(this.#noticeText());
+    if (this.#view === "task-detail" || this.#view === "run-detail") {
+      const isTask = this.#view === "task-detail";
+      const notice2 = this.#noticeText();
+      const hint = notice2 ? accentDim2(notice2) : ink42(isTask ? "review the task, then dispatch" : "live run controls");
+      return [
+        ` ${hint}`,
+        ` ${accent2("\u2191\u2193")}${ink32(" action")}  ${accent2("enter")}${ink32(isTask ? " dispatch" : " run")}  ${accent2("\u21DE\u21DF")}${ink32(" scroll")}  ${accent2("\u2190")}${ink32(" back")}  ${accent2("esc")}${ink32(" cockpit")}  ${accent2("q")}${ink32(" quit")}`
+      ];
+    }
+    const notice = this.#noticeText();
+    return [
+      ` ${notice ? accentDim2(notice) : ink42(`screen: ${screenLabel(this.#view, this.catalog)}`)}`,
+      ` ${accent2("\u2191\u2193")}${ink32(" move")}  ${accent2("enter")}${ink32(" act/open")}  ${accent2("\u2190")}${ink32(" back")}  ${accent2("esc")}${ink32(" cockpit")}  ${accent2("q")}${ink32(" quit")}`
+    ];
+  }
+  async#attach(runId) {
+    const record = this.#runById.get(runId);
+    if (!record || !canAttachRun(record, this.#state))
+      return;
+    await this.#runAction(() => this.actions.act(`run:${encodeURIComponent(runId)}`));
+    if (!this.#error)
+      this.done();
+  }
+  async#stop(run) {
+    this.#notice = `stop requested for ${run.runId.slice(0, 8)}\u2026`;
+    this.tui.requestRender();
+    await this.#runAction(() => this.actions.act(`run-stop:${encodeURIComponent(run.runId)}`));
+  }
+  async#pause(run) {
+    this.#notice = `pause requested for ${run.runId.slice(0, 8)}\u2026`;
+    this.tui.requestRender();
+    await this.#runAction(() => this.actions.act(`run-pause:${encodeURIComponent(run.runId)}`));
+  }
+  async#resume(run) {
+    this.#notice = `resume requested for ${run.runId.slice(0, 8)}\u2026`;
+    this.tui.requestRender();
+    await this.#runAction(() => this.actions.act(`run-resume:${encodeURIComponent(run.runId)}`));
+  }
+  async#steer(run, message) {
+    await this.#runAction(() => this.actions.act(`run-steer:${encodeURIComponent(run.runId)}`, message));
+  }
+  async#actOnItem(item) {
+    if (item.id.startsWith("to:")) {
+      const target = item.id.slice("to:".length);
+      if (isRigScreen(target, this.catalog))
+        await this.#navigate(target);
+      return;
+    }
+    if (item.id.startsWith("task-detail:") && !item.id.startsWith("task-detail:dispatch:")) {
+      this.#selectedTaskId = decodeActionValue(item.id.slice("task-detail:".length));
+      await this.#navigate("task-detail");
+      return;
+    }
+    if (item.id.startsWith("run-detail:")) {
+      this.#selectedRunId = decodeActionValue(item.id.slice("run-detail:".length));
+      await this.#navigate("run-detail");
+      return;
+    }
+    if (item.id === "detail:back") {
+      await this.#back();
+      return;
+    }
+    if (item.id === "detail:join") {
+      const run = findRunById(this.#runs, this.#selectedRunId);
+      if (run) {
+        await this.#runAction(() => this.actions.act(`run:${encodeURIComponent(run.runId)}`));
+        if (!this.#error)
+          this.done();
+      }
+      return;
+    }
+    if (item.id === "config:relayUrl" || item.id.startsWith("stats:") || item.id.startsWith("inspect:audit")) {
+      this.#notice = "informational row; no cockpit action";
+      this.tui.requestRender();
+      return;
+    }
+    if (item.id.startsWith("task-detail:dispatch:")) {
+      await this.#runAction((onProgress) => this.actions.act(item.id, undefined, onProgress));
+      if (!this.#error)
+        this.done();
+      return;
+    }
+    if (item.values && item.values.length > 0)
+      await this.#runAction((onProgress) => this.actions.act(item.id, undefined, onProgress));
+  }
+  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() {
+    for (const view of this.#domainViews.values())
+      view.invalidate();
+    this.#helpView.invalidate();
+    this.#genericView.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")
+          line.apply("");
+        this.#inputLine = null;
+      } else if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+        this.#inputLine = null;
+        if (line.kind === "steer" && line.buffer.trim())
+          this.#steer(line.run, line.buffer.trim());
+      } else if (matchesKey(data, "backspace")) {
+        const buffer = line.buffer.slice(0, -1);
+        this.#inputLine = line.kind === "search" ? { kind: "search", buffer, apply: line.apply } : { kind: "steer", buffer, run: line.run };
+        if (line.kind === "search")
+          line.apply(buffer);
+      } else if (data.length === 1 && data >= " ") {
+        const buffer = line.buffer + data;
+        this.#inputLine = line.kind === "search" ? { kind: "search", buffer, apply: line.apply } : { kind: "steer", buffer, run: line.run };
+        if (line.kind === "search")
+          line.apply(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") || data === "?")
+        this.#back();
+      else if (matchesKey(data, "escape"))
+        this.#navigate("cockpit", false);
+      this.tui.requestRender();
+      return;
+    }
+    if (this.#view === "task-detail" || this.#view === "run-detail") {
+      if (matchesKey(data, "up") || data === "k") {
+        this.#detailComposer.moveSelection(-1);
+        this.tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, "down") || data === "j") {
+        this.#detailComposer.moveSelection(1);
+        this.tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+        const action = this.#detailComposer.selectedAction();
+        if (action) {
+          if (action.id.startsWith("run-steer:")) {
+            const run = findRunById(this.#runs, this.#selectedRunId);
+            if (run) {
+              this.#inputLine = { kind: "steer", buffer: "", run: { runId: run.runId } };
+              this.tui.requestRender();
+            }
+            return;
+          }
+          if (action.id.startsWith("task-detail:dispatch:")) {
+            this.#notice = "dispatch \xB7 starting\u2026";
+            this.tui.requestRender();
+          }
+          if (action.id.startsWith("run-stop:")) {
+            this.#notice = "stop requested\u2026";
+            this.tui.requestRender();
+          }
+          this.#actOnItem({ id: action.id, label: action.label, values: [action.value ?? "go"] });
+        }
+        return;
+      }
+      if (matchesKey(data, "pageUp")) {
+        this.#detailComposer.scrollBody(-5);
+        this.tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, "pageDown") || data === " ") {
+        this.#detailComposer.scrollBody(5);
+        this.tui.requestRender();
+        return;
+      }
+      if (data === "?" || data === "h") {
+        this.#setView("help");
+        return;
+      }
+      if (matchesKey(data, "left")) {
+        this.#back();
+        return;
+      }
+      if (matchesKey(data, "escape")) {
+        this.#navigate("cockpit", false);
+        return;
+      }
+      return;
+    }
+    const domainView = this.#domainViews.get(this.#view);
+    if (domainView) {
+      if (domainView.handleInput(data))
+        return;
+      if (data === "?" || data === "h") {
+        this.#setView("help");
+        return;
+      }
+      if (data === "r") {
+        this.#runAction(async () => {});
+        return;
+      }
+      if (matchesKey(data, "left")) {
+        this.#back();
+        return;
+      }
+      if (matchesKey(data, "escape")) {
+        this.#navigate("cockpit", false);
+        return;
+      }
+    } else {
+      if (matchesKey(data, "up") || data === "k") {
+        this.#genericView.moveSelection(-1);
+        this.tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, "down") || data === "j") {
+        this.#genericView.moveSelection(1);
+        this.tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+        const item = this.#genericView.selectedItem();
+        if (item)
+          this.#actOnItem(item);
+        return;
+      }
+      if (data === "?" || data === "h") {
+        this.#setView("help");
+        return;
+      }
+      if (data === "r") {
+        this.#runAction(async () => {});
+        return;
+      }
+      if (matchesKey(data, "left")) {
+        this.#back();
+        return;
+      }
+      if (matchesKey(data, "escape")) {
+        this.#navigate("cockpit", false);
+        return;
+      }
+    }
+  }
+  dispose() {
+    const fiber = this.#discoveryFiber;
+    this.#discoveryFiber = undefined;
+    if (fiber)
+      Effect.runFork(Fiber.interrupt(fiber));
+    if (this.#animationTimer) {
+      clearInterval(this.#animationTimer);
+      this.#animationTimer = undefined;
+    }
+    this.#busyDepth = 0;
+  }
+}
+
+class FullscreenSceneProxy {
+  current;
+  onDispose;
+  constructor(current, onDispose) {
+    this.current = current;
+    this.onDispose = onDispose;
+  }
+  render() {
+    return EMPTY_SCENE_LINES;
+  }
+  handleInput(data) {
+    this.current().handleInput?.(data);
+  }
+  invalidate() {
+    this.current().invalidate?.();
+  }
+  dispose() {
+    this.onDispose();
+    this.current().dispose?.();
+  }
+}
+async function openRigFlow(api, ctx, screen, actions = defaultFlowActions(api, ctx), actionRowsEnabled = true, quitExits = false) {
+  const refreshRuns = async () => discoverRuns(ctx);
+  const refreshState = (nextScreen, selectedTaskId, runs) => loadRigFlowState(ctx, nextScreen, selectedTaskId, api, runs, actionRowsEnabled);
+  await ctx.ui.custom((tui, _theme, _keybindings, done) => {
+    let handle;
+    let finished = false;
+    const hideScene = () => {
+      handle?.hide();
+      handle = undefined;
+    };
+    const finish = () => {
+      finished = true;
+      hideScene();
+      done(undefined);
+    };
+    const onQuit = quitExits ? () => {
+      finished = true;
+      hideScene();
+      postmortem.quit(0);
+    } : finish;
+    const preloader = new DronePreloaderComponent(tui);
+    let active = preloader;
+    handle = tui.showOverlay(preloader, { width: "100%", maxHeight: "100%", anchor: "top-left", margin: 0, fullscreen: true });
+    tui.setFocus(preloader);
+    (async () => {
+      try {
+        let runLoadError = null;
+        let runs = [];
+        try {
+          runs = await refreshRuns();
+        } catch (error) {
+          runLoadError = notificationMessage(error);
+        }
+        const loadedState = await refreshState(screen, null, runs);
+        const state = runLoadError ? { ...loadedState, error: loadedState.error ? `${runLoadError}; ${loadedState.error}` : runLoadError } : loadedState;
+        await appendWorkflowStarted(api, ctx, state);
+        const { catalog, caps } = await resolveCockpitRegistry(ctx);
+        const helpRoot = state.projectRoot ?? rigProjectRoot();
+        const helpCatalogService = await loadCapabilityForRoot(helpRoot, defineCapability(HELP_CATALOG));
+        const helpHost = await resolvePluginHost(helpRoot).catch(() => null);
+        const helpCommands = helpHost?.host.listExecutableCliCommands() ?? [];
+        const helpCatalog = helpCatalogService ? helpCatalogService.helpCatalog(helpCommands) : { sections: [], groups: [] };
+        if (finished)
+          return;
+        const component = new RigFlowComponent(tui, api, finish, onQuit, screen, runs, state, refreshRuns, refreshState, actions, actionRowsEnabled, catalog, caps, helpCatalog);
+        try {
+          const panelHost = await resolvePluginHost(helpRoot).catch(() => null);
+          for (const panel of panelHost?.host.listExecutablePanels() ?? []) {
+            if (typeof panel.createView !== "function" || !panel.screen)
+              continue;
+            const view = await panel.createView(component.viewHost());
+            component.registerDomainView(panel.id, view);
+          }
+        } catch {}
+        hideScene();
+        preloader.dispose();
+        active = component;
+        handle = tui.showOverlay(component, { width: "100%", maxHeight: "100%", anchor: "top-left", margin: 0, fullscreen: true });
+        tui.setFocus(component);
+      } catch (error) {
+        if (finished)
+          return;
+        hideScene();
+        preloader.dispose();
+        ctx.ui.notify(notificationMessage(error), "error");
+        done(undefined);
+      }
+    })();
+    return new FullscreenSceneProxy(() => active, hideScene);
+  });
+}
+function launchRigFlow(api, ctx, screen, actions = defaultFlowActions(api, ctx), actionRowsEnabled = true, quitExits = false) {
+  openRigFlow(api, ctx, screen, actions, actionRowsEnabled, quitExits).catch((error) => {
+    ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+  });
+}
+async function startCockpitOrSetup(api, ctx) {
+  const actions = defaultFlowActions(api, ctx);
+  const status = await detectRigStartupStatus(ctx);
+  if (status.configured) {
+    launchRigFlow(api, ctx, "cockpit", actions, true, true);
+    return;
+  }
+  const autoSetupCompleted = await runRigAutomaticSetup(api, ctx, status);
+  if (autoSetupCompleted) {
+    launchRigFlow(api, ctx, "cockpit", actions, true, true);
+    return;
+  }
+  launchRigFlow(api, ctx, "cockpit", actions, true, true);
+}
+function rigExtension(api, panels = []) {
+  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;
+  });
+  const startupCatalog = resolveScreenCatalog(panels);
+  for (const { screen, shortcut } of screenShortcuts(startupCatalog)) {
+    const target = screen;
+    api.registerShortcut(shortcut.key, {
+      description: shortcut.description,
+      handler: async (shortcutCtx) => {
+        launchRigFlow(api, shortcutCtx, target, defaultFlowActions(api, shortcutCtx), true);
+      }
+    });
+  }
+  api.on("session_start", async (_event, ctx) => {
+    if (!ctx.hasUI)
+      return;
+    ctx.ui.setTitle("RIG");
+    await startCockpitOrSetup(api, ctx);
+  });
+  api.registerCommand("rig", {
+    description: "Open the Rig operator flow",
+    handler: async (args, ctx) => {
+      const requested = args.trim();
+      const actions = commandFlowActions(api, ctx);
+      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();
+      let screen = "cockpit";
+      try {
+        const { catalog } = await resolveCockpitRegistry(ctx);
+        if (isRigScreen(lower, catalog))
+          screen = lower;
+      } catch {}
+      launchRigFlow(api, ctx, screen, actions, true);
+    }
+  });
+}
+var UNCLASSIFIED_RUN_CLASSIFICATION, RunIdentityEnvCap, ProjectSetupCap, WorkflowJournalWriterCap, commandFlowActions, EMPTY_SCENE_LINES, __rigExtensionTest;
+var init_extension = __esm(() => {
+  init_board_views();
+  init_drone_preloader();
+  init_screen_catalog();
+  init_cockpit_product();
+  UNCLASSIFIED_RUN_CLASSIFICATION = {
+    status: "unclassified",
+    runStatus: "needs-attention",
+    phase: "unknown",
+    role: "neutral",
+    rank: Number.MAX_SAFE_INTEGER,
+    isActive: false,
+    isTerminal: false,
+    isNeedsAttention: false,
+    offersRecovery: false
+  };
+  RunIdentityEnvCap = defineCapability(RUN_IDENTITY_ENV);
+  ProjectSetupCap = defineCapability(PROJECT_SETUP);
+  WorkflowJournalWriterCap = defineCapability(RIG_WORKFLOW_JOURNAL_WRITER);
+  commandFlowActions = defaultFlowActions;
+  EMPTY_SCENE_LINES = [];
+  __rigExtensionTest = {
+    itemsFor,
+    taskDetailModel,
+    runDetailModel,
+    defaultFlowActions,
+    commandFlowActions,
+    loadRigFlowState,
+    detectRigStartupStatus,
+    inboxActionId,
+    parseInboxActionTarget,
+    runListActionHints
+  };
+});
+
+// packages/omp-extension-plugin/src/cockpit/plugin.ts
+import { definePlugin } from "@rig/core/config";
+var COCKPIT_HOST_PLUGIN_NAME = "@rig/omp-extension-plugin";
+function createCockpitHostPlugin() {
+  return definePlugin({
+    name: COCKPIT_HOST_PLUGIN_NAME,
+    version: "0.0.0",
+    effects: {
+      readsFiles: true
+    },
+    contributes: {
+      sessionExtensions: [
+        {
+          id: "rig:cockpit-product",
+          description: "Rig cockpit screen-host extension for OMP sessions.",
+          install: async (api, context) => {
+            const { default: rigExtension2 } = await Promise.resolve().then(() => (init_extension(), exports_extension));
+            return rigExtension2(api, context?.panels);
+          }
+        }
+      ]
+    }
+  });
+}
+var cockpitHostPlugin = createCockpitHostPlugin();
+var plugin_default = cockpitHostPlugin;
+export {
+  plugin_default as default,
+  createCockpitHostPlugin,
+  cockpitHostPlugin,
+  COCKPIT_HOST_PLUGIN_NAME
+};