@xynogen/pix-runtime 0.16.0 → 0.17.0

package/README.md

@@ -1,3 +1,7 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/xynogen/pix-mono/main/.github/assets/pix-logo.svg" alt="Pix" width="152" height="80">
+</p>
+
 # pix-runtime
 
 Pix's small shared runtime layer. It owns the process-wide config contract:
@@ -10,7 +14,7 @@ See `DESIGN.md` for the full contract.
 ## What it does
 
 - Versioned, sparse `pix.json` (`$version: 1`) — defaults resolve in code.
-- Typed sections: `collapse`, `pretty`, `io`, `compaction`, `edit`, `optimizer`, `gate`, `fetch`, `search`, `voice`, `toolbox`.
+- Typed sections: `collapse`, `pretty`, `io`, `compaction`, `edit`, `optimizer`, `gate`, `fetch`, `search`, `voice`, `notify`, `toolbox`.
 - `/pix` has a Footer tab for `pretty.footer` visibility.
 - Startup imports legacy service config files and archives them only after a successful save.
 - Atomic writes behind a serialized in-process queue and a short-lived
@@ -19,7 +23,9 @@ See `DESIGN.md` for the full contract.
 - Typed, path-filtered change events.
 - One-time migration of legacy unversioned config and the `optimizer.json`
   sidecar.
