pi-minimal 0.5.0 → 0.6.0

package/src/background-overlay.ts

@@ -0,0 +1,103 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui"
+import type { BackgroundProcess, BackgroundSnapshot, BackgroundTracker } from "./background.js"
+import { formatElapsed } from "./working-status.js"
+
+export type BackgroundRow = {
+  pid: number
+  command: string
+  status: "running" | "ended"
+  /** Running: time since start. Ended: how long it ran. */
+  durationMs: number
+}
+
+export function backgroundRows(snap: BackgroundSnapshot, now: number): BackgroundRow[] {
+  const row = (proc: BackgroundProcess): BackgroundRow => ({
+    pid: proc.pid,
+    command: proc.command,
+    status: proc.endedAt === undefined ? "running" : "ended",
+    durationMs: (proc.endedAt ?? now) - proc.startedAt,
+  })
+  return [...snap.running.map(row), ...snap.ended.map(row)]
+}
+
+/** Status-line segment: `⚙ 2 bg`; undefined when nothing is running. */
+export function backgroundSegment(snap: BackgroundSnapshot): string | undefined {
+  if (snap.running.length === 0) return undefined
+  return `⚙ ${snap.running.length} bg`
+}
+
+type Theme = { fg(color: string, text: string): string }
+
+/** Lines of the overlay body for a given width; pure so it can be tested without a TUI. */
+export function renderBackgroundLines(rows: BackgroundRow[], selected: number, width: number, theme: Theme, shortcut?: string): string[] {
+  const title = theme.fg("accent", "Background processes")
+  const hint = theme.fg("dim", shortcut ? `↑↓ select · k kill · K kill group · esc close (${shortcut})` : "↑↓ select · k kill · K kill group · esc close")
+  if (rows.length === 0) {
+    return [title, theme.fg("muted", "Nothing running in the background."), hint].map((line) => truncateToWidth(line, width))
+  }
+  const statusWidth = 7
+  const durations = rows.map((row) => (row.status === "running" ? formatElapsed(row.durationMs) : `ran ${formatElapsed(row.durationMs)}`))
+  const durationWidth = Math.max(...durations.map((text) => text.length))
+  const commandWidth = Math.max(8, width - 2 - 1 - statusWidth - 2 - durationWidth)
+  const lines = rows.map((row, index) => {
+    const marker = index === selected ? theme.fg("accent", "› ") : "  "
+    const command = truncateToWidth(row.command, commandWidth, "…").padEnd(commandWidth)
+    const status = row.status === "running" ? theme.fg("success", "running") : theme.fg("muted", "ended  ")
+    const duration = theme.fg("dim", (durations[index] ?? "").padStart(durationWidth))
+    const text = `${marker}${index === selected ? theme.fg("text", command) : theme.fg("muted", command)} ${status}  ${duration}`
+    return visibleWidth(text) > width ? truncateToWidth(text, width) : text
+  })
+  return [title, ...lines, hint]
+}
+
+/** Shows the overlay until the user closes it. Resolves when closed. */
+export async function showBackgroundOverlay(ctx: ExtensionContext, tracker: BackgroundTracker, shortcut?: string): Promise<void> {
+  if (ctx.mode !== "tui") {
+    const rows = backgroundRows(tracker.get(), Date.now())
+    ctx.ui.notify(rows.length === 0 ? "Nothing running in the background." : rows.map((row) => `${row.pid} ${row.status} ${formatElapsed(row.durationMs)} ${row.command}`).join("\n"), "info")
+    return
+  }
+  await ctx.ui.custom<void>(
+    (tui, theme, keybindings, done) => {
+      let selected = 0
+      let cached: { width: number; lines: string[] } | undefined
+      const invalidate = () => { cached = undefined }
+      const redraw = () => { invalidate(); tui.requestRender() }
+      const unsubscribe = tracker.onChange(redraw)
+      const ticker = setInterval(redraw, 1000)
+      const rows = () => backgroundRows(tracker.get(), Date.now())
+      const finish = () => {
+        clearInterval(ticker)
+        unsubscribe()
+        done()
+      }
+      return {
+        render(width: number): string[] {
+          if (cached && cached.width === width) return cached.lines
+          const current = rows()
+          if (selected >= current.length) selected = Math.max(0, current.length - 1)
+          cached = { width, lines: renderBackgroundLines(current, selected, width, theme, shortcut) }
+          return cached.lines
+        },
+        handleInput(data: string): void {
+          const current = rows()
+          if (keybindings.matches(data, "tui.select.cancel")) { finish(); return }
+          if (keybindings.matches(data, "tui.select.up")) selected = current.length === 0 ? 0 : (selected - 1 + current.length) % current.length
+          else if (keybindings.matches(data, "tui.select.down")) selected = current.length === 0 ? 0 : (selected + 1) % current.length
+          else if (data === "k" || data === "K") {
+            const row = current[selected]
+            if (row?.status === "running") tracker.kill(row.pid, { group: data === "K" })
+          } else return
+          redraw()
+        },
+        invalidate,
+        dispose() {
+          clearInterval(ticker)
+          unsubscribe()
+        },
+      }
+    },
+    { overlay: true, overlayOptions: { width: "70%", maxHeight: "60%", anchor: "center" } },
+  )
+}

