pi-minimal 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -10,6 +10,39 @@ Releases are cut automatically: when the `version` in `package.json` changes on
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-10-29
+
+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
+
+- 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.
+
 ## [0.5.0] - 2026-10-27
 
 Session lifecycle, one tool-row lifecycle, and a domain glossary. `hideGauntletWidgets`
@@ -201,7 +234,8 @@ is now opt-in and the 200 ms chrome steal interval is gone.
 - Initial release: header/footer chrome, compact tool activity rows, working
   status line, Herdr sibling status, Gauntlet widget hiding.
 
-[Unreleased]: https://github.com/raviy06/pi-minimal/compare/v0.2.3...HEAD
+[Unreleased]: https://github.com/raviy06/pi-minimal/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/raviy06/pi-minimal/compare/v0.5.0...v0.6.0
 [0.2.3]: https://github.com/raviy06/pi-minimal/compare/v0.2.2...v0.2.3
 [0.2.2]: https://github.com/raviy06/pi-minimal/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/raviy06/pi-minimal/compare/v0.2.0...v0.2.1

package/CONTEXT.md

@@ -12,8 +12,15 @@ When a word below has a narrower meaning than in everyday use, the narrower mean
 - **Reclaim** — re-installing chrome after an event that may have let another extension draw over
   it (`src/reclaim.ts`). A *reclaim reason* (`session_start`, `session_settle`, `turn_end`,
   `tool_execution_end`) maps to a policy: whether to reset the editor and whether to reinstall chrome.
-- **Status line** — `model · thinking · context meter · cwd · ⎇ branch ±dirty · Herdr siblings`
-  (`src/cwd.ts`). *Siblings* are other Herdr panes in the same workspace (`src/herdr.ts`).
+- **Status line** — `model · thinking · context meter · cwd · ⎇ branch ±dirty · siblings`
+  (`src/cwd.ts`). *Siblings* are other agents in the same host workspace with their state
+  (`working | blocked | idle | done | error`).
+- **Sibling source** — where siblings come from (`src/siblings.ts`, `SiblingSource`: `get`,
+  `onChange`, `dispose`). Chosen from the environment at session start: the *Herdr source*
+  polls `herdr agent list` / `herdr tab list` (`src/herdr.ts`, `HERDR_ENV=1`); the *Rex source*
+  follows one `rex events -s SESSION --json` stream and reads OSC 7501 program-status records
+  (`src/rex.ts`, `REX_SESSION` + `REX_BLOCK`). Herdr wins when both are set. A sibling's name is
+  its tab label, or the program's `app` when the tab only has a Rex auto-label (`Window 1a2b…`).
 - **Hints** — the keybinding labels in the footer (`send · thinking · expand tools`, plus
   `/compact` from 70 % context), shown only when idle with an empty editor (`src/footer.ts`).
   Not task hints and not the change hints other extensions emit.
@@ -31,6 +38,23 @@ When a word below has a narrower meaning than in everyday use, the narrower mean
 - **Code box** — the faint frame around fenced code blocks (`src/code-box.ts`, a pi-tui
   `Markdown.prototype.renderToken` patch).
 
+- **Open PR** — an open pull request in the repo of `cwd` that I authored (*mine*) or that requests
+  my review (*review*); PRs that merely mention me are not shown (`src/prs.ts`, `PullRequest`,
+  `kind`). Found with `gh repo view` → `gh api user` (login differs per host) → `gh pr list
+  --search involves:@me`. Shown as *chips* right-aligned on the footer's hints line (`src/footer.ts`): `#1675`, an OSC 8 hyperlink to the
+  PR, coloured by `prColor` (trouble > review > draft > mine). `/prs` and the `list_open_prs` tool
+  live in `src/prs-command.ts`. The *PR source* (`PrSource`) polls every 3 min and on `refreshGit`,
+  throttled to once a minute. A **session PR** is one this session created: a `gh pr create` /
+  `gt submit` bash call whose output prints a PR URL (`findPrUrls`). Its URL is stored as a
+  `pi-minimal.pr` custom session entry (restored on resume) and fetched with `gh pr view URL`
+  whatever cwd is, labelled `repo#n` outside the cwd repo, until it is merged or closed.
+- **Background process** — a process a `bash` tool call left running after it returned
+  (`src/background.ts`). Found by diffing `ps` before/after the call: new, orphaned (ppid 1) and in a
+  *tracked group*, a process group whose leader (the tool shell) was born and died inside the call.
+  Groups are polled every 2 s until empty. A process is `running` or `ended` (gone from `ps`, kept
+  60 s; no exit code is knowable). Shown as `⚙ N bg` after the hints on the footer's hints line (`src/footer.ts`) and listed in the
+  *background overlay* (`src/background-overlay.ts`, `/bg` or `backgroundShortcut`, default `ctrl+b`).
+
 ## Footer contributions (the extension point)
 
 - **Contribution** — data another extension publishes for pi-minimal to render in the footer,
