pi-minimal 0.5.0 → 0.6.0

package/dist/rex.js

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

package/dist/session.js

@@ -7,17 +7,35 @@ import { bindFooterContributionEvents } from "./footer-contribution-events.js";
 import { createFooterContributions } from "./footer-contributions.js";
 import { createGitState } from "./git-state.js";
 import { installHeader } from "./header.js";
-import { listSiblings, parseAgentList, parseTabList } from "./herdr.js";
+import { createBackgroundTracker } from "./background.js";
+import { backgroundSegment } from "./background-overlay.js";
+import { createPrSource, findPrUrls, prSegment } from "./prs.js";
 import { applyReclaim, reclaimPolicy } from "./reclaim.js";
+import { createSiblingSource } from "./siblings.js";
 import { setSessionCwd } from "./tool-rows.js";
 import { setEditDiffMode } from "./tools.js";
 import { hideGauntletWidgets } from "./tracker.js";
-const HERDR_FAST_MS = 2000;
-const HERDR_SLOW_MS = 10000;
-const HERDR_EXEC_TIMEOUT_MS = 3000;
+/** Custom session entry remembering a PR this session created, so a resumed session shows it. */
+export const PR_ENTRY_TYPE = "pi-minimal.pr";
+function readSessionPrs(ctx) {
+    const urls = [];
+    try {
+        for (const entry of ctx.sessionManager.getBranch()) {
+            if (entry.type !== "custom" || entry.customType !== PR_ENTRY_TYPE)
+                continue;
+            const url = entry.data?.url;
+            if (typeof url === "string")
+                urls.push(url);
+        }
+    }
+    catch {
+        // No branch available (tests, odd hosts): start empty.
+    }
+    return urls;
+}
 /**
- * Everything pi-minimal owns for one session: config, cwd, the contribution registry, the git and
- * Herdr pollers, and the header/footer/status-line chrome. Disposal stops every timer and makes
+ * Everything pi-minimal owns for one session: config, cwd, the contribution registry, the git
+ * poller, the sibling source (Herdr or Rex), and the header/footer/status-line chrome. Disposal stops every timer and makes
  * late async results inert, so two sessions in one process never share or overwrite each other's
  * state. Non-TUI sessions get a session too, but it only binds the contribution protocol (which
  * replies `not-tui`) and installs no chrome.
@@ -28,7 +46,7 @@ export function createSession(pi, ctx, deps) {
     const contributions = createFooterContributions();
     const stopContributionEvents = bindFooterContributionEvents(pi.events, contributions, id, ctx.mode);
     if (ctx.mode !== "tui") {
-        return { id, pin() { }, refreshGit() { }, dispose() { if (!alive)
+        return { id, pin() { }, refreshGit() { }, notePrUrls() { }, dispose() { if (!alive)
                 return; alive = false; stopContributionEvents(); } };
     }
     const config = loadPiMinimalConfig({ agentDir: getAgentDir(), cwd: ctx.cwd, projectTrusted: ctx.isProjectTrusted() });
@@ -44,9 +62,8 @@ export function createSession(pi, ctx, deps) {
     const gitState = createGitState(pi, () => ctx.cwd);
     let stopFooter = () => { };
     let siblings;
-    let herdrTimer;
-    let herdrPeriod = 0;
-    let herdrInFlight;
+    const background = createBackgroundTracker({ pi });
+    const prs = createPrSource({ pi, cwd: () => ctx.cwd, sessionPrs: readSessionPrs(ctx) });
     const settleTimers = [];
     const contextPct = () => {
         const usage = ctx.getContextUsage?.();
@@ -61,10 +78,25 @@ export function createSession(pi, ctx, deps) {
             busy: deps.busy,
             editorText: () => (typeof ctx.ui.getEditorText === "function" ? ctx.ui.getEditorText() : ""),
             contextPct,
+            prs: (theme) => {
+                const snap = prs.get();
+                return prSegment(snap.prs, theme, 4, snap.repo ? `${snap.repo.host}/${snap.repo.nameWithOwner}` : undefined);
+            },
+            onPrsChange: prs.onChange,
+            background: () => backgroundSegment(background.get()),
+            onBackgroundChange: background.onChange,
         }, contributions);
     };
     const installStatusLine = () => {
-        installCwd(ctx, { gitState: gitState.get, siblings: () => siblings, onGitChange: gitState.onChange });
+        installCwd(ctx, {
+            gitState: gitState.get,
+            siblings: () => siblings?.get(),
+            onChange(listener) {
+                const offGit = gitState.onChange(listener);
+                const offSiblings = siblings?.onChange(listener) ?? (() => { });
+                return () => { offGit(); offSiblings(); };
+            },
+        });
     };
     const pin = (reason) => {
         if (!alive)
@@ -79,45 +111,9 @@ export function createSession(pi, ctx, deps) {
         ctx.ui.setWidget("tw-cwd", undefined);
         installStatusLine();
     };
-    const scheduleHerdr = (periodMs) => {
-        if (!alive || herdrPeriod === periodMs)
-            return;
-        if (herdrTimer)
-            clearInterval(herdrTimer);
-        herdrPeriod = periodMs;
-        herdrTimer = setInterval(() => { void probeHerdr(); }, periodMs);
-    };
-    const probeHerdr = async () => {
-        if (!alive || herdrInFlight)
-            return;
-        const ac = new AbortController();
-        herdrInFlight = 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) {
-                siblings = undefined;
-                scheduleHerdr(HERDR_SLOW_MS);
-                return;
-            }
-            siblings = listSiblings(parseAgentList(agentRun.stdout), parseTabList(tabRun.stdout), process.env.HERDR_PANE_ID, process.env.HERDR_TAB_ID);
-            scheduleHerdr(siblings ? HERDR_FAST_MS : HERDR_SLOW_MS);
-        }
-        catch {
-            if (!alive)
-                return;
-            siblings = undefined;
-            scheduleHerdr(HERDR_SLOW_MS);
-        }
-        finally {
-            if (herdrInFlight === ac)
-                herdrInFlight = undefined;
-        }
-    };
+    // The source is chosen from the environment (HERDR_ENV, else REX_SESSION/REX_BLOCK); start it
+    // before the status line so its onChange subscription is live.
+    siblings = createSiblingSource({ pi, spawn: deps.spawn });
     // Install once, then re-assert shortly after: other extensions' session_start handlers may draw after ours.
     installHeader(ctx);
     installChromeFooter();
@@ -128,24 +124,41 @@ export function createSession(pi, ctx, deps) {
     ctx.ui.setWorkingIndicator();
     for (const delay of [0, 50])
         settleTimers.push(setTimeout(() => pin("session_settle"), delay));
-    if (process.env.HERDR_ENV === "1")
-        void probeHerdr();
     return {
         id,
+        background,
+        backgroundShortcut: config.backgroundShortcut,
+        prs,
+        notePrUrls(text) {
+            if (!alive)
+                return;
+            const known = new Set(prs.sessionPrs());
+            for (const url of findPrUrls(text)) {
+                if (known.has(url))
+                    continue;
+                prs.addSessionPr(url);
+                try {
+                    pi.appendEntry?.(PR_ENTRY_TYPE, { url });
+                }
+                catch {
+                    // A session that cannot accept entries just forgets the PR on restart.
+                }
+            }
+        },
         pin,
-        refreshGit(force) { if (alive)
-            void gitState.refresh(force); },
+        refreshGit(force) { if (alive) {
+            void gitState.refresh(force);
+            void prs.refresh();
+        } },
         dispose() {
             if (!alive)
                 return;
             alive = false;
             for (const timer of settleTimers.splice(0))
                 clearTimeout(timer);
-            if (herdrTimer)
-                clearInterval(herdrTimer);
-            herdrTimer = undefined;
-            herdrInFlight?.abort();
-            herdrInFlight = undefined;
+            background.dispose();
+            prs.dispose();
+            siblings?.dispose();
             siblings = undefined;
             gitState.dispose();
             stopFooter();

package/dist/siblings.js

@@ -0,0 +1,14 @@
+import { createHerdrSiblings } from "./herdr.js";
+import { createRexSiblings } from "./rex.js";
+/**
+ * Picks the host the session runs in. Herdr wins when both are present (Rex inside a Herdr pane):
+ * Herdr knows every agent it launched, Rex only the programs that report status.
+ */
+export function createSiblingSource(deps) {
+    const env = deps.env ?? process.env;
+    if (env.HERDR_ENV === "1")
+        return createHerdrSiblings(deps.pi, env);
+    if (env.REX_SESSION && env.REX_BLOCK)
+        return createRexSiblings({ pi: deps.pi, env, spawn: deps.spawn });
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-minimal",
-  "version": "0.5.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,57 +1,44 @@
-Session lifecycle, one tool-row lifecycle, and a domain glossary. `hideGauntletWidgets`
-is now opt-in and the 200 ms chrome steal interval is gone.
+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
 
-- `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"]`.
+- 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
 
-- `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.
+- 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
-* refactor: per-session lifecycle, no chrome steal interval, hideGauntletWidgets opt-in by @raviy06 in https://github.com/raviy06/pi-minimal/pull/19
-* refactor(tools): one row lifecycle + strategies; write content on expand; small diffs inline by @raviy06 in https://github.com/raviy06/pi-minimal/pull/20
-* docs: CONTEXT.md glossary, clearer internal names, 'plan' slot alias (0.5.0) by @raviy06 in https://github.com/raviy06/pi-minimal/pull/21
+* 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.4.0...v0.5.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.5.0   # or: pi update --extensions
+pi install npm:pi-minimal@0.6.0   # or: pi update --extensions
 ```