package/src/background.ts

@@ -0,0 +1,250 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { createListeners } from "./listeners.js"
+
+/**
+ * Background processes: programs a `bash` tool call left running after it returned (`npm run dev &`,
+ * `nohup ./watch.sh`). Pi spawns every bash call detached in its own process group, so whatever the
+ * shell leaves behind keeps that group's id after the shell exits and is reparented to pid 1.
+ *
+ * Attribution needs no command rewriting: snapshot `ps` when the call starts and when it ends; a
+ * process that is new, orphaned (ppid 1) and belongs to a group whose leader was born and died inside
+ * the call came from that call's shell. Tracked groups are then polled until they are empty.
+ * Pi kills these groups when it exits, so "background" means "alive while this pi is".
+ */
+
+export type PsEntry = {
+  pid: number
+  ppid: number
+  pgid: number
+  /** Seconds since the process started, from `etime`. */
+  elapsedSec: number
+  command: string
+}
+
+export type BackgroundProcess = {
+  pid: number
+  pgid: number
+  command: string
+  /** Wall-clock ms when the process started (derived from etime at first sight). */
+  startedAt: number
+  /** Wall-clock ms when it was first seen gone; undefined while running. */
+  endedAt?: number
+}
+
+export type BackgroundSnapshot = {
+  running: BackgroundProcess[]
+  /** Recently ended, newest first; kept for ENDED_TTL_MS. */
+  ended: BackgroundProcess[]
+}
+
+export const PS_ARGS = ["-ax", "-o", "pid=,ppid=,pgid=,etime=,command="]
+const ENDED_TTL_MS = 60_000
+const POLL_MS = 2000
+const PS_TIMEOUT_MS = 3000
+
+/** Parses `etime` (`SS`, `MM:SS`, `HH:MM:SS`, `DD-HH:MM:SS`) into seconds. */
+export function parseEtime(text: string): number {
+  const [daysPart, clock] = text.includes("-") ? text.split("-", 2) : [undefined, text]
+  const parts = (clock ?? "").split(":").map((part) => Number.parseInt(part, 10))
+  if (parts.some((part) => !Number.isFinite(part))) return 0
+  let seconds = 0
+  for (const part of parts) seconds = seconds * 60 + part
+  const days = daysPart === undefined ? 0 : Number.parseInt(daysPart, 10)
+  return seconds + (Number.isFinite(days) ? days : 0) * 86400
+}
+
+/** Parses `ps -ax -o pid=,ppid=,pgid=,etime=,command=` output. */
+export function parsePs(stdout: string): Map<number, PsEntry> {
+  const entries = new Map<number, PsEntry>()
+  for (const line of stdout.split("\n")) {
+    const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(line)
+    if (!match) continue
+    const pid = Number(match[1])
+    entries.set(pid, {
+      pid,
+      ppid: Number(match[2]),
+      pgid: Number(match[3]),
+      elapsedSec: parseEtime(match[4] ?? ""),
+      command: (match[5] ?? "").trim(),
+    })
+  }
+  return entries
+}
+
+/**
+ * Process groups a finished tool call left behind: processes present only in `after`, orphaned
+ * (ppid 1), whose group leader is a pid that did not exist in `before` and is gone in `after`.
+ * Any group that was alive before the call, or whose leader still runs, belongs to someone else.
+ */
+export function findOrphanGroups(before: Map<number, PsEntry>, after: Map<number, PsEntry>): Set<number> {
+  const groupsBefore = new Set<number>()
+  for (const entry of before.values()) groupsBefore.add(entry.pgid)
+  const groups = new Set<number>()
+  for (const [pid, entry] of after) {
+    if (before.has(pid) || entry.ppid !== 1) continue
+    if (groupsBefore.has(entry.pgid) || after.has(entry.pgid)) continue
+    groups.add(entry.pgid)
+  }
+  return groups
+}
+
+export type BackgroundState = {
+  groups: Set<number>
+  processes: Map<number, BackgroundProcess>
+}
+
+export function createBackgroundState(): BackgroundState {
+  return { groups: new Set(), processes: new Map() }
+}
+
+/**
+ * Reconciles tracked processes with a fresh `ps` listing: records new members of tracked groups,
+ * marks vanished ones ended, forgets ended ones after their TTL, and drops empty groups.
+ * Returns whether anything changed.
+ */
+export function applyPoll(state: BackgroundState, ps: Map<number, PsEntry>, now: number): boolean {
+  let changed = false
+  const seen = new Set<number>()
+  for (const entry of ps.values()) {
+    if (!state.groups.has(entry.pgid) || entry.pid === entry.pgid) continue
+    seen.add(entry.pid)
+    const known = state.processes.get(entry.pid)
+    if (known && known.endedAt === undefined) continue
+    state.processes.set(entry.pid, {
+      pid: entry.pid,
+      pgid: entry.pgid,
+      command: entry.command,
+      startedAt: now - entry.elapsedSec * 1000,
+    })
+    changed = true
+  }
+  for (const [pid, proc] of state.processes) {
+    if (seen.has(pid)) continue
+    if (proc.endedAt === undefined) {
+      proc.endedAt = now
+      changed = true
+    } else if (now - proc.endedAt > ENDED_TTL_MS) {
+      state.processes.delete(pid)
+      changed = true
+    }
+  }
+  for (const pgid of state.groups) {
+    const live = [...state.processes.values()].some((proc) => proc.pgid === pgid)
+    if (!live) {
+      state.groups.delete(pgid)
+      changed = true
+    }
+  }
+  return changed
+}
+
+export function snapshot(state: BackgroundState): BackgroundSnapshot {
+  const running: BackgroundProcess[] = []
+  const ended: BackgroundProcess[] = []
+  for (const proc of state.processes.values()) (proc.endedAt === undefined ? running : ended).push(proc)
+  running.sort((a, b) => a.startedAt - b.startedAt)
+  ended.sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0))
+  return { running, ended }
+}
+
+export type BackgroundTracker = {
+  get(): BackgroundSnapshot
+  onChange(listener: () => void): () => void
+  toolStart(toolCallId: string, toolName: string): void
+  toolEnd(toolCallId: string, toolName: string): void
+  /** SIGTERM one process (or its whole group with `group: true`). */
+  kill(pid: number, options?: { group?: boolean; signal?: NodeJS.Signals }): boolean
+  dispose(): void
+}
+
+export type BackgroundTrackerDeps = {
+  pi: ExtensionAPI
+  now?: () => number
+  killProcess?: (pid: number, signal: NodeJS.Signals) => void
+  /** Tool names whose calls are inspected; defaults to pi's shell tools. */
+  tools?: readonly string[]
+}
+
+export function createBackgroundTracker(deps: BackgroundTrackerDeps): BackgroundTracker {
+  const now = deps.now ?? Date.now
+  const killProcess = deps.killProcess ?? ((pid, signal) => process.kill(pid, signal))
+  const tools = new Set(deps.tools ?? ["bash", "powershell"])
+  const state = createBackgroundState()
+  const listeners = createListeners()
+  const starts = new Map<string, Promise<Map<number, PsEntry> | undefined>>()
+  let alive = true
+  let timer: ReturnType<typeof setTimeout> | undefined
+  let polling = false
+
+  const listProcesses = async (): Promise<Map<number, PsEntry> | undefined> => {
+    try {
+      const run = await deps.pi.exec("ps", PS_ARGS, { timeout: PS_TIMEOUT_MS })
+      if (run.code !== 0 || run.killed) return undefined
+      return parsePs(run.stdout)
+    } catch {
+      return undefined
+    }
+  }
+
+  const schedule = () => {
+    if (!alive || timer || state.groups.size === 0) return
+    timer = setTimeout(() => {
+      timer = undefined
+      void poll()
+    }, POLL_MS)
+  }
+
+  const poll = async () => {
+    if (!alive || polling) return
+    polling = true
+    try {
+      const ps = await listProcesses()
+      if (!alive) return
+      if (ps && applyPoll(state, ps, now())) listeners.notify()
+    } finally {
+      polling = false
+      schedule()
+    }
+  }
+
+  return {
+    get: () => snapshot(state),
+    onChange: listeners.add,
+    toolStart(toolCallId, toolName) {
+      if (!alive || !tools.has(toolName)) return
+      starts.set(toolCallId, listProcesses())
+    },
+    toolEnd(toolCallId, toolName) {
+      const before = starts.get(toolCallId)
+      starts.delete(toolCallId)
+      if (!alive || !before || !tools.has(toolName)) return
+      void (async () => {
+        const [beforePs, afterPs] = await Promise.all([before, listProcesses()])
+        if (!alive || !beforePs || !afterPs) return
+        const groups = findOrphanGroups(beforePs, afterPs)
+        if (groups.size === 0) return
+        for (const pgid of groups) state.groups.add(pgid)
+        if (applyPoll(state, afterPs, now())) listeners.notify()
+        schedule()
+      })()
+    },
+    kill(pid, options = {}) {
+      const proc = state.processes.get(pid)
+      if (!proc) return false
+      try {
+        killProcess(options.group ? -proc.pgid : pid, options.signal ?? "SIGTERM")
+        return true
+      } catch {
+        return false
+      }
+    },
+    dispose() {
+      if (!alive) return
+      alive = false
+      if (timer) clearTimeout(timer)
+      timer = undefined
+      starts.clear()
+      listeners.clear()
+    },
+  }
+}