@@ -77,7 +101,7 @@ When a word below has a narrower meaning than in everyday use, the narrower mean
 - **Load-time hooks** — installed once per extension instance: tool renderers, the markdown
   transformer, the code-box patch, working status and the turn rule (`src/index.ts`).
 - **Session** — everything scoped to one pi session: config, cwd, the contribution registry,
-  git and Herdr pollers, settle timers and chrome (`src/session.ts`, when present). Created on
+  git poller, sibling source, settle timers and chrome (`src/session.ts`, when present). Created on
   `session_start`, disposed on `session_shutdown` or when the next session starts.
 - **Chrome margin** — pi's `outputPad`, mirrored on `globalThis` so module copies reloaded by
   `/reload` agree (`src/chrome.ts`).

package/README.md

@@ -7,12 +7,13 @@ A Pi coding-agent package.
 - Node.js `>=22.19.0`
 - Pi `>=1.4.0` (uses `registerToolRenderer`, `registerEntryRenderer`, `registerMarkdownTransformer`)
 
-No other Pi extension is required. Pi supplies the peer packages used by this extension.
+No other Pi extension is required. Pi supplies the peer packages used by this extension. The `gh` CLI is needed only for the open-PR chips.
 
 Optional integrations:
 
 - `pi-gauntlet`: supplies the phase and task data shown in the footer. Set `hideGauntletWidgets: true` to also hide its own widgets, since the footer already shows that data.
