pi-minimal 0.4.0 → 0.6.0

package/src/prs.ts

@@ -0,0 +1,348 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { hyperlink } from "@earendil-works/pi-tui"
+import { createListeners } from "./listeners.js"
+
+/**
+ * Open pull requests for the repository the session is in, via the `gh` CLI: the ones I authored
+ * and the ones waiting on my review. Shown on the status line as clickable `#1675` chips (OSC 8
+ * links), coloured by kind, and listed by `/prs`.
+ *
+ * `gh` resolves the host from the repo's remote, so GitHub.com and GitHub Enterprise both work;
+ * the viewer login is looked up per host because it differs between them.
+ */
+
+export type PrKind = "mine" | "review"
+
+export type PullRequest = {
+  number: number
+  title: string
+  url: string
+  /** `host/owner/repo`, the form `gh -R` accepts for any host. */
+  repo: string
+  author: string
+  isDraft: boolean
+  /** Why it is on my list. A PR I authored that also requests my review counts as `mine`. */
+  kind: PrKind
+  /** GitHub's review decision: APPROVED, CHANGES_REQUESTED, REVIEW_REQUIRED or empty. */
+  reviewDecision: string
+  /** Any status context or check run failed. */
+  ciFailing: boolean
+  updatedAt: string
+}
+
+export type PrRepo = {
+  /** `owner/repo` */
+  nameWithOwner: string
+  /** e.g. `github.com` */
+  host: string
+  url: string
+}
+
+export type PrSnapshot = {
+  repo?: PrRepo
+  /** The cwd repo's PRs first, then PRs created in this session elsewhere (deduped by URL). */
+  prs: PullRequest[]
+  /** Last `gh` error, when the list could not be refreshed. */
+  error?: string
+  fetchedAt?: number
+}
+
+export const PR_LIST_FIELDS = "number,title,url,isDraft,author,reviewRequests,reviewDecision,statusCheckRollup,updatedAt"
+
+/** A GitHub PR URL on any host: `https://host/owner/repo/pull/123`. */
+export const PR_URL_RE = /https?:\/\/([a-z0-9.-]+)\/([^\s/]+)\/([^\s/]+)\/pull\/(\d+)\b/gi
+
+/** Finds PR URLs in text, e.g. the output of `gh pr create`. */
+export function findPrUrls(text: string): string[] {
+  const urls = new Set<string>()
+  for (const match of text.matchAll(PR_URL_RE)) urls.add(`https://${match[1]}/${match[2]}/${match[3]}/pull/${match[4]}`)
+  return [...urls]
+}
+
+/** Repo (`host/owner/repo`) a PR URL belongs to. */
+export function prUrlRepo(url: string): string | undefined {
+  const match = new RegExp(PR_URL_RE.source, "i").exec(url)
+  return match ? `${match[1]}/${match[2]}/${match[3]}` : undefined
+}
+
+/** Commands whose output announces a PR this session created. */
+export function isPrCreateCommand(command: string): boolean {
+  return /\bgh\s+pr\s+create\b|\bgt\s+submit\b/.test(command)
+}
+
+/** Parses `gh repo view --json nameWithOwner,url`. */
+export function parseRepoView(stdout: string): PrRepo {
+  const data = JSON.parse(stdout) as { nameWithOwner?: unknown; url?: unknown }
+  if (typeof data.nameWithOwner !== "string" || typeof data.url !== "string") throw new Error("invalid gh repo view")
+  return { nameWithOwner: data.nameWithOwner, host: new URL(data.url).host, url: data.url }
+}
+
+type RawCheck = { state?: string | null; conclusion?: string | null; status?: string | null }
+type RawPr = {
+  number?: unknown
+  title?: unknown
+  url?: unknown
+  isDraft?: unknown
+  author?: { login?: unknown } | null
+  reviewRequests?: Array<{ __typename?: string; login?: unknown; slug?: unknown; name?: unknown }> | null
+  reviewDecision?: unknown
+  statusCheckRollup?: RawCheck[] | null
+  updatedAt?: unknown
+}
+
+const FAILED_STATES = new Set(["FAILURE", "ERROR"])
+const FAILED_CONCLUSIONS = new Set(["FAILURE", "TIMED_OUT", "CANCELLED", "ACTION_REQUIRED", "STARTUP_FAILURE"])
+
+export function ciFailing(checks: RawCheck[] | null | undefined): boolean {
+  return (checks ?? []).some(
+    (check) => FAILED_STATES.has(check.state ?? "") || FAILED_CONCLUSIONS.has(check.conclusion ?? ""),
+  )
+}
+
+function toPullRequest(raw: RawPr, repo: string, kind: PrKind): PullRequest | undefined {
+  if (typeof raw.number !== "number" || typeof raw.url !== "string") return undefined
+  return {
+    number: raw.number,
+    title: typeof raw.title === "string" ? raw.title : "",
+    url: raw.url,
+    repo,
+    author: typeof raw.author?.login === "string" ? raw.author.login : "",
+    isDraft: raw.isDraft === true,
+    kind,
+    reviewDecision: typeof raw.reviewDecision === "string" ? raw.reviewDecision : "",
+    ciFailing: ciFailing(raw.statusCheckRollup),
+    updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : "",
+  }
+}
+
+/** Parses `gh pr view URL --json …` for a PR this session created (always `mine`). */
+export function parsePrView(stdout: string, url: string): PullRequest | undefined {
+  const raw = JSON.parse(stdout) as RawPr & { state?: unknown }
+  if (raw.state !== undefined && raw.state !== "OPEN") return undefined
+  const repo = prUrlRepo(url)
+  return repo ? toPullRequest(raw, repo, "mine") : undefined
+}
+
+/**
+ * Parses `gh pr list --json …` for `involves:@me` into my PRs: authored by `login`, or requesting
+ * my review (directly; team requests are included when `teams` lists my team slugs). Others I'm
+ * merely mentioned on are dropped.
+ */
+export function parsePrList(stdout: string, repo: PrRepo, login: string, teams: readonly string[] = []): PullRequest[] {
+  const data = JSON.parse(stdout) as RawPr[]
+  if (!Array.isArray(data)) throw new Error("invalid gh pr list")
+  const teamSet = new Set(teams.map((team) => team.toLowerCase()))
+  const prs: PullRequest[] = []
+  for (const raw of data) {
+    const author = typeof raw.author?.login === "string" ? raw.author.login : ""
+    const requested = (raw.reviewRequests ?? []).some((request) => {
+      if (typeof request.login === "string") return request.login.toLowerCase() === login.toLowerCase()
+      const slug = typeof request.slug === "string" ? request.slug : typeof request.name === "string" ? request.name : ""
+      return teamSet.has(slug.toLowerCase())
+    })
+    const mine = author.toLowerCase() === login.toLowerCase()
+    if (!mine && !requested) continue
+    const pr = toPullRequest(raw, `${repo.host}/${repo.nameWithOwner}`, mine ? "mine" : "review")
+    if (pr) prs.push(pr)
+  }
+  // Review requests first (they need me), then mine; newest first within each.
+  prs.sort((a, b) => (a.kind === b.kind ? (a.updatedAt < b.updatedAt ? 1 : -1) : a.kind === "review" ? -1 : 1))
+  return prs
+}
+
+export type PrColor = "accent" | "dim" | "warning" | "error"
+
+/** Chip colour: trouble (failing CI, changes requested) wins, then review requests, then drafts. */
+export function prColor(pr: PullRequest): PrColor {
+  if (pr.ciFailing || pr.reviewDecision === "CHANGES_REQUESTED") return "error"
+  if (pr.kind === "review") return "warning"
+  if (pr.isDraft) return "dim"
+  return "accent"
+}
+
+export const PR_LEGEND = "#n mine · dim draft · amber needs my review · red failing CI / changes requested"
+
+type Theme = { fg(color: string, text: string): string }
+
+/** `#1675` inside the cwd repo; `repo#1675` for a PR elsewhere (created in this session) or when cwd is no repo. */
+export function prChipLabel(pr: PullRequest, cwdRepo?: string): string {
+  if (cwdRepo && pr.repo === cwdRepo) return `#${pr.number}`
+  return `${pr.repo.split("/").pop()}#${pr.number}`
+}
+
+/** Footer segment: `#1675 #1670 +3` with each number an OSC 8 link; undefined when empty. */
+export function prSegment(prs: PullRequest[], theme: Theme, max = 4, cwdRepo?: string): string | undefined {
+  if (prs.length === 0) return undefined
+  const shown = prs.slice(0, max)
+  const chips = shown.map((pr) => theme.fg(prColor(pr), hyperlink(prChipLabel(pr, cwdRepo), pr.url)))
+  const rest = prs.length - shown.length
+  if (rest > 0) chips.push(theme.fg("dim", `+${rest}`))
+  return chips.join(" ")
+}
+
+export function describePr(pr: PullRequest, cwdRepo?: string): string {
+  const flags = [
+    pr.kind === "review" ? "review requested" : pr.isDraft ? "draft" : "mine",
+    pr.ciFailing ? "CI failing" : undefined,
+    pr.reviewDecision === "CHANGES_REQUESTED" ? "changes requested" : pr.reviewDecision === "APPROVED" ? "approved" : undefined,
+  ].filter(Boolean)
+  return `${prChipLabel(pr, cwdRepo)}  ${pr.title}  · ${flags.join(" · ")}${pr.kind === "review" ? ` · @${pr.author}` : ""}`
+}
+
+export type PrSource = {
+  get(): PrSnapshot
+  onChange(listener: () => void): () => void
+  /** Re-fetch now (throttled unless `force`). */
+  refresh(force?: boolean): Promise<void>
+  /** Remember a PR this session created (any repo); it is shown until it is no longer open. */
+  addSessionPr(url: string): void
+  /** URLs remembered via addSessionPr, for persistence. */
+  sessionPrs(): string[]
+  dispose(): void
+}
+
+export type PrSourceDeps = {
+  pi: ExtensionAPI
+  cwd: () => string
+  /** PR URLs restored from a previous run of this session. */
+  sessionPrs?: readonly string[]
+  now?: () => number
+  /** Poll period; 3 min by default. */
+  pollMs?: number
+  /** Minimum gap between refreshes triggered by events. */
+  minIntervalMs?: number
+}
+
+const GH_TIMEOUT_MS = 15_000
+const DEFAULT_POLL_MS = 3 * 60_000
+const DEFAULT_MIN_INTERVAL_MS = 60_000
+
+export function createPrSource(deps: PrSourceDeps): PrSource {
+  const now = deps.now ?? Date.now
+  const pollMs = deps.pollMs ?? DEFAULT_POLL_MS
+  const minIntervalMs = deps.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS
+  const listeners = createListeners()
+  let alive = true
+  let state: PrSnapshot = { prs: [] }
+  let inFlight: Promise<void> | undefined
+  let timer: ReturnType<typeof setTimeout> | undefined
+  let lastRun = 0
+  const logins = new Map<string, string>()
+  const session = new Set<string>(deps.sessionPrs ?? [])
+
+  // Only what is displayed counts as a change; a refresh that confirms the same list is silent.
+  const visible = (snap: PrSnapshot) => JSON.stringify([snap.repo, snap.prs, snap.error])
+  const set = (next: PrSnapshot) => {
+    const changed = visible(next) !== visible(state)
+    state = next
+    if (changed) listeners.notify()
+  }
+
+  const gh = (args: string[]) => deps.pi.exec("gh", args, { cwd: deps.cwd(), timeout: GH_TIMEOUT_MS })
+
+  const viewerLogin = async (host: string): Promise<string | undefined> => {
+    const cached = logins.get(host)
+    if (cached) return cached
+    const run = await gh(["api", "--hostname", host, "user", "--jq", ".login"])
+    if (run.code !== 0) return undefined
+    const login = run.stdout.trim()
+    if (login) logins.set(host, login)
+    return login || undefined
+  }
+
+  /** PRs this session created, wherever they live; a merged or closed one is forgotten. */
+  const fetchSessionPrs = async (exclude: Set<string>): Promise<PullRequest[]> => {
+    const extra = await Promise.all(
+      [...session].filter((url) => !exclude.has(url)).map(async (url) => {
+        const view = await gh(["pr", "view", url, "--json", `${PR_LIST_FIELDS},state`])
+        if (view.code !== 0) return undefined
+        try {
+          const pr = parsePrView(view.stdout, url)
+          if (!pr) session.delete(url)
+          return pr
+        } catch {
+          return undefined
+        }
+      }),
+    )
+    return extra.filter((pr): pr is PullRequest => pr !== undefined)
+  }
+
+  const fetchOnce = async (): Promise<void> => {
+    let repo = state.repo
+    let repoError: string | undefined
+    try {
+      if (!repo) {
+        const view = await gh(["repo", "view", "--json", "nameWithOwner,url"])
+        if (!alive) return
+        if (view.code === 0) repo = parseRepoView(view.stdout)
+        else repoError = view.stderr.trim() || "gh repo view failed"
+      }
+      let prs: PullRequest[] = []
+      let error = repoError
+      if (repo) {
+        const login = await viewerLogin(repo.host)
+        if (!alive) return
+        if (!login) {
+          error = `gh is not authenticated for ${repo.host}`
+        } else {
+          const list = await gh([
+            "pr", "list", "-R", `${repo.host}/${repo.nameWithOwner}`, "--state", "open", "--limit", "100",
+            "--search", "involves:@me", "--json", PR_LIST_FIELDS,
+          ])
+          if (!alive) return
+          if (list.code !== 0) error = list.stderr.trim() || "gh pr list failed"
+          else prs = parsePrList(list.stdout, repo, login)
+        }
+      }
+      // Outside a GitHub repo, or when the list failed, the session's own PRs still show.
+      prs.push(...(await fetchSessionPrs(new Set(prs.map((pr) => pr.url)))))
+      if (!alive) return
+      set({ repo, prs: error && prs.length === 0 && state.prs.length > 0 ? state.prs : prs, error, fetchedAt: now() })
+    } catch (error) {
+      if (!alive) return
+      set({ repo, prs: state.prs, error: error instanceof Error ? error.message : String(error), fetchedAt: state.fetchedAt })
+    }
+  }
+
+  const schedule = () => {
+    if (!alive) return
+    if (timer) clearTimeout(timer)
+    timer = setTimeout(() => { void refresh(true) }, pollMs)
+    timer.unref?.()
+  }
+
+  const refresh = (force = false): Promise<void> => {
+    if (!alive) return Promise.resolve()
+    if (inFlight) return inFlight
+    if (!force && now() - lastRun < minIntervalMs) return Promise.resolve()
+    lastRun = now()
+    inFlight = fetchOnce().finally(() => {
+      inFlight = undefined
+      schedule()
+    })
+    return inFlight
+  }
+
+  void refresh(true)
+
+  return {
+    get: () => state,
+    onChange: listeners.add,
+    refresh,
+    addSessionPr(url) {
+      const found = findPrUrls(url)[0]
+      if (!found || session.has(found)) return
+      session.add(found)
+      void refresh(true)
+    },
+    sessionPrs: () => [...session],
+    dispose() {
+      if (!alive) return
+      alive = false
+      if (timer) clearTimeout(timer)
+      timer = undefined
+      listeners.clear()
+    },
+  }
+}