package/src/config.ts

@@ -9,12 +9,15 @@ export const EDIT_DIFF_MODES: readonly EditDiffMode[] = ["always", "never", "exp
 export type PiMinimalConfig = {
 	hideGauntletWidgets: boolean
 	editDiff: EditDiffMode
+	/** Key that opens the background-process overlay; `null` disables the shortcut (`/bg` still works). */
+	backgroundShortcut: string | null
 }
 
 const DEFAULTS: PiMinimalConfig = {
 	// Hiding another extension's widgets is opt-in.
 	hideGauntletWidgets: false,
 	editDiff: "expanded",
+	backgroundShortcut: "ctrl+b",
 }
 
 export function loadPiMinimalConfig(options: {
@@ -58,6 +61,11 @@ function applyLayer(config: PiMinimalConfig, path: string): void {
 		if (typeof value === "boolean") config.hideGauntletWidgets = value
 		else console.error(`pi-minimal: hideGauntletWidgets must be a boolean in ${path}`)
 	}
+	if (Object.hasOwn(record, "backgroundShortcut")) {
+		const value = record.backgroundShortcut
+		if (value === null || (typeof value === "string" && value.trim().length > 0)) config.backgroundShortcut = value === null ? null : value.trim()
+		else console.error(`pi-minimal: backgroundShortcut must be a key name such as "ctrl+b" or null in ${path}`)
+	}
 	if (Object.hasOwn(record, "editDiff")) {
 		const value = record.editDiff
 		if (isEditDiffMode(value)) config.editDiff = value

package/src/cwd.ts

@@ -3,7 +3,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
 import path from "node:path"
 import * as chrome from "./chrome.js"
 import { formatGitState, type GitState } from "./git-state.js"
-import type { Sibling } from "./herdr.js"
+import type { Sibling } from "./siblings.js"
 
 /** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
 const margin = (): number => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1))
@@ -88,21 +88,22 @@ export function splitRow(left: string, rightSegments: string[], width: number, s
 function siblingColor(status: string): "success" | "warning" | "error" | "accent" | "muted" {
   if (status === "idle" || status === "done") return "success"
   if (status === "working") return "accent"
-  if (status === "blocked") return "error"
+  if (status === "blocked" || status === "error") return "error"
   return "muted"
 }
 
 export type StatusLineSources = {
   gitState: () => GitState | undefined
   siblings: () => Sibling[] | undefined
-  onGitChange: (listener: () => void) => () => void
+  /** Fires when git state or the sibling list may have changed; the widget re-renders. */
+  onChange: (listener: () => void) => () => void
 }
 
 export function installCwd(ctx: ExtensionContext, sources: StatusLineSources): void {
   ctx.ui.setWidget(
     "tw-cwd",
     (tui, theme) => {
-      const unsub = sources.onGitChange(() => tui.requestRender())
+      const unsub = sources.onChange(() => tui.requestRender())
       return {
         dispose: unsub,
         invalidate() {},

package/src/footer.ts

@@ -2,6 +2,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
 import { keyHint } from "@earendil-works/pi-coding-agent"
 import { truncateToWidth } from "@earendil-works/pi-tui"
 import * as chrome from "./chrome.js"
+import { splitRow } from "./cwd.js"
 import { formatTrackerLines } from "./tracker.js"
 import type { FooterContributions } from "./footer-contributions.js"
 import { activityNeedsAnimation, renderFooterActivity } from "./footer-activity.js"
@@ -19,6 +20,14 @@ export type FooterSources = {
   editorText: () => string
   /** Context usage percentage, when known. */
   contextPct: () => number | undefined
+  /** Open PR chips (`#1675 #1670 +3`), themed and linked, shown right-aligned on the hints line. */
+  prs?: (theme: { fg(color: string, text: string): string }) => string | undefined
+  /** Fires when the PR chips may have changed. */
+  onPrsChange?: (listener: () => void) => () => void
+  /** `⚙ 2 bg` while bash-tool processes run in the background; shown after the hints. */
+  background?: () => string | undefined
+  /** Fires when the background count may have changed. */
+  onBackgroundChange?: (listener: () => void) => () => void
 }
 
 /**
@@ -52,11 +61,15 @@ export function installFooter(ctx: ExtensionContext, sources: FooterSources, con
     const update = () => { syncAnimation(); redraw() }
     const unsub = footerData.onBranchChange(redraw)
     const unsubscribeActivity = contributions?.subscribe(update)
+    const unsubscribePrs = sources.onPrsChange?.(redraw)
+    const unsubscribeBackground = sources.onBackgroundChange?.(redraw)
     stopMount = () => {
       if (disposed) return
       disposed = true
       unsub()
       unsubscribeActivity?.()
+      unsubscribePrs?.()
+      unsubscribeBackground?.()
       live.stop()
     }
     update()
@@ -71,9 +84,16 @@ export function installFooter(ctx: ExtensionContext, sources: FooterSources, con
           keyHint("app.thinking.cycle", "thinking"),
           keyHint("app.tools.expand", "expand tools"),
         ].filter(Boolean))
-        if (hints.length > 0) {
-          const line = theme.fg("dim", hints.join("  ·  "))
-          out.push(`${" ".repeat(margin())}${truncateToWidth(line, inner, "")}`)
+        // Left: hints (idle only) then the background count (always). Right: PR chips whenever
+        // there are any. The chips are dropped before the left side when the line is too narrow.
+        const background = sources.background?.()
+        const left = [hints.length > 0 ? theme.fg("dim", hints.join("  ·  ")) : "", background ? theme.fg("warning", background) : ""]
+          .filter(Boolean)
+          .join(theme.fg("dim", "  ·  "))
+        const prs = sources.prs?.(theme)
+        if (left || prs) {
+          const line = prs ? splitRow(left, [prs], inner) : truncateToWidth(left, inner, "")
+          out.push(`${" ".repeat(margin())}${line}`)
         }
         const activityWidth = Math.max(0, width - margin() * 2)
         const plan = renderFooterPlan(contributions?.readPlan(), activityWidth, theme)

package/src/herdr.ts

@@ -1,3 +1,9 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { createListeners } from "./listeners.js"
+import type { Sibling, SiblingSource } from "./siblings.js"
+
+export type { Sibling } from "./siblings.js"
+
 export type HerdrAgent = {
   agent: string
   agent_status: string
@@ -40,11 +46,6 @@ export function parseTabList(stdout: string): HerdrTab[] {
   }))
 }
 
-export type Sibling = {
-  name: string
-  status: string
-}
-
 export function listSiblings(
   agents: HerdrAgent[],
   tabs: HerdrTab[],
@@ -64,3 +65,75 @@ export function listSiblings(
   if (parts.length === 0) return undefined
   return parts
 }
+
+const HERDR_FAST_MS = 2000
+const HERDR_SLOW_MS = 10000
+const HERDR_EXEC_TIMEOUT_MS = 3000
+
+/**
+ * Polls `herdr agent list` + `herdr tab list`: every 2 s while siblings are visible, every 10 s
+ * otherwise or after a failure. Probes once immediately.
+ */
+export function createHerdrSiblings(pi: ExtensionAPI, env: NodeJS.ProcessEnv = process.env): SiblingSource {
+  let alive = true
+  let siblings: Sibling[] | undefined
+  let timer: ReturnType<typeof setInterval> | undefined
+  let period = 0
+  let inFlight: AbortController | undefined
+  const listeners = createListeners()
+
+  const set = (next: Sibling[] | undefined) => {
+    const changed = JSON.stringify(next) !== JSON.stringify(siblings)
+    siblings = next
+    if (changed) listeners.notify()
+  }
+
+  const schedule = (periodMs: number) => {
+    if (!alive || period === periodMs) return
+    if (timer) clearInterval(timer)
+    period = periodMs
+    timer = setInterval(() => { void probe() }, periodMs)
+  }
+
+  const probe = async () => {
+    if (!alive || inFlight) return
+    const ac = new AbortController()
+    inFlight = ac
+    try {
+      const agentRun = await pi.exec("herdr", ["agent", "list"], { timeout: HERDR_EXEC_TIMEOUT_MS, signal: ac.signal })
+      if (!alive) return
+      const tabRun = await pi.exec("herdr", ["tab", "list"], { timeout: HERDR_EXEC_TIMEOUT_MS, signal: ac.signal })
+      if (!alive) return
+      if (agentRun.code !== 0 || tabRun.code !== 0 || agentRun.killed || tabRun.killed) {
+        set(undefined)
+        schedule(HERDR_SLOW_MS)
+        return
+      }
+      set(listSiblings(parseAgentList(agentRun.stdout), parseTabList(tabRun.stdout), env.HERDR_PANE_ID, env.HERDR_TAB_ID))
+      schedule(siblings ? HERDR_FAST_MS : HERDR_SLOW_MS)
+    } catch {
+      if (!alive) return
+      set(undefined)
+      schedule(HERDR_SLOW_MS)
+    } finally {
+      if (inFlight === ac) inFlight = undefined
+    }
+  }
+
+  void probe()
+
+  return {
+    get: () => siblings,
+    onChange: listeners.add,
+    dispose() {
+      if (!alive) return
+      alive = false
+      if (timer) clearInterval(timer)
+      timer = undefined
+      inFlight?.abort()
+      inFlight = undefined
+      siblings = undefined
+      listeners.clear()
+    },
+  }
+}

package/src/index.ts

@@ -1,5 +1,9 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { Type } from "@earendil-works/pi-ai"
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { showBackgroundOverlay } from "./background-overlay.js"
 import { installCodeBox } from "./code-box.js"
+import { isPrCreateCommand } from "./prs.js"
+import { parsePrFilter, prsToolResult, runPrsCommand, type PrFilter } from "./prs-command.js"
 import { createSession, type Session } from "./session.js"
 import { installToolRenderers, stopLiveWatch } from "./tools.js"
 import { installTranscript } from "./transcript.js"
@@ -21,9 +25,61 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
   let active: Session | undefined
   let busy = false
 
+  // Background processes: `/bg` and a shortcut (default ctrl+b, see `backgroundShortcut`). The
+  // shortcut is registered once per key at load, since pi has no unregister; it reads the active
+  // session's config when pressed.
+  const openBackground = async (ctx: ExtensionContext) => {
+    if (!active?.background) return
+    await showBackgroundOverlay(ctx, active.background, active.backgroundShortcut ?? undefined)
+  }
+  pi.registerCommand("bg", { description: "Show processes left running by bash tool calls", handler: (_args, ctx) => openBackground(ctx) })
+  // Open PRs for the repo in cwd: `/prs [mine|review|all]` and the `list_open_prs` tool.
+  pi.registerCommand("prs", {
+    description: "Open PRs in this repo that I authored or that need my review",
+    handler: (args, ctx) => runPrsCommand(args, ctx, pi, active?.prs),
+  })
+  pi.registerTool({
+    name: "list_open_prs",
+    label: "List Open PRs",
+    description: "List open pull requests in the current repository that the user authored or has been asked to review (via the gh CLI).",
+    parameters: Type.Object({
+      filter: Type.Optional(Type.Union([Type.Literal("all"), Type.Literal("mine"), Type.Literal("review")], { description: "all (default), mine, or review (waiting on my review)" })),
+    }),
+    async execute(_toolCallId, params) {
+      await active?.prs?.refresh()
+      const result = prsToolResult(active?.prs, (params.filter as PrFilter | undefined) ?? parsePrFilter(""))
+      const text = result.prs.length === 0
+        ? `No open PRs${result.repo ? ` in ${result.repo}` : ""}${result.error ? ` (${result.error})` : ""}.`
+        : result.prs.map((pr) => `#${pr.number} [${pr.kind}${pr.isDraft ? ", draft" : ""}${pr.ciFailing ? ", CI failing" : ""}] ${pr.title} — ${pr.url}`).join("\n")
+      return { content: [{ type: "text", text }], details: result }
+    },
+  })
+  const registeredShortcuts = new Set<string>()
+  const ensureShortcut = () => {
+    const key = active?.backgroundShortcut
+    if (!key || registeredShortcuts.has(key) || typeof pi.registerShortcut !== "function") return
+    registeredShortcuts.add(key)
+    pi.registerShortcut(key as Parameters<ExtensionAPI["registerShortcut"]>[0], {
+      description: "Show background processes",
+      handler: (ctx) => (active?.backgroundShortcut === key ? openBackground(ctx) : undefined),
+    })
+  }
+
   pi.on("session_start", (_event, ctx) => {
     active?.dispose()
     active = createSession(pi, ctx, { busy: () => busy })
+    ensureShortcut()
+  })
+
+  // Commands that create a PR: remember the URL they print so the chips follow the session
+  // even when cwd is another repo (worktrees) or no repo at all.
+  const prCreateCalls = new Map<string, true>()
+  pi.on("tool_execution_start", (event) => {
+    active?.background?.toolStart(event.toolCallId, event.toolName)
+    const command = (event.args as { command?: unknown } | undefined)?.command
+    if ((event.toolName === "bash" || event.toolName === "powershell") && typeof command === "string" && isPrCreateCommand(command)) {
+      prCreateCalls.set(event.toolCallId, true)
+    }
   })
 
   pi.on("agent_start", () => {
@@ -37,7 +93,12 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
     active?.pin("turn_end")
     active?.refreshGit()
   })
-  pi.on("tool_execution_end", () => {
+  pi.on("tool_execution_end", (event) => {
+    active?.background?.toolEnd(event.toolCallId, event.toolName)
+    if (prCreateCalls.delete(event.toolCallId) && !event.isError) {
+      const content = (event.result as { content?: Array<{ type?: string; text?: string }> } | undefined)?.content ?? []
+      active?.notePrUrls(content.map((part) => (part.type === "text" && typeof part.text === "string" ? part.text : "")).join("\n"))
+    }
     active?.pin("tool_execution_end")
     active?.refreshGit()
   })

package/src/listeners.ts

@@ -0,0 +1,22 @@
+/** A tiny change-notification set shared by the git and sibling sources. */
+export function createListeners() {
+  const listeners = new Set<() => void>()
+  return {
+    notify() {
+      for (const listener of listeners) {
+        try {
+          listener()
+        } catch {
+          // One listener's failure must not starve the others.
+        }
+      }
+    },
+    add(listener: () => void) {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    },
+    clear() {
+      listeners.clear()
+    },
+  }
+}