pi-minimal 0.4.0 → 0.6.0

package/dist/tracker.js

@@ -1,5 +1,5 @@
 const PHASES = ["brainstorm", "plan", "implement", "verify", "ship"];
-function readSnapshot(ctx) {
+export function readGauntletProjection(ctx) {
     let phases;
     let tasks;
     for (const entry of ctx.sessionManager.getBranch()) {
@@ -21,7 +21,7 @@ function phaseActive(phases) {
     return PHASES.some((p) => phases[p]?.status && phases[p].status !== "pending");
 }
 export function formatTrackerLines(ctx, theme) {
-    const { phases, tasks } = readSnapshot(ctx);
+    const { phases, tasks } = readGauntletProjection(ctx);
     const lines = [];
     if (phases && phaseActive(phases)) {
         const parts = PHASES.map((p) => {

package/dist/working-status.js

@@ -184,8 +184,9 @@ export function installWorkingStatus(pi) {
         stop();
     });
     pi.on("session_shutdown", () => {
-        ctx = undefined;
+        // Clear the message while ctx is still known; dropping ctx first left it on screen.
         stop();
+        ctx = undefined;
     });
     return stop;
 }

package/doc/archive/README.md

@@ -0,0 +1,3 @@
+# Archive
+
+The spec and plan here describe the 0.1 package (September 2026) and are superseded by [README.md](../../README.md) and [CONTEXT.md](../../CONTEXT.md).

package/doc/footer-contributions.md

@@ -4,14 +4,14 @@ Pi-minimal remains the single footer owner. A trusted companion extension can pu
 
 Order: **input → existing hints → plan summary → activity rows last**. When either contribution is visible, a blank row separates the footer from input and separates each nonempty group. Agent rows stay compact, and empty groups leave no extra gaps. Legacy-only output is unchanged.
 
-Two independent slots are supported: `activity` and `summary`, with one owner per slot. An explicit plan summary replaces the legacy tracker projection while present, avoiding duplicate plan bars; clearing it restores the legacy summary. This is display composition, not a task tracker, subagent launcher, or PR/workspace display.
+Two independent slots are supported: `activity` and `plan`, with one owner per slot. (`summary` is the legacy wire name of the plan slot and remains accepted.) A rendered plan line replaces the legacy pi-gauntlet projection, avoiding duplicate plan bars; a plan snapshot that omits `plan`, or clearing the slot, lets the legacy projection show again. This is display composition, not a task tracker, subagent launcher, or PR/workspace display.
 
 ## Events
 
 | Event | Direction | Payload |
 |---|---|---|
 | `pi-minimal:footer:v1:register` | consumer → host | Mutable registration request; host assigns `result` synchronously |
-| `pi-minimal:footer:v1:ready` | host → consumers | `{ version: 1, sessionId, slots: ["activity", "summary"] }` |
+| `pi-minimal:footer:v1:ready` | host → consumers | `{ version: 1, sessionId, slots: ["activity", "plan", "summary"] }` |
 | `pi-minimal:footer:v1:unavailable` | host → consumers | `{ version: 1, sessionId }` |
 
 Use `ctx.sessionManager.getSessionId()`, not a file path. Events are in-process only, not a cross-process API. One consumer owns each slot at a time; a tracker and activity extension can register independently. Names/keys are display identity, not permission or process-control tokens.
@@ -51,7 +51,7 @@ type RegisterRequest = {
   version: 1;
   sessionId: string;
   owner: string;
-  slot: "activity" | "summary";
+  slot: "activity" | "plan" | "summary"; // "summary" is the legacy alias of "plan"
   result?:
     | { ok: true; registration: {
         publish(snapshot: unknown): { ok: true } | { ok: false; code: string };
@@ -63,7 +63,7 @@ type RegisterRequest = {
 
 No result means the host is absent/not ready. Registration errors include `invalid`, `wrong-session`, `occupied`, and `not-tui`. Publish errors include `invalid`, `stale`, and `disposed`.
 
-## Plan summary snapshot (`summary` slot)
+## Plan snapshot (`plan` slot; legacy name `summary`)
 
 ```ts
 {
@@ -74,8 +74,8 @@ No result means the host is absent/not ready. Registration errors include `inval
 ```
 
 The plan ID follows row-key bounds. Counts/revision are nonnegative safe integers;
-accepted cannot exceed total; review and blocked counts cannot individually exceed
-remaining tasks. Counts are supplied by the tracker, never inferred from agent
+accepted cannot exceed total; `inReview` and `blocked` are each bounded by
+`total - accepted`, but their sum is not checked (a task may be both). Counts are supplied by the tracker, never inferred from agent
 runs. Omit `plan` on a newer revision to clear the contribution without releasing
 ownership. Snapshot objects are cloned/frozen, and revision/disposal rules match
 the activity slot. Each slot has independent ownership and revision tracking.
@@ -109,7 +109,7 @@ Metrics are right-aligned only if the full activity text still fits with at leas
 
 Task IDs appear beside activity. In-progress tasks need no extra badge; blocked/review/accepted/cancelled tasks get a distinct badge, and plain mode retains textual status. A completed agent with an `in_review` task shows a green run check plus an accent review diamond. This optional data does not create a tracker or automatically accept a task.
 
-Owner uses the same character/length rules as row keys. Display text has ANSI/OSC, C0/C1, and bidi controls removed, with whitespace collapsed. The host clones and freezes validated snapshots. Invalid/stale publishes preserve the previous valid snapshot. Consumers must handle publish failure and send an explicit unknown/error observation when appropriate; an absent update does not prove a run ended.
+Owner uses the same character/length rules as row keys. Display text has ANSI/OSC sequences stripped; remaining C0/C1 and bidi control characters are replaced with spaces, then whitespace is collapsed and trimmed. The host clones and freezes validated snapshots. Invalid/stale publishes preserve the previous valid snapshot. Consumers must handle publish failure and send an explicit unknown/error observation when appropriate; an absent update does not prove a run ended.
 
 ## Presentation and responsibility boundaries
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-minimal",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -28,7 +28,8 @@
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-tui": "*",
+    "@earendil-works/pi-ai": "*"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^1.4.0",
@@ -37,7 +38,8 @@
     "@types/node": "*",
     "eslint": "^10.11.0",
     "typescript": "*",
-    "typescript-eslint": "^8.70.1"
+    "typescript-eslint": "^8.70.1",
+    "@earendil-works/pi-ai": "^1.4.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",

package/release-notes.md

@@ -1,23 +1,44 @@
+Rex support and a footer hints line that carries live state: sibling agents from Rex as well as
+Herdr, background processes left by bash calls, and the repo's open PRs as clickable chips.
+
 ### Added
 
-- `editDiff` setting in `pi-minimal.json`: controls whether an `edit` row shows the
-  change itself. `"expanded"` (default) shows the unified diff in the `│`-ruled
-  block when the row is expanded with `ctrl+o`, where the bare "Successfully
-  replaced" text used to be. `"always"` shows it inline as soon as the edit lands,
-  capped at 40 lines with `… N more lines (ctrl+o)` for the rest. `"never"` keeps
-  the stats-only row. Lines use the theme's `toolDiffAdded` / `toolDiffRemoved` /
-  `toolDiffContext` colours and keep pi's line-number gutter; when one line
-  replaces one line, only the changed tokens are inverse-highlighted, as in pi's
-  own edit renderer. Failed edits and results without a diff are unchanged.
+- Open PRs: the footer shows `#1675 #1670 +3` chips, right-aligned on the hints line below the editor, for open PRs in the repo of cwd that you
+  authored or were asked to review, each an OSC 8 hyperlink to the PR, coloured accent (mine), dim
+  (my draft), amber (needs my review) or red (failing CI / changes requested). `/prs [mine|review|all]`
+  lists them with open / paste URL / checkout actions; `list_open_prs` tool for the model. Uses the
+  `gh` CLI; works on GitHub.com and GitHub Enterprise. PRs created by the session (`gh pr create`,
+  `gt submit`) are remembered as session entries and shown from any directory, as `repo#n` when
+  outside the cwd repo, until merged. New peer dependency `@earendil-works/pi-ai` (supplied by pi)
+  for the tool schema.
+- Background processes: `⚙ N bg` after the key hints in the footer while processes left behind by `bash` tool
+  calls are running; `ctrl+b` / `/bg` opens an overlay listing each one with running/ended state and
+  duration, `k` kills the selection, `K` its process group. Attribution diffs `ps` around each bash
+  call using pi's detached process groups, so no command is rewritten. New `backgroundShortcut`
+  setting (`"ctrl+b"`; `null` disables the key).
+
+- Rex siblings: inside a Rex session (`REX_SESSION` + `REX_BLOCK`) the status line shows other
+  panes' agent state, read from Rex's Program Status Protocol (OSC 7501) over one
+  `rex events --json` stream instead of polling. Needs a reporter in each pi (an extension that
+  writes OSC 7501 on `agent_start` / `agent_settled`); programs such as claude-code or terraform
+  that already speak the protocol appear as well. `error` renders like `blocked`.
+
+### Changed
+
+- Sibling status now comes from a `SiblingSource` (`src/siblings.ts`) picked from the environment;
+  the Herdr poller moved from `session.ts` into `herdr.ts` unchanged. Herdr wins when both hosts
+  are present. The status line re-renders when the sibling list changes, not only on git changes.
 
 ## What's Changed
-* feat: editDiff setting — show edit diffs always, never, or behind ctrl+o (0.4.0) by @raviy06 in https://github.com/raviy06/pi-minimal/pull/18
+* feat: Rex siblings on the status line via OSC 7501 event stream by @raviy06 in https://github.com/raviy06/pi-minimal/pull/22
+* feat: background processes on the status line with a ctrl+b overlay by @raviy06 in https://github.com/raviy06/pi-minimal/pull/23
+* feat: open PR chips and background count on the footer hints line by @raviy06 in https://github.com/raviy06/pi-minimal/pull/24
 
 
-**Full Changelog**: https://github.com/raviy06/pi-minimal/compare/v0.3.1...v0.4.0
+**Full Changelog**: https://github.com/raviy06/pi-minimal/compare/v0.5.0...v0.6.0
 
 ---
 **Install / upgrade**
 ```bash
-pi install npm:pi-minimal@0.4.0   # or: pi update --extensions
+pi install npm:pi-minimal@0.6.0   # or: pi update --extensions
 ```

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,11 +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 = {
-	hideGauntletWidgets: true,
+	// Hiding another extension's widgets is opt-in.
+	hideGauntletWidgets: false,
 	editDiff: "expanded",
+	backgroundShortcut: "ctrl+b",
 }
 
 export function loadPiMinimalConfig(options: {
@@ -57,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() {},