pi-minimal 0.5.0 → 0.6.0

package/test/background.test.ts

@@ -0,0 +1,198 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import {
+	applyPoll,
+	createBackgroundState,
+	createBackgroundTracker,
+	findOrphanGroups,
+	parseEtime,
+	parsePs,
+	PS_ARGS,
+	snapshot,
+} from "../src/background.js"
+import { backgroundRows, backgroundSegment, renderBackgroundLines } from "../src/background-overlay.js"
+
+// `ps -ax -o pid=,ppid=,pgid=,etime=,command=` as macOS prints it (right-aligned numbers).
+const PI = 76737
+const SHELL = 81443
+const psBefore = `
+ ${PI} 78317 ${PI}    04:11 pi
+ 81000     1 81000 01-02:03:04 /usr/libexec/trustd --agent
+`
+const psDuring = `${psBefore}
+ ${SHELL} ${PI} ${SHELL}    00:00 /bin/bash -c (./watch.sh &); sleep 0.3
+`
+const psAfter = `${psBefore}
+ 81446     1 ${SHELL}    00:01 /bin/bash ./watch.sh
+ 81450     1 ${SHELL}    00:01 node server.js
+ 81460     1 81460    00:00 /usr/libexec/other-daemon
+`
+
+test.describe("ps parsing", () => {
+	test("parseEtime handles every format", () => {
+		assert.equal(parseEtime("05"), 5)
+		assert.equal(parseEtime("04:11"), 251)
+		assert.equal(parseEtime("01:02:03"), 3723)
+		assert.equal(parseEtime("01-02:03:04"), 86400 + 7384)
+		assert.equal(parseEtime("garbage"), 0)
+	})
+
+	test("parsePs reads pid, ppid, pgid, etime and the full command", () => {
+		const entries = parsePs(psAfter)
+		assert.deepEqual(entries.get(81446), { pid: 81446, ppid: 1, pgid: SHELL, elapsedSec: 1, command: "/bin/bash ./watch.sh" })
+		assert.equal(entries.get(81000)?.elapsedSec, 86400 + 7384)
+		assert.equal(entries.size, 5)
+	})
+})
+
+test.describe("findOrphanGroups", () => {
+	test("finds the dead tool shell's group and ignores unrelated orphans and pre-existing groups", () => {
+		const groups = findOrphanGroups(parsePs(psBefore), parsePs(psAfter))
+		assert.deepEqual([...groups], [SHELL])
+	})
+
+	test("a group whose leader is still alive is a foreground call, not background", () => {
+		const groups = findOrphanGroups(parsePs(psBefore), parsePs(`${psDuring}\n 81446     1 ${SHELL}    00:01 node server.js`))
+		assert.equal(groups.size, 0)
+	})
+
+	test("a group that existed before the call belongs to someone else", () => {
+		const before = parsePs(`${psBefore}\n 81446     1 ${SHELL}    00:10 node server.js`)
+		assert.equal(findOrphanGroups(before, parsePs(psAfter)).size, 0)
+	})
+})
+
+test.describe("applyPoll", () => {
+	test("tracks members, marks them ended when gone, forgets them after the TTL and drops empty groups", () => {
+		const state = createBackgroundState()
+		state.groups.add(SHELL)
+		let now = 100_000
+		assert.equal(applyPoll(state, parsePs(psAfter), now), true)
+		let snap = snapshot(state)
+		assert.deepEqual(snap.running.map((p) => [p.pid, p.command, p.startedAt]), [
+			[81446, "/bin/bash ./watch.sh", now - 1000],
+			[81450, "node server.js", now - 1000],
+		])
+		assert.equal(snap.ended.length, 0)
+
+		// Nothing changed: no notification.
+		assert.equal(applyPoll(state, parsePs(psAfter), now + 2000), false)
+
+		// server.js exits.
+		now += 4000
+		const onlyWatch = psAfter.split("\n").filter((line) => !line.includes("server.js")).join("\n")
+		assert.equal(applyPoll(state, parsePs(onlyWatch), now), true)
+		snap = snapshot(state)
+		assert.deepEqual(snap.running.map((p) => p.pid), [81446])
+		assert.deepEqual(snap.ended.map((p) => [p.pid, p.endedAt]), [[81450, now]])
+
+		// Everything exits; the ended entries linger for a minute, then the group is dropped.
+		now += 2000
+		assert.equal(applyPoll(state, parsePs(psBefore), now), true)
+		assert.equal(snapshot(state).running.length, 0)
+		assert.equal(snapshot(state).ended.length, 2)
+		assert.equal(state.groups.has(SHELL), true)
+		now += 61_000
+		assert.equal(applyPoll(state, parsePs(psBefore), now), true)
+		assert.equal(snapshot(state).ended.length, 0)
+		assert.equal(state.groups.size, 0)
+	})
+})
+
+test.describe("overlay rendering", () => {
+	const theme = { fg: (_c: string, t: string) => t }
+
+	test("segment shows the running count only", () => {
+		assert.equal(backgroundSegment({ running: [], ended: [] }), undefined)
+		const proc = { pid: 1, pgid: 1, command: "x", startedAt: 0 }
+		assert.equal(backgroundSegment({ running: [proc, proc], ended: [proc] }), "⚙ 2 bg")
+	})
+
+	test("rows carry status and duration; lines fit the width and mark the selection", () => {
+		const now = 1_000_000
+		const rows = backgroundRows(
+			{
+				running: [{ pid: 10, pgid: 1, command: "npm run dev", startedAt: now - 252_000 }],
+				ended: [{ pid: 11, pgid: 1, command: "tail -f app.log", startedAt: now - 40_000, endedAt: now - 8000 }],
+			},
+			now,
+		)
+		assert.deepEqual(rows, [
+			{ pid: 10, command: "npm run dev", status: "running", durationMs: 252_000 },
+			{ pid: 11, command: "tail -f app.log", status: "ended", durationMs: 32_000 },
+		])
+		const lines = renderBackgroundLines(rows, 1, 60, theme, "ctrl+b")
+		assert.equal(lines.length, 4)
+		assert.match(lines[1] ?? "", /^ {2}npm run dev\s+running\s+4m 12s$/)
+		assert.match(lines[2] ?? "", /^› tail -f app.log\s+ended\s+ran 32s$/)
+		assert.ok(lines.every((line) => line.length <= 60))
+		assert.match(lines[3] ?? "", /ctrl\+b/)
+	})
+
+	test("empty list says so", () => {
+		const lines = renderBackgroundLines([], 0, 40, theme)
+		assert.match(lines[1] ?? "", /Nothing running/)
+	})
+})
+
+test.describe("createBackgroundTracker", () => {
+	const tick = () => new Promise((resolve) => setImmediate(resolve))
+	const settle = async () => { for (let i = 0; i < 6; i++) await tick() }
+
+	function fakePi(listings: string[]) {
+		const execCalls: string[][] = []
+		const pi = {
+			async exec(command: string, args: string[]) {
+				execCalls.push([command, ...args])
+				const stdout = listings.length > 1 ? (listings.shift() as string) : (listings[0] ?? "")
+				return { stdout, stderr: "", code: 0, killed: false }
+			},
+		} as unknown as ExtensionAPI
+		return { pi, execCalls }
+	}
+
+	test("a bash call that leaves processes behind is tracked; other tools are ignored", async () => {
+		const { pi, execCalls } = fakePi([psBefore, psAfter, psAfter])
+		const killed: Array<[number, string]> = []
+		let now = 500_000
+		const tracker = createBackgroundTracker({ pi, now: () => now, killProcess: (pid, signal) => { killed.push([pid, signal]) } })
+		let changes = 0
+		tracker.onChange(() => { changes += 1 })
+
+		tracker.toolStart("c1", "read")
+		tracker.toolEnd("c1", "read")
+		await settle()
+		assert.equal(execCalls.length, 0)
+
+		tracker.toolStart("c2", "bash")
+		await settle()
+		tracker.toolEnd("c2", "bash")
+		await settle()
+		assert.deepEqual(execCalls.slice(0, 2), [["ps", ...PS_ARGS], ["ps", ...PS_ARGS]])
+		assert.equal(changes, 1)
+		assert.deepEqual(tracker.get().running.map((p) => p.pid), [81446, 81450])
+
+		assert.equal(tracker.kill(81450), true)
+		assert.equal(tracker.kill(81446, { group: true, signal: "SIGKILL" }), true)
+		assert.equal(tracker.kill(99999), false)
+		assert.deepEqual(killed, [[81450, "SIGTERM"], [-SHELL, "SIGKILL"]])
+
+		now += 3000
+		tracker.dispose()
+		assert.deepEqual(tracker.get().running.map((p) => p.pid), [81446, 81450], "get() still answers after dispose")
+	})
+
+	test("a clean bash call tracks nothing and starts no poller", async () => {
+		const { pi, execCalls } = fakePi([psBefore, psBefore])
+		const tracker = createBackgroundTracker({ pi })
+		tracker.toolStart("c1", "bash")
+		tracker.toolEnd("c1", "bash")
+		await settle()
+		assert.equal(execCalls.length, 2)
+		assert.equal(tracker.get().running.length, 0)
+		await new Promise((resolve) => setTimeout(resolve, 30))
+		assert.equal(execCalls.length, 2, "no poll scheduled")
+		tracker.dispose()
+	})
+})