-- The `/pix` shared-settings command, with **Settings** and **Binaries** tabs.
+- The `/pix` shared-settings command, with **Settings** and **Binaries** tabs plus
+  tabs that packages register (for example **Notify** from pix-notify).
+  `/pix <tab>` opens a tab directly.
 - One catalog, resolver and downloader for every external command pix runs
   (`binaries`), plus shared `paths` and `platform` helpers.
 - **User shell** — user `!` commands run through PowerShell on Windows (pwsh 7,
@@ -67,8 +73,8 @@ pix-core consumes both settings.
 
 Over that threshold, pix-core masks older tool output before it summarizes.
 `compaction.maskKeep` (default `10`) is the number of newest tool results kept as
-is. Older successful `bash`/`grep`/`find`/`ls`/`read` output becomes a one-line
-stub; errors stay. `compaction.maskMinTokens` (default `5000`) skips a pass that
+is. Older successful `bash`/`grep`/`find`/`ls`/`read` output of 2,000 chars or more
+becomes a one-line stub; smaller output and errors stay. `compaction.maskMinTokens` (default `5000`) skips a pass that
 would free fewer tokens, because each pass breaks the prompt cache. Both are
 `pix.json` calibration knobs with no `/pix` picker.
 
@@ -297,37 +303,12 @@ const done = beginAgentActivity(pi.events, "subagent", "Agent running");
 done();
 ```
 
-### herdr notification bridge
-
-`src/herdr-notify.ts` (exported as `bindHerdrNotify`) is a leaf subscriber on
-`pix:agent-state`. When the agent transitions INTO `blocked` it spawns:
-
-```bash
-herdr notification show <message> --sound request
-```
-
-so a user away from their terminal gets a popup and sound. `request` is herdr's
-built-in "needs attention" cue. The trigger is edge-triggered: it fires once per
-entry into `blocked`, not repeatedly, and nested blocks stay a single
-notification.
-
-The bridge is fire-and-forget. The child is `detached`, `unref`'d, and
-`stdio: "ignore"`, and a missing `herdr` binary is swallowed, so it never blocks
-the prompt path or throws. herdr owns the toast's color, position, and sound via
-its own server config (`[toast]` / `[notification]`); pix only reports the moment
-and the message. Compaction and other autonomous work never enter `blocked`, so
-they never notify.
-
-It is wired automatically by the runtime extension: bound at session start,
-unbound at shutdown. No manual setup beyond running inside a herdr pane.
-
-Two environment variables control it:
+### Notifications
 
-- `HERDR_ENV` — herdr sets this to `1` inside its own pane. The bridge only runs
-  when `HERDR_ENV === "1"`; outside a herdr pane it is a no-op and spawns
-  nothing.
-- `PIX_HERDR_NOTIFY` — set to `0` to silence notifications even inside a herdr
-  pane.
+The runtime only emits `pix:agent-state`. The sound/popup on `blocked` lives in
+[`@xynogen/pix-notify`](https://www.npmjs.com/package/@xynogen/pix-notify): herdr
+notification inside a herdr pane, the configured system sound everywhere else.
+It reads the `notify` section (`enabled`, `sound`), edited in the `/pix` **Notify** tab.
 
 ## Testing
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-runtime",
-	"version": "0.16.0",
+	"version": "0.17.0",
 	"description": "Pix shared runtime — versioned pix.json config, atomic persistence, typed change events",
 	"type": "module",
 	"main": "src/index.ts",
@@ -36,6 +36,7 @@
 		"./testing": "./src/testing.ts",
 		"./exec": "./src/exec.ts",
 		"./os": "./src/os.ts",
+		"./sysstat": "./src/sysstat.ts",
 		"./audio": "./src/audio.ts",
 		"./safe-path": "./src/safe-path.ts",
 		"./which": "./src/which.ts",

package/src/binaries/catalog.ts

@@ -113,6 +113,29 @@ export const CATALOG = {
 			asset: (h, v) => (h.os === "win32" ? `aria2-${v}-win-64bit-build1.zip` : undefined),
 		},
 	},
+	herdr: {
+		usedBy: ["pix-notify"],
+		os: ["linux", "darwin"],
+		optional: true,
+		hint: { default: "see herdr.dev — only used inside a herdr pane" },
+	},
+	paplay: {
+		usedBy: ["pix-notify"],
+		os: LINUX,
+		optional: true,
+		// PulseAudio's player; PipeWire ships the same job as pw-play.
+		names: ["paplay", "pw-play"],
+		versionArgs: null,
+		hint: {
+			default: "apt install pulseaudio-utils · dnf install pulseaudio-utils · pacman -S libpulse",
+		},
+	},
+	afplay: {
+		usedBy: ["pix-notify"],
+		os: ["darwin"],
+		versionArgs: null,
+		hint: { default: "built into macOS" },
+	},
 	ffmpeg: {
 		usedBy: ["pix-voice"],
 		os: ["linux", "win32", "darwin"],
@@ -237,7 +260,7 @@ export const CATALOG = {
 		hint: { default: "npm install -g @earendil-works/pi-coding-agent" },
 	},
 	powershell: {
-		usedBy: ["pix-powershell", "pix-ask", "pix-voice"],
+		usedBy: ["pix-powershell", "pix-ask", "pix-voice", "pix-notify"],
 		os: ["win32", "linux"],
 		wslOnly: true,
 		// WSL reaches Windows PowerShell through interop as powershell.exe.

package/src/exec.ts

@@ -97,7 +97,7 @@ export interface ToolExecOptions {
 	onStatus?: (status: ToolStatus) => void;
 	/** Test seam for the host OS. */
 	host?: HostPlatform;
-	/** Cap on captured stdout/stderr bytes each (default 50 MB). */
+	/** Cap on captured stdout/stderr bytes each (default 50 MB). Past it the child is stopped. */
 	maxBuffer?: number;
 	/** Args are already quoted for the target (cmd.exe `/c` lines); Node must not re-quote. */
 	verbatim?: boolean;
@@ -111,7 +111,7 @@ export interface ToolRunResult {
 	/** Raw stdout for binary output (clipboard images, archives). */
 	stdoutBytes: Buffer;
 	timedOut: boolean;
-	/** Output passed `maxBuffer` and was cut. A zero exit code is then not a complete result. */
+	/** Output passed `maxBuffer`; the child was stopped and output cut. Never a complete result. */
 	truncated: boolean;
 	/** The binary that ran and where it was found. */
 	tool: ResolvedTool;
@@ -220,7 +220,11 @@ function collect(
 		let truncated = false;
 		const push = (list: Buffer[], chunk: Buffer, len: number): number => {
 			const room = cap - len;
-			if (chunk.length > room) truncated = true;
+			// Like pi.exec: stop a runaway child instead of draining output nobody keeps.
+			if (chunk.length > room) {
+				truncated = true;
+				stop();
+			}
 			if (room <= 0) return len;
 			list.push(chunk.length > room ? chunk.subarray(0, room) : chunk);
 			return len + Math.min(chunk.length, room);

package/src/extension.ts

@@ -5,7 +5,6 @@ import {
 	type ExtensionAPI,
 } from "@earendil-works/pi-coding-agent";
 import { syncBinaryStore } from "./binaries/store.ts";
-import { bindHerdrNotify } from "./herdr-notify.ts";
 import { bindAgentStateEvents, resetAgentState, resetUnattendedState } from "./herdr-state.ts";
 import { once } from "./once.ts";
 import { registerPixCommand } from "./pix-command.ts";
@@ -26,7 +25,6 @@ export default function registerRuntime(pi: ExtensionAPI): void {
 
 		registerPixCommand(pi, runtime);
 		const unbindAgentState = bindAgentStateEvents(pi.events);
-		const unbindHerdrNotify = bindHerdrNotify(pi.events);
 
 		// User `!` commands: PowerShell on Windows, $SHELL on POSIX (zsh gets rc + aliases).
 		const shell = userShell();
@@ -65,7 +63,6 @@ export default function registerRuntime(pi: ExtensionAPI): void {
 		pi.on("session_shutdown", async () => {
 			resetAgentState(pi.events);
 			resetUnattendedState(pi.events);
-			unbindHerdrNotify();
 			unbindAgentState();
 			await runtime.flush();
 		});

package/src/icon-catalog.ts

@@ -58,6 +58,12 @@ const CATALOG = {
 	"net.in": { nerd: "\u21E1", unicode: "\u21E1", ascii: "in" },
 	"net.out": { nerd: "\u21E3", unicode: "\u21E3", ascii: "out" },
 	score: { nerd: "\u26A1", unicode: "\u26A1", ascii: "S" },
+	// Distinct shapes: chip (CPU), card (GPU), stick (RAM). md-memory looks like the CPU chip.
+	"sys.cpu": { nerd: "\u{F4BC}", unicode: `\u2699${VS}`, ascii: "cpu" },
+	"sys.gpu": { nerd: "\u{F08AE}", unicode: `\u25A6${VS}`, ascii: "gpu" },
+	"sys.ram": { nerd: "\u{EFC5}", unicode: `\u2630${VS}`, ascii: "ram" },
+	"sys.temp": { nerd: "\u{F050F}", unicode: `\u2668${VS}`, ascii: "t" },
+	clock: { nerd: "\u{F0150}", unicode: `\u25F7${VS}`, ascii: "@" },
 
 	// ── misc ──────────────────────────────────────────────────────────────
 	ok: { nerd: "\u2713", unicode: "\u2713", ascii: "ok" },

package/src/index.ts

@@ -8,7 +8,6 @@ export type {
 	SubscribeOptions,
 } from "./events.ts";
 export { default } from "./extension.ts";
-export { bindHerdrNotify } from "./herdr-notify.ts";
 export {
 	beginAgentActivity,
 	bindAgentStateEvents,

package/src/os.ts

@@ -46,7 +46,7 @@ export function openCommand(
 	target: string,
 	host: HostPlatform,
 	app?: string,
-): { name: string; args: string[]; verbatim?: boolean } {
+): { name: string; args: string[]; verbatim?: boolean; cwd?: string } {
 	if (host.os === "darwin") return { name: "open", args: app ? ["-a", app, target] : [target] };
 	if (host.os === "win32") {
 		// `start` is a cmd.exe builtin; "" is its window-title argument.
@@ -54,8 +54,9 @@ export function openCommand(
 		return { name: "cmd", args: ["/d", "/s", "/c", `"${parts.join(" ")}"`], verbatim: true };
 	}
 	if (host.wsl && !app) {
-		// WSL: hand the target to Windows so the user's default browser opens.
-		return { name: "wslview", args: [target] };
+		// WSL: hand the target to Windows so the user's default browser opens. Windows programs
+		// cannot start from a long `\\wsl.localhost\...` cwd, so start from `/`.
+		return { name: "wslview", args: [target], cwd: "/" };
 	}
 	return { name: app ?? "xdg-open", args: [target] };
 }
@@ -71,6 +72,7 @@ export async function openTarget(target: string, opts: OpenOptions = {}): Promis
 	if (cmd.name === "wslview" && !resolveTool("wslview", opts))
 		cmd = openCommand(target, { ...host, wsl: false });
 	const result = await runTool(cmd.name, cmd.args, {
+		cwd: cmd.cwd,
 		env: opts.env,
 		host,
 		timeoutMs: opts.timeoutMs ?? 15_000,
@@ -140,10 +142,16 @@ export function pickPreferredMime(types: readonly string[]): string | null {
 }
 
 /** Output bytes when the tool exists and exits 0; null otherwise (probing, never throws). */
-function probe(name: string, args: string[], timeoutMs: number, opts: OsOptions): Buffer | null {
+function probe(
+	name: string,
+	args: string[],
+	timeoutMs: number,
+	opts: OsOptions,
+	cwd?: string,
+): Buffer | null {
 	if (!resolveTool(name, opts)) return null;
 	try {
-		const r = runToolSync(name, args, { env: opts.env, host: opts.host, timeoutMs });
+		const r = runToolSync(name, args, { env: opts.env, host: opts.host, timeoutMs, cwd });
 		return r.code === 0 ? r.stdoutBytes : null;
 	} catch {
 		return null;
@@ -203,7 +211,8 @@ function viaPowerShell(host: HostPlatform, opts: OsOptions): ClipboardImage | nu
 			"if ($img) { $img.Save($path, [System.Drawing.Imaging.ImageFormat]::Png); Write-Output 'ok' } else { Write-Output 'empty' }",
 		].join("; ");
 		const args = ["-NoProfile", "-STA", "-Command", script];
-		const out = probe("powershell", args, POWERSHELL_TIMEOUT_MS, opts);
+		// From WSL, Windows programs cannot start from a long `\\wsl.localhost\...` cwd.
+		const out = probe("powershell", args, POWERSHELL_TIMEOUT_MS, opts, host.wsl ? "/" : undefined);
 		if (out?.toString("utf-8").trim() !== "ok") return null;
 		const bytes = readFileSync(tmpFile);
 		return bytes.length ? { bytes, mimeType: "image/png" } : null;

package/src/pix-command.ts

@@ -42,6 +42,21 @@ function row<T>(r: SettingRow<T>): SettingRow<unknown> {
 	return r as SettingRow<unknown>;
 }
 
+/** Pi-owned theme row: not stored in pix.json, applied through `ctx.ui.setTheme`. */
+interface ThemeRow {
+	kind: "theme";
+	section: string;
+	label: string;
+	values: readonly string[];
+	current: () => string;
+}
+
+type Row = SettingRow<unknown> | ThemeRow;
+
+function isThemeRow(row: Row): row is ThemeRow {
+	return "kind" in row;
+}
+
 /** Render a token count as a compact label: 1_000_000 → "1M", 150_000 → "150k". */
 function formatTokens(tokens: number): string {
 	return tokens % 1_000_000 === 0 ? `${tokens / 1_000_000}M` : `${tokens / 1000}k`;
@@ -213,6 +228,20 @@ function binariesEnv(runtime: PixRuntime): NodeJS.ProcessEnv {
 	return { ...process.env, PI_CODING_AGENT_DIR: dirname(runtime.path) };
 }
 
+/**
+ * `target` with some properties replaced. Other reads go to `target` itself, so
+ * prototype methods keep working and are bound to the real instance (`this`).
+ */
+function forward<T extends object>(target: T, overrides: Record<string, () => unknown>): T {
+	return new Proxy(target, {
+		get(obj, key) {
+			if (typeof key === "string" && key in overrides) return overrides[key]?.();
+			const value = Reflect.get(obj, key, obj);
+			return typeof value === "function" ? value.bind(obj) : value;
+		},
+	});
+}
+
 const TABS = ["Settings", "Binaries", "Footer"] as const;
 /** Most frequently changed tabs sit leftmost; unknown package tabs go before rare ones. */
 const TAB_ORDER = ["Settings", "Tools", "MCP", "Optimizer", "Web", "Voice"];
@@ -291,12 +320,32 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 		if (data && typeof data === "object" && "registered" in data) data.registered = true;
 	});
 	pi.registerCommand("pix", {
-		description: "pix: open shared settings (edit pix.json)",
-		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+		description: "pix: open shared settings (edit pix.json); /pix <tab> opens that tab",
+		getArgumentCompletions: (prefix: string) => {
+			const p = prefix.trim().toLowerCase();
+			const items = [...TABS, ...packageSettings(pi).map((entry) => entry.label)]
+				.map((label) => label.toLowerCase())
+				.filter((name) => name.startsWith(p))
+				.map((name) => ({ value: name, label: name }));
+			return items.length ? items : null;
+		},
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
 			// Re-parse pix.json so section parsers remain the single validation source.
 			await runtime.reload({ origin: "command", source: "pix" });
 			const panels = packageSettings(pi);
 			const settings = visibleSettings(pi);
+			// Pi owns the active theme (settings.json); `/pix` only cycles it through `ctx.ui.setTheme`.
+			const themeNames = (ctx.ui.getAllThemes?.() ?? []).map((t) => t.name).sort();
+			const themeRow: ThemeRow | undefined =
+				themeNames.length > 1
+					? {
+							kind: "theme",
+							section: "Pretty",
+							label: "theme",
+							values: themeNames,
+							current: () => ctx.ui.theme.name ?? "",
+						}
+					: undefined;
 			// SAFETY: Runtime UI supports custom overlays beyond the published command context type.
 			const ui = ctx.ui as unknown as {
 				custom?: (f: unknown, opts?: unknown) => Promise<unknown>;
@@ -338,7 +387,8 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 						),
 						...panels.map((entry) => entry.label),
 					].sort((a, b) => tabRank(a) - tabRank(b));
-					let tab = "Settings";
+					const wanted = (args ?? "").trim().toLowerCase();
+					let tab = tabs.find((name) => name.toLowerCase() === wanted) ?? "Settings";
 					let embedded:
 						| { render(width: number): string[]; handleInput(data: string): void; dispose?(): void }
 						| undefined;
@@ -369,18 +419,14 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 									return new Promise<unknown>((resolve) => {
 										leavePanel = () => resolve(null);
 										// The /pix tab row takes one line; render() shrinks the panel's terminal until both fit.
-										const panelTui = {
-											...tui,
-											terminal: {
-												...tui.terminal,
-												get rows() {
-													return Math.max(
-														1,
-														(tui.terminal?.rows ?? process.stdout.rows ?? 24) - panelShrink,
-													);
-												},
-											},
-										};
+										// Proxies, not spreads: the real TUI and terminal are class instances whose
+										// methods (requestRender, columns) live on the prototype and a spread drops them.
+										const terminal = tui.terminal ?? {};
+										const panelTerminal = forward(terminal, {
+											rows: () =>
+												Math.max(1, (terminal.rows ?? process.stdout.rows ?? 24) - panelShrink),
+										});
+										const panelTui = forward(tui, { terminal: () => panelTerminal });
 										embedded = factory(panelTui, theme, kb, (value: unknown) => {
 											if (generation !== panelGeneration) return resolve(null);
 											if (value == null) {
@@ -429,11 +475,27 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 						mountPanel();
 					};
 
-					const rows = () =>
-						settings.filter((r) => (r.section === "Footer") === (tab === "Footer"));
+					// `/pix <tab>` opens straight into that tab.
+					if (tab === "Binaries") binariesTab().refresh();
+					mountPanel();
+
+					const rows = (): Row[] => {
+						const list = settings.filter((r) => (r.section === "Footer") === (tab === "Footer"));
+						return tab === "Settings" && themeRow ? [themeRow, ...list] : list;
+					};
 					const cycle = (direction: -1 | 1) => {
 						const row = rows()[selected];
 						if (!row) return;
+						if (isThemeRow(row)) {
+							const cur = row.values.indexOf(row.current());
+							const start = cur === -1 && direction === -1 ? 0 : cur;
+							const next = row.values[(start + direction + row.values.length) % row.values.length];
+							const result = next ? ctx.ui.setTheme(next) : undefined;
+							if (result && !result.success)
+								ui.notify(`pix: theme ${next}: ${result.error ?? "failed"}`, "error");
+							tui.requestRender();
+							return;
+						}
 						// Functional updater: the runtime queue serializes writes, and the
 						// callback sees the latest committed value — so rapid presses each
 						// advance exactly one step instead of collapsing on a stale snapshot.
@@ -538,8 +600,8 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 								const sel = i === selected;
 								const cursor = sel ? theme.fg("accent", "→") : " ";
 								const label = theme.fg(sel ? "accent" : "text", row.label.padEnd(labelW));
-								const value = row.read(runtime.get(row.handle));
-								const isDefault = value === row.read(row.handle.defaults);
+								const value = isThemeRow(row) ? row.current() : row.read(runtime.get(row.handle));
+								const isDefault = isThemeRow(row) || value === row.read(row.handle.defaults);
 								settingBodyLines[i] = body.length;
 								body.push(`${cursor} ${label}  ${theme.fg(isDefault ? "dim" : "success", value)}`);
 							}

package/src/registry.ts

@@ -28,6 +28,17 @@ export class SectionRegistry {
 		return this.byKey.get(key);
 	}
 
+	/**
+	 * Swap in a newer definition for a known key (Pi reload re-evaluates modules, but the
+	 * runtime singleton on globalThis survives with the old schema). True when it changed.
+	 */
+	adopt(handle: SectionHandle<string, unknown>): boolean {
+		if (!this.byKey.has(handle.key) || this.byKey.get(handle.key) === handle.__section)
+			return false;
+		this.byKey.set(handle.key, handle.__section);
+		return true;
+	}
+
 	all(): ConfigSection<unknown>[] {
 		return [...this.byKey.values()];
 	}

package/src/runtime.ts

@@ -40,6 +40,7 @@ import {
 	type SectionHandle,
 	stripDefaults,
 } from "./schema.ts";
+import { builtinSections } from "./sections/index.ts";
 
 export interface InitOptions {
 	origin?: ConfigChangeOrigin;
@@ -112,6 +113,13 @@ class RuntimeImpl implements PixRuntime {
 		return this.current !== null;
 	}
 
+	/** Adopt newer section definitions; drop the snapshot so the next read re-resolves them. */
+	adoptSections(handles: readonly SectionHandle<string, unknown>[]): void {
+		let changed = false;
+		for (const handle of handles) changed = this.registry.adopt(handle) || changed;
+		if (changed) this.current = null;
+	}
+
 	private parseContext(): ParseContext {
 		return { diagnostic: (d) => this.sink.push(d) };
 	}
@@ -492,6 +500,16 @@ export function pixRuntime(): PixRuntime {
 	return g[SINGLETON_KEY];
 }
 
+// A reload re-evaluates this module but keeps the singleton: hand it this copy's schemas,
+// or new keys (e.g. a new footer flag) are dropped on every read and write.
+// ponytail: last-evaluated copy wins. Version-skewed copies loading after a newer one
+// would hand back older schemas; compare a schema version here if that ever happens.
+(
+	(globalThis as Global)[SINGLETON_KEY] as
+		| { adoptSections?: (h: readonly SectionHandle<string, unknown>[]) => void }
+		| undefined
+)?.adoptSections?.(builtinSections);
+
 /** Test/entry hook: create an isolated runtime with injected adapters. */
 export function createRuntime(adapters: RuntimeAdapters = {}): PixRuntime {
 	return new RuntimeImpl(adapters);

package/src/sections/index.ts

@@ -34,6 +34,8 @@ import { prettySection } from "./pretty.ts";
 
 export {
 	fetchSection,
+	type NotifyConfig,
+	notifySection,
 	searchSection,
 	type ToolboxConfig,
 	toolboxSection,
@@ -42,7 +44,13 @@ export {
 	type WebConfig,
 } from "./services.ts";
 
-import { fetchSection, searchSection, toolboxSection, voiceSection } from "./services.ts";
+import {
+	fetchSection,
+	notifySection,
+	searchSection,
+	toolboxSection,
+	voiceSection,
+} from "./services.ts";
 
 /** All built-in sections, in stable registration order. */
 export const builtinSections = [
@@ -56,5 +64,6 @@ export const builtinSections = [
 	fetchSection,
 	searchSection,
 	voiceSection,
+	notifySection,
 	toolboxSection,
 ] as const;

package/src/sections/pretty.ts

@@ -32,6 +32,8 @@ export interface PrettyConfig {
 		| "tokens"
 		| "cost"
 		| "tps"
+		| "system"
+		| "clock"
 		| "wrap",
 		boolean
 	>;
@@ -72,6 +74,8 @@ const DEFAULTS: Readonly<PrettyConfig> = {
 		tokens: true,
 		cost: true,
 		tps: true,
+		system: true,
+		clock: true,
 		wrap: false,
 	},
 };

package/src/sections/services.ts

@@ -47,6 +47,18 @@ export const voiceSection = defineSection({
 		return result;
 	},
 });
+const notifyDefaults = { enabled: true, sound: "auto" };
+export type NotifyConfig = typeof notifyDefaults;
+export const notifySection = defineSection({
+	key: "notify",
+	defaults: notifyDefaults,
+	parse(raw): NotifyConfig {
+		const item = isObj(raw) ? raw : {};
+		const sound = typeof item.sound === "string" && item.sound.trim() ? item.sound.trim() : "auto";
+		return { enabled: boolOr(item.enabled, true), sound };
+	},
+});
+
 export interface ToolboxConfig {
 	disabledTools?: string[];
 	loadedTools?: string[];

package/src/sysstat.ts

@@ -0,0 +1,118 @@
+/**
+ * sysstat.ts — cheap host load sample for status bars: CPU %, RAM %, GPU %, CPU temperature.
+ *
+ * CPU and RAM come from `node:os`, so they work on every OS. GPU busy % and temperature
+ * are read from Linux sysfs (`/sys/class/drm`, `/sys/class/hwmon`, `/sys/class/thermal`);
+ * elsewhere, or when the driver exposes nothing, those fields are undefined.
+ * ponytail: no NVIDIA support (its driver has no sysfs busy file). Add an `nvidia-smi`
+ * catalog binary and a slow poll here if that is needed.
+ */
+
+import { readdirSync, readFileSync } from "node:fs";
+import { cpus, freemem, totalmem } from "node:os";
+import { join } from "node:path";
+
+export interface SystemStats {
+	/** Busy CPU since the previous sample, 0–100. Undefined on the first sample. */
+	cpu?: number;
+	/** Used memory (total − available), 0–100. */
+	ram?: number;
+	/** GPU busy, 0–100 (Linux amdgpu/i915/xe sysfs only). */
+	gpu?: number;
+	/** CPU package temperature in °C (Linux hwmon/thermal only). */
+	temp?: number;
+}
+
+/** Opaque CPU counter snapshot; pass the previous one to get a CPU percent. */
+export type CpuTimes = { busy: number; total: number };
+
+export function cpuTimes(): CpuTimes {
+	let busy = 0;
+	let total = 0;
+	for (const { times } of cpus()) {
+		const sum = times.user + times.nice + times.sys + times.idle + times.irq;
+		total += sum;
+		busy += sum - times.idle;
+	}
+	return { busy, total };
+}
+
+/** Busy share between two snapshots, 0–100, or undefined when no time passed. */
+export function cpuPercent(prev: CpuTimes, next: CpuTimes): number | undefined {
+	const total = next.total - prev.total;
+	if (total <= 0) return undefined;
+	return clampPct(((next.busy - prev.busy) / total) * 100);
+}
+
+const clampPct = (n: number) => Math.min(100, Math.max(0, Math.round(n)));
+
+function readNumber(path: string): number | undefined {
+	try {
+		const n = Number(readFileSync(path, "utf8").trim());
+		return Number.isFinite(n) ? n : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function list(dir: string): string[] {
+	try {
+		return readdirSync(dir);
+	} catch {
+		return [];
+	}
+}
+
+/** Highest `gpu_busy_percent` across DRM cards (a laptop may report an idle iGPU too). */
+export function readGpuBusy(sys = "/sys"): number | undefined {
+	let best: number | undefined;
+	for (const card of list(join(sys, "class/drm"))) {
+		if (!/^card\d+$/.test(card)) continue;
+		const n = readNumber(join(sys, "class/drm", card, "device/gpu_busy_percent"));
+		if (n !== undefined) best = Math.max(best ?? 0, clampPct(n));
+	}
+	return best;
+}
+
+// CPU sensor drivers, most specific first. coretemp = Intel, k10temp/zenpower = AMD.
+const CPU_HWMON = ["k10temp", "zenpower", "coretemp", "cpu_thermal", "acpitz"];
+
+/** CPU temperature in °C from hwmon (known CPU drivers), then thermal_zone0. */
+export function readCpuTemp(sys = "/sys"): number | undefined {
+	const hwmon = join(sys, "class/hwmon");
+	const byName = new Map<string, string>();
+	for (const dir of list(hwmon)) {
+		try {
+			byName.set(readFileSync(join(hwmon, dir, "name"), "utf8").trim(), dir);
+		} catch {}
+	}
+	for (const name of CPU_HWMON) {
+		const dir = byName.get(name);
+		const milli = dir && readNumber(join(hwmon, dir, "temp1_input"));
+		if (milli) return Math.round(milli / 1000);
+	}
+	const zone = readNumber(join(sys, "class/thermal/thermal_zone0/temp"));
+	return zone ? Math.round(zone / 1000) : undefined;
+}
+
+/**
+ * Take one sample. Keep the returned `times` and pass it back next call so CPU % covers
+ * the interval between calls. Synchronous and cheap (a few small sysfs reads).
+ */
+export function readSystemStats(
+	prev?: CpuTimes,
+	sys = "/sys",
+): { stats: SystemStats; times: CpuTimes } {
+	const times = cpuTimes();
+	const total = totalmem();
+	const linux = process.platform === "linux";
+	return {
+		times,
+		stats: {
+			cpu: prev ? cpuPercent(prev, times) : undefined,
+			ram: total > 0 ? clampPct(((total - freemem()) / total) * 100) : undefined,
+			gpu: linux ? readGpuBusy(sys) : undefined,
+			temp: linux ? readCpuTemp(sys) : undefined,
+		},
+	};
+}

package/src/herdr-notify.ts

@@ -1,39 +0,0 @@
-import { spawn } from "node:child_process";
-import type { EventBus } from "@earendil-works/pi-coding-agent";
-import type { PixAgentState, PixAgentStateEvent } from "./herdr-state.ts";
-
-/**
- * Leaf bridge: when the agent enters the `blocked` state (ask_user / gate /
- * sudo waiting on the user), fire a herdr notification so an away-from-pane
- * user gets a sound + popup. Fires only on the transition INTO blocked, never
- * repeatedly. No-op outside a herdr pane; silence with `PIX_HERDR_NOTIFY=0`.
- */
-export function bindHerdrNotify(events: EventBus, spawnFn = spawn): () => void {
-	// ponytail: gate on HERDR_ENV — herdr's own extension uses the same signal;
-	//           outside herdr the CLI would just no-op, so skip the spawn entirely.
-	if (process.env.HERDR_ENV !== "1" || process.env.PIX_HERDR_NOTIFY === "0") {
-		return () => {};
-	}
-	let last: PixAgentState | undefined;
-	const off = events.on("pix:agent-state", (raw) => {
-		const event = raw as PixAgentStateEvent;
-		if (event.state === "blocked" && last !== "blocked") {
-			notify(event.message ?? "Pi needs your attention", spawnFn);
-		}
-		last = event.state;
-	});
-	return off;
-}
-
-function notify(message: string, spawnFn: typeof spawn): void {
-	try {
-		const child = spawnFn("herdr", ["notification", "show", message, "--sound", "request"], {
-			stdio: "ignore",
-			detached: true,
-		});
-		child.on("error", () => {}); // herdr not on PATH — ignore
-		child.unref();
-	} catch {
-		// spawn threw synchronously; nothing actionable
-	}
-}