-- Herdr: sibling status appears only when Pi is running inside Herdr.
+- Herdr: sibling status (other agents in the workspace, `working` / `blocked` / `idle`) appears when Pi runs inside a Herdr pane (`HERDR_ENV=1`). Herdr's own pi integration reports each pane's state.
+- Rex: the same sibling status appears when Pi runs inside a [Rex](https://www.superlogical.com/rex) session (`REX_SESSION` + `REX_BLOCK`). Rex learns a pane's state from the [Program Status Protocol (OSC 7501)](https://www.superlogical.com/rex/docs/build/program-status), so each pi needs an extension that reports it (e.g. a `rex-agent-state.ts` that writes `ESC ] 7501 ; state=working:app=pi ESC \\` on `agent_start`); other programs that speak the protocol show up too. Herdr wins when both are present.
 
 ## Installation
 
@@ -33,8 +34,10 @@ Do not load this package beside the live `grok-chrome` extension. Disable or rem
 - **Tool rows** – every built-in tool call (`bash`, `read`, `edit`, `write`, `grep`, `find`, `ls`) renders as one line: status glyph (`◐` running, `✓` ok, `✗` failed), verb, item, and a right-aligned outcome (`34 lines · 1.0s`, `exit 1`, `+3 −1`, `4 matches`). Failed rows show the first line of output underneath; `ctrl+o` expands full output in a `│`-ruled block. `codemode` renders the same way, as a `code` row with one child row per nested tool call; `ctrl+o` shows the script and its output. Tools without a renderer of their own (most MCP tools) get the same one-line row; tools that draw themselves keep their look. Bash rows drop a leading `cd <session cwd> &&` and shorten other `cd` prefixes to the directory name.
 - **Turn rule** – after each agent run a dim `── 15:51 · 12s · 4 tools ──` separator is appended (stored as a custom entry; never sent to the model).
 - **Thinking gutter** – every line of a thinking paragraph, wrapped lines included, starts with `┊`, so thinking reads as a column beside prose.
-- **Status line** – one line above the editor: model · thinking level · context meter (amber at 70 %, red at 90 %) · cwd · `⎇ branch ±dirty` · Herdr siblings.
+- **Status line** – one line above the editor: model · thinking level · context meter (amber at 70 %, red at 90 %) · cwd · `⎇ branch ±dirty` · siblings (other agents in the same Herdr workspace or Rex session, with their state).
 - **Footer** – key hints appear only when the agent is idle and the editor is empty; `/compact` is suggested under context pressure.
+- **Open PRs** – for the GitHub repo in the working directory (any host `gh` is logged in to), the footer shows chips for open PRs you authored or were asked to review, right-aligned on the key-hints line below the editor: `#1675 #1670 +3`. The chips stay while you type or the agent works, even though the hints hide. PRs the session itself creates (a `bash` call running `gh pr create` or `gt submit`) are remembered — also across `/resume` — and shown wherever the session is, even outside a repo, labelled `repo#1675` when they are not in the cwd repo; they drop off once merged or closed. Each chip is a terminal hyperlink to the PR (OSC 8; click or cmd-click in Rex, Ghostty, iTerm2, WezTerm, Kitty). Colours: accent = mine, dim = my draft, amber = waiting on my review, red = failing CI or changes requested. `/prs [mine|review|all]` lists them with actions (open in browser, paste URL into the editor, `gh pr checkout`); the `list_open_prs` tool gives the model the same list. Refreshed every 3 minutes and after each turn (at most once a minute). Needs the `gh` CLI.
+- **Background processes** – when a `bash` tool call leaves something running (`npm run dev &`, `nohup ./watch.sh`), the footer shows `⚙ 2 bg` after the key hints below the editor (it stays while the hints hide). `ctrl+b` (or `/bg`) opens a list with each process, whether it is running or has ended, and for how long; `k` kills the selected process, `K` its whole process group. Pi kills these groups when it exits, so the list is scoped to this pi. Attribution uses process groups (pi spawns each bash call detached), so commands are never rewritten; a process that has already exited shows as `ended` without an exit code, since it was reparented away from pi. Set `backgroundShortcut` in `pi-minimal.json` to another key, or `null` to keep only `/bg`.
 - **Code blocks** – fenced code renders as a closed box with the language as its title, keeping syntax highlighting, instead of literal ``` lines; long lines wrap inside the box.
 - **Alignment** – chrome follows pi's `outputPad` setting. Pi's editor uses the separate `editorPaddingX` setting (default `0`); set `"editorPaddingX": 1` for a flush left edge with the transcript.
 - **Theme** – ships `minimal-dark`: no background behind tool rows (failures excepted), a grey ladder whose readable tiers stay near 4.5:1, syntax colours kept off the status hues, visible user-message tint, dimmer thinking text, violet headings (yellow is reserved for warnings), and faint code-block frames. Select it in `/settings` → Theme, or set `"theme": "minimal-dark"`.

package/dist/background-overlay.js

@@ -0,0 +1,95 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { formatElapsed } from "./working-status.js";
+export function backgroundRows(snap, now) {
+    const row = (proc) => ({
+        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) {
+    if (snap.running.length === 0)
+        return undefined;
+    return `⚙ ${snap.running.length} bg`;
+}
+/** Lines of the overlay body for a given width; pure so it can be tested without a TUI. */
+export function renderBackgroundLines(rows, selected, width, theme, shortcut) {
+    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, tracker, shortcut) {
+    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((tui, theme, keybindings, done) => {
+        let selected = 0;
+        let cached;
+        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) {
+                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) {
+                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/dist/background.js

@@ -0,0 +1,206 @@
+import { createListeners } from "./listeners.js";
+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) {
+    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) {
+    const entries = new Map();
+    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, after) {
+    const groupsBefore = new Set();
+    for (const entry of before.values())
+        groupsBefore.add(entry.pgid);
+    const groups = new Set();
+    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 function createBackgroundState() {
+    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, ps, now) {
+    let changed = false;
+    const seen = new Set();
+    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) {
+    const running = [];
+    const ended = [];
+    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 function createBackgroundTracker(deps) {
+    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();
+    let alive = true;
+    let timer;
+    let polling = false;
+    const listProcesses = async () => {
+        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/dist/config.js

@@ -6,6 +6,7 @@ const DEFAULTS = {
     // Hiding another extension's widgets is opt-in.
     hideGauntletWidgets: false,
     editDiff: "expanded",
+    backgroundShortcut: "ctrl+b",
 };
 export function loadPiMinimalConfig(options) {
     const config = { ...DEFAULTS };
@@ -44,6 +45,13 @@ function applyLayer(config, path) {
         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))

package/dist/cwd.js

@@ -86,13 +86,13 @@ function siblingColor(status) {
         return "success";
     if (status === "working")
         return "accent";
-    if (status === "blocked")
+    if (status === "blocked" || status === "error")
         return "error";
     return "muted";
 }
 export function installCwd(ctx, sources) {
     ctx.ui.setWidget("tw-cwd", (tui, theme) => {
-        const unsub = sources.onGitChange(() => tui.requestRender());
+        const unsub = sources.onChange(() => tui.requestRender());
         return {
             dispose: unsub,
             invalidate() { },

package/dist/footer.js

@@ -1,6 +1,7 @@
 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 { activityNeedsAnimation, renderFooterActivity } from "./footer-activity.js";
 import { createLiveWatch } from "./live-watch.js";
@@ -45,12 +46,16 @@ export function installFooter(ctx, sources, contributions) {
         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();
@@ -65,9 +70,16 @@ export function installFooter(ctx, sources, contributions) {
                     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/dist/herdr.js

@@ -1,3 +1,4 @@
+import { createListeners } from "./listeners.js";
 function parseJson(stdout) {
     return JSON.parse(stdout);
 }
@@ -42,3 +43,80 @@ export function listSiblings(agents, tabs, selfPane, selfTab) {
         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, env = process.env) {
+    let alive = true;
+    let siblings;
+    let timer;
+    let period = 0;
+    let inFlight;
+    const listeners = createListeners();
+    const set = (next) => {
+        const changed = JSON.stringify(next) !== JSON.stringify(siblings);
+        siblings = next;
+        if (changed)
+            listeners.notify();
+    };
+    const schedule = (periodMs) => {
+        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();
+        },
+    };
+}