pi-minimal 0.4.0 → 0.6.0

package/CHANGELOG.md

@@ -10,6 +10,85 @@ 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`
+is now opt-in and the 200 ms chrome steal interval is gone.
+
+### Added
+
+- `write` rows show the written content (first 400 lines) when expanded with `ctrl+o`.
+- With `editDiff: "expanded"` (the default), diffs of up to 8 lines are shown inline;
+  hiding them saved nothing and cost a keypress. Longer diffs still wait for `ctrl+o`.
+- `CONTEXT.md`: a glossary of the domain (chrome, reclaim, slots, owner token, the snapshot
+  kinds, plan vs the legacy pi-gauntlet projection, activity rows, hints, turn rule, working
+  status). The 0.1 spec and plan moved to `doc/archive/`.
+- The plan slot can be addressed as `slot: "plan"`; `summary` stays accepted as its legacy
+  name and the ready event now lists `["activity", "plan", "summary"]`.
+
+### Changed
+
+- `hideGauntletWidgets` now defaults to `false`. Hiding another extension's widgets is
+  opt-in; set it to `true` to keep the previous behaviour.
+- Chrome is re-asserted only on events (session start and its two settle ticks, turn
+  end, tool end). The 200 ms interval that cleared pi-gauntlet's widgets five times a
+  second is gone; it never reinstalled the header or footer anyway.
+- All session-scoped state (config, cwd, the footer contribution registry, the git and
+  Herdr pollers, the chrome) now lives on one `Session` object created at session start
+  and disposed at shutdown or when the next session starts. Late async results from a
+  disposed session are dropped instead of drawing into the new one.
+- The compact, generic and codemode tool rows are now three small strategies over one
+  row lifecycle (`createRowRenderers`): running state, live spinner, status colours,
+  the error line and expansion are implemented once. Edit-diff colouring moved to
+  `src/edit-diff.ts`. No visible change beyond the two items above.
+- Internal renames for clarity: `TrackerSnapshot` → `GauntletProjection`,
+  `readSnapshot` → `readGauntletProjection`, the tracker's `TaskStatus` →
+  `GauntletTaskStatus`, and the slot's authority symbol is `ownerToken`. No wire change.
+- `doc/footer-contributions.md` now states precisely when the legacy projection is replaced
+  (only while a plan line renders), how control characters are sanitised (VT stripped,
+  C0/C1/bidi replaced with spaces), and that `inReview`/`blocked` are bounded individually.
+
+### Fixed
+
+- The working message is cleared on session shutdown; it used to drop the context
+  before clearing and leave the last status on screen.
+- Git state reads the working directory once per refresh, so branch and dirty count
+  always describe the same tree, and one throwing change listener no longer blocks
+  the others.
+
 ## [0.4.0] - 2026-10-27
 
 ### Added
@@ -155,7 +234,8 @@ Releases are cut automatically: when the `version` in `package.json` changes on
 - 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

@@ -0,0 +1,107 @@
+# pi-minimal domain glossary
+
+The vocabulary used in code and docs, one entry per concept, with the file that defines it.
+When a word below has a narrower meaning than in everyday use, the narrower meaning wins.
+
+## Surfaces pi-minimal owns
+
+- **Chrome** — the three host slots pi-minimal draws into: the header (`src/header.ts`, intentionally
+  empty), the footer (`src/footer.ts`) and the status line (`src/cwd.ts`, a widget above the editor;
+  it is *not* pi's `setStatus`). pi has no owner concept for these, so chrome is re-asserted on
+  events; see *reclaim*.
+- **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 · 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.
+- **Tool row** — one line per tool call: `glyph verb item … outcome` (`src/tools.ts`,
+  `src/tool-rows.ts`). *Compact* rows are the built-in tools, *generic* rows are tools with no
+  renderer of their own (most MCP tools), the *codemode* row has one child row per nested call.
+  A row's **outcome** is its right-aligned summary (`34 lines · 1.0s`, `+3 −1`, `exit 1`).
+- **Turn rule** — the dim `── 15:51 · 12s · 4 tools ──` separator appended after each agent run
+  (`src/turn-rule.ts`). Stored as a `pi-minimal.turn` custom session entry, never sent to the model.
+  Its data is a *TurnSummary*, unrelated to the plan slot.
+- **Working status** — the transient `Thinking · 3s` / `Running ls · 2 tools · 5s` message while
+  an agent runs (`src/working-status.ts`), driven by agent/tool/message events and cleared when
+  the agent settles. Its state object is a *WorkingSnapshot*.
+- **Thinking gutter** — the `┊` column in front of assistant thinking text (`src/transcript.ts`).
+- **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,
+  through the in-process `pi-minimal:footer:v1:*` events (`src/footer-contribution-events.ts`).
+  pi-minimal keeps ownership of the footer; contributors never draw.
+- **Slot** — one of two independent places a contribution can go: `activity` (agent rows) and
+  `plan` (one plan bar). `summary` is the legacy wire name of the plan slot and stays accepted.
+  One owner per slot per session (`src/footer-contributions.ts`).
+- **Owner** vs **owner token** — `owner` is the registrant's display identity (a validated
+  string). The *owner token* is the `Symbol` handed back on registration; it alone authorises
+  `publish`/`dispose`. A slot is *occupied* while a token is live.
+- **Snapshot** — a complete replacement value published to a slot. Two kinds:
+  **ActivitySnapshot** (`revision`, `rows`, `omitted`, `motion`, `format`) and **PlanSnapshot**
+  (`revision`, `format`, optional `plan`). Publishing never patches; it replaces.
+- **Revision** — a per-slot monotonic counter on each snapshot. A publish whose revision is not
+  greater than the current one is *stale* and ignored.
+- **Activity row** — one keyed line in the activity slot: `agent`, `state`, `text`, optional
+  `parentKey` (two levels of nesting), `metrics` (`elapsedMs`, `tokens`), `task`
+  (`planId`, `id`, `status`). Rendered in producer order, at most four plus `+ N more`
+  (`src/footer-activity.ts`, `src/footer-activity-details.ts`).
+- **Activity state** — `queued | running | waiting | paused | stopping | completed | failed |
+  stopped | unknown`. Display-only; pi-minimal infers nothing about execution from it.
+- **Plan** — the plan slot's payload: `id`, `accepted`, `total`, `inReview`, `blocked`. Counts
+  are supplied by the contributor, never inferred from agent runs (`src/footer-plan.ts`).
+- **Task status (contribution)** — `todo | in_progress | blocked | in_review | done | cancelled`
+  on an activity row's `task`. Distinct from the gauntlet task status below.
+
+## Legacy pi-gauntlet projection
+
+- **Gauntlet projection** — what pi-gauntlet last reported on the session branch, read from its
+  `phase_tracker` / `plan_tracker` tool-result `details` (`src/tracker.ts`,
+  `readGauntletProjection`). A projection of another extension's history, not a contribution:
+  unversioned and only as stable as those tools' result shapes. A rendered plan line from the
+  plan slot replaces it in the footer.
+- **Phase** — `brainstorm → plan → implement → verify → ship`, each
+  `pending | in_progress | complete | skipped`.
+- **Gauntlet task status** — `pending | in_progress | complete | failed` (`GauntletTaskStatus`).
+  Not interchangeable with the contribution task status.
+- **hideGauntletWidgets** — opt-in setting to clear pi-gauntlet's own widgets on each reclaim,
+  since the footer already shows that data (`src/config.ts`).
+
+## Process vs session
+
+- **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 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. Its widgets are hidden by default.
-- Herdr: sibling status appears only when Pi is running inside Herdr.
+- `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 (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"`.
@@ -51,8 +54,8 @@ Project values override global values. A missing file, omitted key, or invalid v
 
 Supported keys:
 
-- `hideGauntletWidgets` (boolean, default `true`).
-- `editDiff` (`"always"` | `"never"` | `"expanded"`, default `"expanded"`) – when an `edit` row shows its diff. `"expanded"` puts it behind `ctrl+o`; `"always"` shows it inline as the edit lands (first 40 lines, the rest behind `ctrl+o`); `"never"` keeps the `+3 −1` stats only.
+- `hideGauntletWidgets` (boolean, default `false`) – when `true`, pi-minimal clears pi-gauntlet's `phase_tracker` and `plan_tracker` widgets each time it re-asserts its chrome (session start, turn end, tool end).
+- `editDiff` (`"always"` | `"never"` | `"expanded"`, default `"expanded"`) – when an `edit` row shows its diff. `"expanded"` shows diffs of up to 8 lines inline and puts longer ones behind `ctrl+o`; `"always"` shows every diff inline as the edit lands (first 40 lines, the rest behind `ctrl+o`); `"never"` keeps the `+3 −1` stats only. `write` rows show the written content behind `ctrl+o`.
 
 ```json
 { "hideGauntletWidgets": true, "editDiff": "always" }

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

@@ -3,8 +3,10 @@ import { join } from "node:path";
 import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
 export const EDIT_DIFF_MODES = ["always", "never", "expanded"];
 const DEFAULTS = {
-    hideGauntletWidgets: true,
+    // Hiding another extension's widgets is opt-in.
+    hideGauntletWidgets: false,
     editDiff: "expanded",
+    backgroundShortcut: "ctrl+b",
 };
 export function loadPiMinimalConfig(options) {
     const config = { ...DEFAULTS };
@@ -43,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() { },