package/src/reclaim.ts

@@ -1,7 +1,6 @@
 export type ReclaimReason =
   | "session_start"
   | "session_settle"
-  | "interval"
   | "turn_end"
   | "tool_execution_end"
 
@@ -14,9 +13,6 @@ export function reclaimPolicy(reason: ReclaimReason): ReclaimPolicy {
   if (reason === "session_start") {
     return { resetEditor: true, reinstallChrome: true }
   }
-  if (reason === "interval") {
-    return { resetEditor: false, reinstallChrome: false }
-  }
   // session_settle / turn_end / tool_execution_end: restore chrome, keep editor
   return { resetEditor: false, reinstallChrome: true }
 }

package/src/rex.ts

@@ -0,0 +1,304 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { spawn as nodeSpawn, type ChildProcess } from "node:child_process"
+import { createInterface } from "node:readline"
+import { createListeners } from "./listeners.js"
+import type { Sibling, SiblingSource } from "./siblings.js"
+
+/**
+ * Rex siblings: other panes in the same Rex session whose program reports status with the
+ * Program Status Protocol (OSC 7501), e.g. another pi with the rex-agent-state extension, or
+ * claude-code / terraform. The pi in this pane is excluded by `REX_BLOCK`.
+ *
+ * Rex pushes status changes over `rex events -s SESSION --json`, so this source keeps one child
+ * process instead of polling every pane; it only shells out again to seed on start and to refresh
+ * tab labels / the block→tab map when the layout changes.
+ */
+
+export type RexStatusRecord = {
+  state: string
+  app?: string
+  msg?: string
+}
+
+export type RexLayout = {
+  /** window_id → tab label */
+  tabs: Map<string, string>
+  /** block_id → window_id, terminal blocks only */
+  blocks: Map<string, string>
+}
+
+export type RexState = {
+  layout: RexLayout
+  /** block_id → root status record */
+  status: Map<string, RexStatusRecord>
+}
+
+export function createRexState(): RexState {
+  return { layout: { tabs: new Map(), blocks: new Map() }, status: new Map() }
+}
+
+const TERMINAL_CREATOR = "com.superlogical.terminal"
+
+/** Parses `rex window ls -s SESSION --json`. */
+export function parseWindowList(stdout: string): RexLayout {
+  const data = JSON.parse(stdout) as {
+    windows?: Array<{
+      window_id?: unknown
+      label?: unknown
+      layers?: Array<{ blocks?: Array<{ block_id?: unknown; creator_name?: unknown }> }>
+    }>
+  }
+  if (!Array.isArray(data.windows)) throw new Error("invalid rex window list")
+  const layout: RexLayout = { tabs: new Map(), blocks: new Map() }
+  for (const window of data.windows) {
+    const windowId = typeof window.window_id === "string" ? window.window_id : undefined
+    if (!windowId) continue
+    layout.tabs.set(windowId, typeof window.label === "string" ? window.label : "")
+    for (const layer of window.layers ?? []) {
+      for (const block of layer.blocks ?? []) {
+        if (typeof block.block_id !== "string") continue
+        if (block.creator_name !== undefined && block.creator_name !== TERMINAL_CREATOR) continue
+        layout.blocks.set(block.block_id, windowId)
+      }
+    }
+  }
+  return layout
+}
+
+/** Parses `rex block call -b BLOCK program_status`; returns the root record, if any. */
+export function parseProgramStatus(stdout: string): RexStatusRecord | undefined {
+  const data = JSON.parse(stdout) as { records?: Array<Record<string, unknown>> }
+  if (!Array.isArray(data.records)) throw new Error("invalid rex program status")
+  const root = data.records.find((record) => record.id === undefined || record.id === "")
+  return root ? toRecord(root) : undefined
+}
+
+function toRecord(raw: Record<string, unknown>): RexStatusRecord | undefined {
+  if (typeof raw.state !== "string") return undefined
+  const record: RexStatusRecord = { state: raw.state }
+  const app = typeof raw.effective_app === "string" ? raw.effective_app : typeof raw.app === "string" ? raw.app : undefined
+  if (app) record.app = app
+  if (typeof raw.msg === "string") record.msg = raw.msg
+  return record
+}
+
+export type RexEventEffect = "status" | "layout" | undefined
+
+/**
+ * Applies one line of `rex events --json` to the state. Returns what changed: `status` (a pane's
+ * record) or `layout` (the caller should re-read the window list). Unknown events are ignored.
+ */
+export function applyRexEvent(state: RexState, line: string): RexEventEffect {
+  // Shape: {"type":"session_event","payload":{"session_id":…,"event":{"type":…,"payload":{…}}}}
+  let outer: { type?: unknown; payload?: { event?: { type?: unknown; payload?: Record<string, unknown> } } }
+  try {
+    outer = JSON.parse(line)
+  } catch {
+    return undefined
+  }
+  if (outer.type !== "session_event") return undefined
+  const event = outer.payload?.event
+  const payload = event?.payload ?? {}
+  switch (event?.type) {
+    case "block_event": {
+      const blockId = payload.block_id
+      if (typeof blockId !== "string") return undefined
+      const inner = (payload.payload ?? {}) as Record<string, unknown>
+      if (payload.name === "program_status_changed") {
+        if (inner.id !== "" && inner.id !== undefined) return undefined
+        const record = toRecord((inner.record ?? {}) as Record<string, unknown>)
+        if (!record) return undefined
+        state.status.set(blockId, record)
+        return "status"
+      }
+      if (payload.name === "program_status_removed") {
+        const ids = Array.isArray(inner.ids) ? inner.ids : []
+        if (!ids.includes("")) return undefined
+        return state.status.delete(blockId) ? "status" : undefined
+      }
+      return undefined
+    }
+    case "block_closed": {
+      const blockId = payload.block_id
+      if (typeof blockId !== "string") return undefined
+      state.status.delete(blockId)
+      state.layout.blocks.delete(blockId)
+      return "layout"
+    }
+    case "block_created":
+    case "window_label_changed":
+    case "window_created":
+    case "window_closed":
+    case "session_label_changed":
+      return "layout"
+    default:
+      return undefined
+  }
+}
+
+/** A Rex auto-label such as `Window 395a96cb` says nothing about the work; prefer the program. */
+const AUTO_LABEL = /^Window [0-9a-f]+$/i
+
+/**
+ * Siblings are named after their tab, like Herdr siblings. A pane in the same tab as this pi
+ * would share our tab's name, so it is named after its program instead.
+ */
+export function listRexSiblings(state: RexState, selfBlock?: string): Sibling[] | undefined {
+  if (!selfBlock) return undefined
+  const selfWindow = state.layout.blocks.get(selfBlock)
+  const parts: Sibling[] = []
+  for (const [blockId, record] of state.status) {
+    if (blockId === selfBlock) continue
+    const windowId = state.layout.blocks.get(blockId)
+    const label = windowId && windowId !== selfWindow ? state.layout.tabs.get(windowId) : undefined
+    const name = label && !AUTO_LABEL.test(label) ? label : record.app
+    if (!name) continue
+    parts.push({ name, status: record.state })
+  }
+  if (parts.length === 0) return undefined
+  return parts
+}
+
+export type RexSpawn = (command: string, args: string[]) => Pick<ChildProcess, "stdout" | "stderr" | "kill" | "on" | "once">
+
+export type RexSiblingsDeps = {
+  pi: ExtensionAPI
+  env?: NodeJS.ProcessEnv
+  spawn?: RexSpawn
+}
+
+const REX_EXEC_TIMEOUT_MS = 3000
+const REX_RESTART_MS = 10000
+const REX_LAYOUT_DEBOUNCE_MS = 150
+
+export function createRexSiblings(deps: RexSiblingsDeps): SiblingSource {
+  const env = deps.env ?? process.env
+  const spawn: RexSpawn = deps.spawn ?? ((command, args) => nodeSpawn(command, args, { stdio: ["ignore", "pipe", "pipe"] }))
+  const session = env.REX_SESSION ?? ""
+  const selfBlock = env.REX_BLOCK
+  let alive = true
+  let child: ReturnType<RexSpawn> | undefined
+  let restartTimer: ReturnType<typeof setTimeout> | undefined
+  let layoutTimer: ReturnType<typeof setTimeout> | undefined
+  let layoutInFlight = false
+  let layoutDirty = false
+  let siblings: Sibling[] | undefined
+  const state = createRexState()
+  const listeners = createListeners()
+
+  const recompute = () => {
+    if (!alive) return
+    const next = listRexSiblings(state, selfBlock)
+    const changed = JSON.stringify(next) !== JSON.stringify(siblings)
+    siblings = next
+    if (changed) listeners.notify()
+  }
+
+  const refreshLayout = async (seedStatus: boolean) => {
+    if (!alive) return
+    if (layoutInFlight) { layoutDirty = true; return }
+    layoutInFlight = true
+    try {
+      const run = await deps.pi.exec("rex", ["window", "ls", "-s", session, "--json"], { timeout: REX_EXEC_TIMEOUT_MS })
+      if (!alive) return
+      if (run.code !== 0 || run.killed) return
+      const layout = parseWindowList(run.stdout)
+      state.layout = layout
+      for (const blockId of [...state.status.keys()]) {
+        if (!layout.blocks.has(blockId)) state.status.delete(blockId)
+      }
+      if (seedStatus) {
+        await Promise.all(
+          [...layout.blocks.keys()]
+            .filter((blockId) => blockId !== selfBlock)
+            .map(async (blockId) => {
+              try {
+                const status = await deps.pi.exec("rex", ["block", "call", "-s", session, "-b", blockId, "program_status"], { timeout: REX_EXEC_TIMEOUT_MS })
+                if (!alive || status.code !== 0 || status.killed) return
+                const record = parseProgramStatus(status.stdout)
+                if (record) state.status.set(blockId, record)
+                else state.status.delete(blockId)
+              } catch {
+                // A pane that vanished mid-seed shows up via events later.
+              }
+            }),
+        )
+      }
+      recompute()
+    } catch {
+      // Keep the last known layout; the next layout event retries.
+    } finally {
+      layoutInFlight = false
+      if (layoutDirty && alive) {
+        layoutDirty = false
+        void refreshLayout(false)
+      }
+    }
+  }
+
+  const scheduleLayoutRefresh = () => {
+    if (!alive || layoutTimer) return
+    layoutTimer = setTimeout(() => {
+      layoutTimer = undefined
+      void refreshLayout(false)
+    }, REX_LAYOUT_DEBOUNCE_MS)
+  }
+
+  const start = () => {
+    if (!alive) return
+    restartTimer = undefined
+    let proc: ReturnType<RexSpawn>
+    try {
+      proc = spawn("rex", ["events", "-s", session, "--json"])
+    } catch {
+      scheduleRestart()
+      return
+    }
+    child = proc
+    if (proc.stdout) {
+      const lines = createInterface({ input: proc.stdout })
+      lines.on("line", (line) => {
+        if (!alive || child !== proc) return
+        const effect = applyRexEvent(state, line)
+        if (effect === "status") recompute()
+        else if (effect === "layout") { recompute(); scheduleLayoutRefresh() }
+      })
+    }
+    proc.on("error", () => { if (child === proc) onExit() })
+    proc.on("exit", () => { if (child === proc) onExit() })
+    void refreshLayout(true)
+  }
+
+  const onExit = () => {
+    child = undefined
+    if (!alive) return
+    state.status.clear()
+    recompute()
+    scheduleRestart()
+  }
+
+  const scheduleRestart = () => {
+    if (!alive || restartTimer) return
+    restartTimer = setTimeout(start, REX_RESTART_MS)
+  }
+
+  start()
+
+  return {
+    get: () => siblings,
+    onChange: listeners.add,
+    dispose() {
+      if (!alive) return
+      alive = false
+      if (restartTimer) clearTimeout(restartTimer)
+      if (layoutTimer) clearTimeout(layoutTimer)
+      restartTimer = undefined
+      layoutTimer = undefined
+      const proc = child
+      child = undefined
+      try { proc?.kill() } catch { /* already gone */ }
+      siblings = undefined
+      listeners.clear()
+    },
+  }
+}