package/test/config.test.ts

@@ -30,7 +30,7 @@ test("defaults hideGauntletWidgets to false", (t) => {
 	const { agentDir, cwd } = setup(t)
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
@@ -39,7 +39,7 @@ test("global false overrides default", (t) => {
 	writeGlobal(agentDir, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false })
-	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
@@ -49,7 +49,7 @@ test("trusted project true overrides global false", (t) => {
 	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: true, editDiff: "expanded" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: true, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: true, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
@@ -59,7 +59,7 @@ test("untrusted project false does not override global true", (t) => {
 	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: false, editDiff: "expanded" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false })
-	assert.deepEqual(config, { hideGauntletWidgets: true, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: true, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
@@ -69,7 +69,7 @@ test("omitted keys do not override", (t) => {
 	writeProject(cwd, JSON.stringify({}))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
@@ -79,7 +79,7 @@ test("unknown keys do not override", (t) => {
 	writeProject(cwd, JSON.stringify({ extra: true }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 0)
 })
 
@@ -89,7 +89,7 @@ test("invalid JSON calls console.error and leaves the lower-precedence value unc
 	writeProject(cwd, "{")
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.ok(error.mock.callCount() >= 1)
 })
 
@@ -99,7 +99,7 @@ test("non-object root calls console.error and leaves the lower-precedence value
 	writeProject(cwd, JSON.stringify(["hideGauntletWidgets", false]))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.ok(error.mock.callCount() >= 1)
 })
 
@@ -109,7 +109,7 @@ test("non-boolean hideGauntletWidgets calls console.error and leaves the lower-p
 	writeProject(cwd, JSON.stringify({ hideGauntletWidgets: "yes" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "expanded", backgroundShortcut: "ctrl+b" })
 	assert.ok(error.mock.callCount() >= 1)
 })
 
@@ -129,7 +129,20 @@ test("an invalid editDiff value is reported and does not override", (t) => {
 	writeProject(cwd, JSON.stringify({ editDiff: "sometimes" }))
 	const error = t.mock.method(console, "error")
 	const config = loadPiMinimalConfig({ agentDir, cwd, projectTrusted: true })
-	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "always" })
+	assert.deepEqual(config, { hideGauntletWidgets: false, editDiff: "always", backgroundShortcut: "ctrl+b" })
 	assert.equal(error.mock.callCount(), 1)
 	assert.match(String(error.mock.calls[0]!.arguments[0]), /editDiff must be one of "always", "never", "expanded"/)
 })
+
+test("backgroundShortcut accepts a key name or null and rejects other values", (t) => {
+	const { agentDir, cwd } = setup(t)
+	writeGlobal(agentDir, JSON.stringify({ backgroundShortcut: "ctrl+g" }))
+	assert.equal(loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false }).backgroundShortcut, "ctrl+g")
+	writeGlobal(agentDir, JSON.stringify({ backgroundShortcut: null }))
+	assert.equal(loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false }).backgroundShortcut, null)
+	const errors: string[] = []
+	t.mock.method(console, "error", (message: string) => { errors.push(message) })
+	writeGlobal(agentDir, JSON.stringify({ backgroundShortcut: 7 }))
+	assert.equal(loadPiMinimalConfig({ agentDir, cwd, projectTrusted: false }).backgroundShortcut, "ctrl+b")
+	assert.match(errors.join("\n"), /backgroundShortcut/)
+})

package/test/footer-composition.test.ts

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict"
 import test from "node:test"
 import { initTheme, type ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { visibleWidth } from "@earendil-works/pi-tui"
 import { installFooter } from "../src/footer.js"
 import { createFooterContributions, type ActivitySnapshot } from "../src/footer-contributions.js"
 
@@ -23,6 +24,8 @@ const data = (revision: number, motion: "spinner" | "static" = "spinner"): Activ
   revision, rows: [{ key: "1", agent: "worker", state: "running", text: "Last: tests" }], omitted: 0, motion, format: "icons",
 })
 const sources = { busy: () => false, editorText: () => "", contextPct: () => 10 }
+// eslint-disable-next-line no-control-regex
+const stripAnsi = (text: string) => text.replace(/\x1b\[[0-9;]*m/g, "")
 
 test("no contributor preserves existing footer; activity is last even while typing/busy", () => {
   const f = fixture(), registry = createFooterContributions("S1")
@@ -127,3 +130,61 @@ test("legacy task summary precedes activity", () => {
   assert.ok(lines.at(-1)?.includes("worker"))
   dispose()
 })
+
+test("background count follows the hints and survives hiding them", () => {
+  const f = fixture()
+  let bg: string | undefined = "⚙ 2 bg"
+  let listener: (() => void) | undefined
+  const bgSources = {
+    ...sources,
+    background: () => bg,
+    onBackgroundChange: (l: () => void) => { listener = l; return () => { listener = undefined } },
+    prs: () => "#24",
+  }
+  const stop = installFooter(f.ctx, bgSources)
+  const component = f.mount()
+  assert.match(stripAnsi(component.render(80)[0] ?? ""), /^ enter send.*expand tools {2}· {2}⚙ 2 bg\s+#24$/)
+  stop(); component.dispose?.()
+  const typingStop = installFooter(f.ctx, { ...bgSources, busy: () => true })
+  const typing = f.mount()
+  assert.match(typing.render(80)[0] ?? "", /^ ⚙ 2 bg\s+#24$/)
+  const before = f.renders
+  bg = undefined
+  listener?.()
+  assert.equal(f.renders, before + 1)
+  assert.deepEqual(typing.render(80).map((line) => line.trim()), ["#24"])
+  typingStop(); typing.dispose?.()
+  assert.equal(listener, undefined)
+})
+
+test("PR chips sit right-aligned on the hints line, stay when hints hide, and re-render on change", () => {
+  const f = fixture()
+  let chips: string | undefined = "#23 #22"
+  let listener: (() => void) | undefined
+  const prsSources = {
+    ...sources,
+    prs: () => chips,
+    onPrsChange: (l: () => void) => { listener = l; return () => { listener = undefined } },
+  }
+  const stop = installFooter(f.ctx, prsSources)
+  const component = f.mount()
+  const idle = component.render(80)
+  assert.equal(idle.length, 1)
+  assert.match(idle[0] ?? "", /^ \S.*send.*#23 #22$/)
+  assert.equal(visibleWidth(idle[0] ?? ""), 1 + 78, "chips are flush right within the margin")
+
+  // Typing hides the hints; the chips keep the line.
+  stop(); component.dispose?.()
+  const typingStop = installFooter(f.ctx, { ...prsSources, editorText: () => "draft" })
+  const typing = f.mount()
+  assert.deepEqual(typing.render(80).map((line) => line.trim()), ["#23 #22"])
+
+  // A change notification triggers a render; no chips, no line.
+  const before = f.renders
+  chips = undefined
+  listener?.()
+  assert.equal(f.renders, before + 1)
+  assert.deepEqual(typing.render(80), [])
+  typingStop(); typing.dispose?.()
+  assert.equal(listener, undefined, "unsubscribed on dispose")
+})

package/test/index.test.ts

@@ -17,11 +17,17 @@ type SessionMode = "tui" | "rpc" | "json" | "print"
 
 const AGENT_DIR_ENV = "PI_CODING_AGENT_DIR"
 const originalHerdrEnv = process.env.HERDR_ENV
+const originalRexSession = process.env.REX_SESSION
+const originalRexBlock = process.env.REX_BLOCK
 const originalAgentDir = process.env[AGENT_DIR_ENV]
 
 function restoreEnv() {
 	if (originalHerdrEnv === undefined) delete process.env.HERDR_ENV
 	else process.env.HERDR_ENV = originalHerdrEnv
+	if (originalRexSession === undefined) delete process.env.REX_SESSION
+	else process.env.REX_SESSION = originalRexSession
+	if (originalRexBlock === undefined) delete process.env.REX_BLOCK
+	else process.env.REX_BLOCK = originalRexBlock
 	if (originalAgentDir === undefined) delete process.env[AGENT_DIR_ENV]
 	else process.env[AGENT_DIR_ENV] = originalAgentDir
 }
@@ -90,6 +96,9 @@ function createFake(options: {
 			if (command === "herdr" && args[0] === "agent") {
 				return { stdout: JSON.stringify({ result: { agents: [] } }), stderr: "", code: 0, killed: false }
 			}
+			if (command === "gh") {
+				return { stdout: "", stderr: "not a github repo", code: 1, killed: false }
+			}
 			if (command === "herdr" && args[0] === "tab") {
 				return { stdout: JSON.stringify({ result: { tabs: [] } }), stderr: "", code: 0, killed: false }
 			}
@@ -98,6 +107,12 @@ function createFake(options: {
 		registerTool(...args: unknown[]) {
 			record(registerCalls, "registerTool", args)
 		},
+		registerCommand(...args: unknown[]) {
+			record(registerCalls, "registerCommand", args)
+		},
+		registerShortcut(...args: unknown[]) {
+			record(registerCalls, "registerShortcut", args)
+		},
 		registerToolRenderer(...args: unknown[]) {
 			record(registerCalls, "registerToolRenderer", args)
 		},
@@ -136,6 +151,8 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		const { agentDir, cwd } = setupDirs(t)
 		process.env[AGENT_DIR_ENV] = agentDir
 		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
 		t.after(restoreEnv)
 
 		const hideThinking = t.mock.method(SettingsManager.prototype, "setHideThinkingBlock")
@@ -172,6 +189,8 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		const { agentDir, cwd } = setupDirs(t)
 		process.env[AGENT_DIR_ENV] = agentDir
 		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
 		t.after(restoreEnv)
 
 		const { pi, allCalls, emit } = createFake({ cwd })
@@ -197,7 +216,7 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		assert.ok(firstHeader < firstReclaim, "header before reclaim")
 		assert.ok(firstFooter < firstReclaim, "footer before reclaim")
 		assert.ok(firstCwd < firstReclaim, "cwd before reclaim")
-		assert.equal(allCalls.some((call) => call.method === "registerTool"), false, "built-in tools are not re-registered")
+		assert.deepEqual(allCalls.filter((call) => call.method === "registerTool").map((call) => (call.args[0] as { name: string }).name), ["list_open_prs"], "only pi-minimal's own tool is registered")
 	})
 
 	test("clears Gauntlet widgets on every chrome reassertion when hiding is opted in, and never on a timer", async (t) => {
@@ -205,6 +224,8 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		writeFileSync(join(agentDir, "pi-minimal.json"), JSON.stringify({ hideGauntletWidgets: true }))
 		process.env[AGENT_DIR_ENV] = agentDir
 		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
 		t.after(restoreEnv)
 
 		const { pi, uiCalls, emit } = createFake({ cwd, projectTrusted: true })
@@ -225,6 +246,8 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		writeFileSync(join(agentDir, "pi-minimal.json"), JSON.stringify({ hideGauntletWidgets: false }))
 		process.env[AGENT_DIR_ENV] = agentDir
 		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
 		t.after(restoreEnv)
 
 		const { pi, uiCalls, emit } = createFake({ cwd, projectTrusted: true })
@@ -243,6 +266,8 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		const { agentDir, cwd } = setupDirs(t)
 		process.env[AGENT_DIR_ENV] = agentDir
 		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
 		t.after(restoreEnv)
 
 		const { pi, execCalls, emit } = createFake({ cwd })
@@ -261,6 +286,46 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		const { agentDir, cwd } = setupDirs(t)
 		process.env[AGENT_DIR_ENV] = agentDir
 		process.env.HERDR_ENV = "1"
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
+		t.after(restoreEnv)
+
+		const { pi, execCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+
+		assert.equal(herdrProbes(execCalls).length, 1)
+		assert.equal(execCalls.filter((call) => call.args[0] === "rex").length, 0)
+	})
+
+	test("inside Rex (REX_SESSION + REX_BLOCK) it reads the Rex session instead of herdr", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		process.env.REX_SESSION = "session:test"
+		process.env.REX_BLOCK = "block:self"
+		t.after(restoreEnv)
+
+		const { pi, execCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+		await new Promise((resolve) => setTimeout(resolve, 20))
+
+		assert.equal(herdrProbes(execCalls).length, 0)
+		assert.deepEqual(
+			execCalls.filter((call) => call.args[0] === "rex").map((call) => call.args[1]),
+			[["window", "ls", "-s", "session:test", "--json"]],
+		)
+	})
+
+	test("Herdr wins when both Herdr and Rex are present", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		process.env.HERDR_ENV = "1"
+		process.env.REX_SESSION = "session:test"
+		process.env.REX_BLOCK = "block:self"
 		t.after(restoreEnv)
 
 		const { pi, execCalls, emit } = createFake({ cwd })
@@ -269,12 +334,97 @@ test.describe("session chrome", { concurrency: 1 }, () => {
 		await emit("session_start")
 
 		assert.equal(herdrProbes(execCalls).length, 1)
+		assert.equal(execCalls.filter((call) => call.args[0] === "rex").length, 0)
+	})
+
+	test("registers /bg and the background shortcut once, honouring backgroundShortcut", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		writeFileSync(join(agentDir, "pi-minimal.json"), JSON.stringify({ backgroundShortcut: "ctrl+g" }))
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
+		t.after(restoreEnv)
+
+		const { pi, registerCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		assert.ok(registerCalls.some((call) => call.method === "registerCommand" && call.args[0] === "bg"))
+		assert.equal(registerCalls.filter((call) => call.method === "registerShortcut").length, 0, "shortcut waits for session config")
+		await emit("session_start")
+		await emit("session_start")
+		const shortcuts = registerCalls.filter((call) => call.method === "registerShortcut")
+		assert.deepEqual(shortcuts.map((call) => call.args[0]), ["ctrl+g"])
+	})
+
+	test("a TUI session asks gh for the repo once and registers /prs", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
+		t.after(restoreEnv)
+
+		const { pi, execCalls, registerCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		assert.ok(registerCalls.some((call) => call.method === "registerCommand" && call.args[0] === "prs"))
+		await emit("session_start")
+		await new Promise((resolve) => setTimeout(resolve, 20))
+		assert.deepEqual(execCalls.filter((call) => call.args[0] === "gh").map((call) => call.args[1]), [["repo", "view", "--json", "nameWithOwner,url"]])
+	})
+
+	test("a bash call running gh pr create records the PR URL as a session entry", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
+		t.after(restoreEnv)
+
+		const { pi, execCalls, registerCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+		await emit("tool_execution_start", { toolCallId: "b1", toolName: "bash", args: { command: "gh pr create --fill" } })
+		await emit("tool_execution_end", {
+			toolCallId: "b1", toolName: "bash", isError: false,
+			result: { content: [{ type: "text", text: "Creating pull request…\nhttps://github.com/raviy06/pi-minimal/pull/24\n" }] },
+		})
+		await new Promise((resolve) => setTimeout(resolve, 20))
+		const entries = registerCalls.filter((call) => call.method === "appendEntry")
+		assert.deepEqual(entries.map((call) => call.args), [["pi-minimal.pr", { url: "https://github.com/raviy06/pi-minimal/pull/24" }]])
+		assert.ok(execCalls.some((call) => call.args[0] === "gh" && (call.args[1] as string[])[1] === "view"), "the PR is fetched by URL")
+	})
+
+	test("bash tool calls are inspected with ps; other tools are not", async (t) => {
+		const { agentDir, cwd } = setupDirs(t)
+		process.env[AGENT_DIR_ENV] = agentDir
+		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
+		t.after(restoreEnv)
+
+		const { pi, execCalls, emit } = createFake({ cwd })
+		install(pi)
+		t.after(() => emit("session_shutdown"))
+		await emit("session_start")
+		await emit("tool_execution_start", { toolCallId: "r1", toolName: "read" })
+		await emit("tool_execution_end", { toolCallId: "r1", toolName: "read" })
+		await new Promise((resolve) => setTimeout(resolve, 10))
+		assert.equal(execCalls.filter((call) => call.args[0] === "ps").length, 0)
+		await emit("tool_execution_start", { toolCallId: "b1", toolName: "bash" })
+		await emit("tool_execution_end", { toolCallId: "b1", toolName: "bash" })
+		await new Promise((resolve) => setTimeout(resolve, 10))
+		assert.equal(execCalls.filter((call) => call.args[0] === "ps").length, 2)
 	})
 
 	test("non-TUI modes install no TUI components", async (t) => {
 		const { agentDir, cwd } = setupDirs(t)
 		process.env[AGENT_DIR_ENV] = agentDir
 		delete process.env.HERDR_ENV
+		delete process.env.REX_SESSION
+		delete process.env.REX_BLOCK
 		t.after(restoreEnv)
 
 		const { pi, uiCalls, execCalls, emit } = createFake({ cwd, mode: "print" })
@@ -307,6 +457,8 @@ test("footer registration survives chrome reinstalls and becomes inert on shutdo
 	const { agentDir, cwd } = setupDirs(t)
 	process.env[AGENT_DIR_ENV] = agentDir
 	delete process.env.HERDR_ENV
+	delete process.env.REX_SESSION
+	delete process.env.REX_BLOCK
 	t.after(restoreEnv)
 	const { pi, emit, events, uiCalls } = createFake({ cwd })
 	install(pi)
@@ -332,6 +484,8 @@ test("agent_end appends a turn summary entry in TUI mode", async (t) => {
 	const { agentDir, cwd } = setupDirs(t)
 	process.env[AGENT_DIR_ENV] = agentDir
 	delete process.env.HERDR_ENV
+	delete process.env.REX_SESSION
+	delete process.env.REX_BLOCK
 	t.after(restoreEnv)
 	const { pi, registerCalls, emit } = createFake({ cwd })
 	install(pi)
@@ -354,6 +508,8 @@ test("a second session_start disposes the first session's chrome and the stale o
 	const { agentDir, cwd } = setupDirs(t)
 	process.env[AGENT_DIR_ENV] = agentDir
 	delete process.env.HERDR_ENV
+	delete process.env.REX_SESSION
+	delete process.env.REX_BLOCK
 	t.after(restoreEnv)
 	const { pi, emit, events, uiCalls } = createFake({ cwd })
 	install(pi)