@xynogen/pix-optimizer 1.1.9 → 1.1.12

package/README.md

@@ -4,10 +4,10 @@ Token-optimization suite for Pi Coding Agent. Four tools wired into one
 extension via `src/index.ts`, fronted by a single `/optimizer` command and one
 shared status-bar cell:
 
-- **Caveman** (`󰜐`) — terse-output system prompt
-- **RTK** (`󰓥`) — prefixes shell commands with `rtk` + injects RTK prompt
-- **TOON** (`󰗀`) — jq + TOON guidance for dense JSON (skill lives in pix-skills)
-- **Ponytail** (`󰆐`) — lazy-senior-dev system prompt (minimal code, YAGNI)
+- **Caveman** (`Cv`) — terse-output system prompt
+- **RTK** (`Rk`) — prefixes shell commands with `rtk` + injects RTK prompt
+- **TOON** (`Tn`) — jq + TOON guidance for dense JSON (skill lives in pix-skills)
+- **Ponytail** (`Pt`) — lazy-senior-dev system prompt (minimal code, YAGNI)
 
 ## Command
 
@@ -30,13 +30,13 @@ state: **accent** when the tool is enabled, **dim** when disabled.
 
 ### Icon style (Nerd Font, Unicode, or ASCII)
 
-The default glyphs (`󰜐 󰓥 󰗀 󰆐`) are **Nerd Font** symbols and require a patched
+The default glyphs (Nerd Font PUA codepoints) are **Nerd Font** symbols and require a patched
 font (e.g. MesloLGS NF). Terminals without one render them as missing-glyph
 “tofu” boxes. Two font-independent fallbacks are available:
 
 | Mode | Glyphs | Needs Nerd Font? |
 |---|---|---|
-| `nerd` (default) | `󰜐 󰓥 󰗀 󰆐` | yes |
+| `nerd` (default) | Nerd Font PUA glyphs | yes |
 | `unicode` | `♤ ♡ ♢ ♧` (outline card suits) | no |
 | `ascii` | `Cv Rk Tn Pt` | no |
 
@@ -44,16 +44,12 @@ Switch the style live from the **`/optimizer` overlay** — a fifth `icons` row
 at the bottom cycles `nerd → unicode → ascii` with `←→`; the choice persists to
 `~/.pi/agent/optimizer.json`.
 
-Or set it via env var (a persisted menu choice takes precedence):
-
-```bash
-export OPTIMIZER_ICONS=unicode   # nerd | unicode | ascii
-export PRETTY_ICONS=none         # stack-wide: also maps the cell to ASCII
-```
+Icons follow the **global** `pix-pretty` mode — set via `/pretty` or `PRETTY_ICONS`
+env var. The optimizer no longer has its own toggle.
 
 ## Features
 
-### Caveman Mode (`󰜐`)
+### Caveman Mode (`Cv`)
 
 Cuts ~75% of output tokens while keeping full technical accuracy.
 
@@ -67,7 +63,7 @@ Cuts ~75% of output tokens while keeping full technical accuracy.
 The `/optimizer` overlay opens a settings dialog when needed. Default level
 for new sessions is restored from `~/.pi/agent/optimizer.json`.
 
-### RTK Tool Rewriting (`󰓥`)
+### RTK Tool Rewriting (`Rk`)
 
 Two layers, both active automatically:
 
@@ -88,7 +84,7 @@ Two layers, both active automatically:
 cargo install rtk-ai
 ```
 
-### TOON / JSON Compression (`󰗀`)
+### TOON / JSON Compression (`Tn`)
 
 Guidance for handling information-dense JSON via `jq` (query/reshape) and
 `toon` (compress). The system-prompt nudge is injected **only when the user
@@ -105,7 +101,7 @@ The `toon-json` skill (full workflow + when-NOT-to-use guidance) is bundled in
 npm i -g @toon-format/cli
 ```
 
-### Ponytail Mode (`󰆐`)
+### Ponytail Mode (`Pt`)
 
 "Lazy senior dev" mode. Governs **what** the agent builds (minimal code,
 YAGNI), orthogonal to Caveman which governs **how** it talks — they pair. Before
@@ -140,7 +136,7 @@ pi install npm:@xynogen/pix-optimizer
 |-------------------|-----------------------------------------------------------|
 | `src/index.ts`    | Wires the four tools + shared status, registers `/optimizer` |
 | `src/opt.ts`      | The `/optimizer` overlay UI (keyboard nav + cycling)     |
-| `src/status.ts`   | Shared status-bar cell + `OptimizerHandle` contract       |
+| `src/status.ts`   | Shared status-bar cell (`toolIcon()` → shared `pix-pretty` catalog) |
 | `src/caveman.ts`  | Caveman logic, levels, prompt                            |
 | `src/rtk.ts`      | RTK prompt + bash command rewriting                       |
 | `src/json.ts`     | jq+TOON guidance, heuristics, system-prompt injection     |

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-optimizer",
-	"version": "1.1.9",
+	"version": "1.1.12",
 	"description": "Performance optimization suite for Pi Coding Agent - caveman mode + RTK tool rewriting + jq/TOON JSON compression + ponytail lazy-dev mode",
 	"type": "module",
 	"main": "src/index.ts",
@@ -48,7 +48,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@xynogen/pix-pretty": "*"
+		"@xynogen/pix-pretty": "^1.7.9"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-coding-agent": "*",

package/src/index.ts

@@ -17,11 +17,9 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { caveman } from "./caveman.ts";
 import { json } from "./json.ts";
 import { registerOptCommand } from "./opt.ts";
-import { loadIconMode } from "./persist.ts";
 import { ponytail } from "./ponytail.ts";
 import { rtk } from "./rtk.ts";
 import {
-	envIconMode,
 	type OptimizerHandle,
 	OptimizerStatus,
 	type OptimizerTool,
@@ -29,8 +27,8 @@ import {
 import { filterModelWarnings } from "./tool-result-filter.ts";
 
 export default function optimizer(pi: ExtensionAPI) {
-	// Persisted menu choice wins; otherwise fall back to the env default.
-	const status = new OptimizerStatus(loadIconMode() ?? envIconMode());
+	// Icons follow the global pix-pretty mode (set via /pretty); no local state.
+	const status = new OptimizerStatus();
 
 	// Each module registers its own lifecycle hooks and returns a handle the
 	// /optimizer overlay renders + drives.

package/src/json.ts

@@ -182,7 +182,8 @@ export function isUniformObjectArray(arr: unknown[]): boolean {
 		for (let i = 0; i < keys.length; i++) {
 			if (elKeys[i] !== keys[i]) return false;
 			// values must be primitive for a clean tabular row
-			if (isObjectLike((el as Record<string, unknown>)[keys[i]!])) return false;
+			if (isObjectLike((el as Record<string, unknown>)[keys[i] as string]))
+				return false;
 		}
 		return true;
 	});

package/src/opt.ts

@@ -16,22 +16,12 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { frameLines } from "@xynogen/pix-pretty/modal-frame";
-import { saveIconMode } from "./persist.ts";
-import {
-	getIcons,
-	ICON_MODES,
-	type IconMode,
-	type OptimizerHandle,
-	type OptimizerStatus,
-	type OptimizerTool,
+import type {
+	OptimizerHandle,
+	OptimizerStatus,
+	OptimizerTool,
 } from "./status.ts";
-
-/** Glyph for the icon-mode row itself (uses the active mode's diamond/Tn). */
-const ICON_ROW_GLYPH: Record<IconMode, string> = {
-	nerd: "󰆐", // gear-ish; distinct from the four tool glyphs
-	unicode: "\u25C8\uFE0E", // ◈ diamond-in-diamond
-	ascii: "Ic",
-};
+import { toolIcon } from "./status.ts";
 
 /** Min/max content width for the overlay box (excludes 4 cols of chrome). */
 const MIN_CONTENT = 28;
@@ -86,7 +76,7 @@ export function buildOptHelp(
 export function registerOptCommand(
 	pi: ExtensionAPI,
 	handles: Record<OptimizerTool, OptimizerHandle>,
-	status: OptimizerStatus,
+	_status: OptimizerStatus,
 ): void {
 	pi.registerCommand("optimizer", {
 		description: "pix-optimizer: caveman / rtk / toon / ponytail tools",
@@ -139,45 +129,28 @@ export function registerOptCommand(
 					_kb: unknown,
 					done: (v: null) => void,
 				) => {
-					// Rows = 4 tools + 1 icon-mode row at index TOOL_ORDER.length.
-					const ICON_ROW = TOOL_ORDER.length;
-					const ROW_COUNT = TOOL_ORDER.length + 1;
-					const ICON_HELP = "status-cell icon style (nerd needs a Nerd Font)";
 					let selected = 0;
 
-					const cycleIconMode = (direction: -1 | 1) => {
-						const cur = ICON_MODES.indexOf(status.mode);
-						const next =
-							(cur + direction + ICON_MODES.length) % ICON_MODES.length;
-						const mode = ICON_MODES[next]!;
-						status.setMode(mode, ctx);
-						saveIconMode(mode);
-					};
-
 					const cycle = (direction: -1 | 1) => {
-						if (selected === ICON_ROW) {
-							cycleIconMode(direction);
-							return;
-						}
-						const tool = TOOL_ORDER[selected]!;
+						const tool = TOOL_ORDER[selected] as OptimizerTool;
 						const values = handles[tool].values;
 						const cur = values.indexOf(handles[tool].current());
 						const next = (cur + direction + values.length) % values.length;
-						handles[tool].run(values[next]!, ctx);
+						handles[tool].run(values[next] as string, ctx);
 					};
 
 					const move = (direction: -1 | 1) => {
-						selected = (selected + direction + ROW_COUNT) % ROW_COUNT;
+						selected =
+							(selected + direction + TOOL_ORDER.length) % TOOL_ORDER.length;
 					};
 
 					return {
 						render: () => {
-							const icons = getIcons(status.mode);
 							const rows = TOOL_ORDER.map((tool, i) => {
 								const on = handles[tool].current() !== "off";
 								const sel = i === selected;
 								const cursor = sel ? theme.fg("accent", "→") : " ";
-								const icon = theme.fg(on ? "accent" : "dim", icons[tool]);
+								const glyph = theme.fg(on ? "accent" : "dim", toolIcon(tool));
 								const name = theme.fg(
 									sel ? "accent" : on ? "text" : "muted",
 									tool.padEnd(nameWidth),
@@ -191,31 +164,19 @@ export function registerOptCommand(
 									on ? "accent" : "dim",
 									levelBar(cur, handles[tool].values),
 								);
-								return `${cursor} ${icon}  ${name}  ${value}  ${bar}`;
+								return `${cursor} ${glyph}  ${name}  ${value}  ${bar}`;
 							});
-							// Icon-mode row: glyph + "icons" + current mode name.
-							const iconSel = selected === ICON_ROW;
-							const iconCursor = iconSel ? theme.fg("accent", "→") : " ";
-							const iconGlyph = theme.fg("accent", ICON_ROW_GLYPH[status.mode]);
-							const iconName = theme.fg(
-								iconSel ? "accent" : "text",
-								"icons".padEnd(nameWidth),
-							);
-							const iconValue = theme.fg(
-								"success",
-								status.mode.padEnd(valueWidth),
-							);
-							const iconRow = `${iconCursor} ${iconGlyph}  ${iconName}  ${iconValue}`;
-							const helpText = iconSel
-								? ICON_HELP
-								: helpSummary(handles[TOOL_ORDER[selected]!].help);
 							const lines = [
 								theme.fg("accent", theme.bold("󱎫  Optimizer")),
 								"",
 								...rows,
-								iconRow,
 								"",
-								theme.fg("dim", helpText),
+								theme.fg(
+									"dim",
+									helpSummary(
+										handles[TOOL_ORDER[selected] as OptimizerTool].help,
+									),
+								),
 								"",
 								theme.fg("dim", "←→ change · ↑↓ move · esc close"),
 							];

package/src/persist.test.ts

@@ -9,12 +9,7 @@ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import {
-	loadIconMode,
-	loadOptValue,
-	saveIconMode,
-	saveOptValue,
-} from "./persist.ts";
+import { loadOptValue, saveOptValue } from "./persist.ts";
 
 let tmpAgentDir: string;
 
@@ -58,21 +53,4 @@ describe("optimizer persistence", () => {
 		expect(loadOptValue("caveman")).toBe("ultra");
 		expect(loadOptValue("ponytail")).toBe("full");
 	});
-
-	test("icon mode round-trips and is independent of tool values", () => {
-		expect(loadIconMode()).toBeUndefined();
-		saveIconMode("unicode");
-		expect(loadIconMode()).toBe("unicode");
-		// Did not disturb existing tool state…
-		expect(loadOptValue("caveman")).toBe("ultra");
-		// …and a later tool write does not disturb the icon mode.
-		saveOptValue("rtk", "on");
-		expect(loadIconMode()).toBe("unicode");
-	});
-
-	test("rejects an invalid persisted icon mode", () => {
-		saveOptValue("caveman", "lite"); // unrelated write
-		saveIconMode("ascii");
-		expect(loadIconMode()).toBe("ascii");
-	});
 });

package/src/persist.ts

@@ -7,21 +7,14 @@
  * restart. Each tool reads its value on session_start and writes on run().
  *
  *   ~/.pi/agent/optimizer.json  →  { "caveman": "lite", "rtk": "on", ... }
- *
- * A reserved "iconMode" key (not a tool) stores the status-cell icon style.
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { ICON_MODES, type IconMode, type OptimizerTool } from "./status.ts";
-
-/** Reserved (non-tool) key holding the icon presentation mode. */
-const ICON_MODE_KEY = "iconMode";
+import type { OptimizerTool } from "./status.ts";
 
-type OptimizerConfig = Partial<Record<OptimizerTool, string>> & {
-	[ICON_MODE_KEY]?: string;
-};
+type OptimizerConfig = Partial<Record<OptimizerTool, string>>;
 
 function getStatePath(): string {
 	return join(getAgentDir(), "optimizer.json");
@@ -55,21 +48,3 @@ export function saveOptValue(tool: OptimizerTool, value: string): void {
 		console.warn(`optimizer: persist ${tool} failed:`, err);
 	}
 }
-
-/** Read the persisted icon mode, or undefined if unset/invalid. */
-export function loadIconMode(): IconMode | undefined {
-	const raw = readAll()[ICON_MODE_KEY];
-	return ICON_MODES.includes(raw as IconMode) ? (raw as IconMode) : undefined;
-}
-
-/** Persist the icon mode, merging into the shared config file. */
-export function saveIconMode(mode: IconMode): void {
-	try {
-		const sp = getStatePath();
-		mkdirSync(dirname(sp), { recursive: true });
-		const next = { ...readAll(), [ICON_MODE_KEY]: mode };
-		writeFileSync(sp, JSON.stringify(next, null, 2), "utf-8");
-	} catch (err) {
-		console.warn("optimizer: persist iconMode failed:", err);
-	}
-}

package/src/rtk.ts

@@ -156,7 +156,7 @@ export function splitChain(command: string): string[] | null {
 	let quote: "'" | '"' | null = null;
 
 	for (let i = 0; i < command.length; i++) {
-		const c = command[i]!;
+		const c = command[i] as string;
 		const next = command[i + 1];
 
 		if (quote) {
@@ -213,7 +213,7 @@ export function rewriteChain(command: string): string {
 		const body = part.slice(leading.length);
 		if (!body) return part;
 
-		const firstWord = body.split(/\s+/)[0]!;
+		const firstWord = body.split(/\s+/)[0] ?? "";
 		if (firstWord === "rtk") return part;
 		if (!RTK_COMMANDS.has(firstWord)) return part;
 

package/src/status.test.ts

@@ -1,17 +1,20 @@
-import { afterEach, describe, expect, it } from "bun:test";
+import { describe, expect, it } from "bun:test";
 import {
-	envIconMode,
-	getIcons,
-	ICON_MODES,
 	OptimizerStatus,
 	renderStatus,
 	STATUS_KEY,
-	TOOL_ICONS,
+	toolIcon,
 } from "./status.ts";
 
 /** Tagging colorizer: <accent>X</accent> / <dim>X</dim> for assertions. */
 const tag = (c: string, t: string) => `<${c}>${t}</${c}>`;
 
+// Icons resolve against the global pix-pretty mode (default "nerd" in tests).
+const CV = toolIcon("caveman");
+const RK = toolIcon("rtk");
+const TN = toolIcon("toon");
+const PT = toolIcon("ponytail");
+
 describe("renderStatus", () => {
 	it("shows ALL icons in order, accent when enabled", () => {
 		expect(
@@ -20,7 +23,7 @@ describe("renderStatus", () => {
 				tag,
 			),
 		).toBe(
-			`<accent>${TOOL_ICONS.caveman}</accent>  <accent>${TOOL_ICONS.rtk}</accent>  <accent>${TOOL_ICONS.toon}</accent>  <accent>${TOOL_ICONS.ponytail}</accent> `,
+			`<accent>${CV}</accent>  <accent>${RK}</accent>  <accent>${TN}</accent>  <accent>${PT}</accent> `,
 		);
 	});
 
@@ -31,80 +34,25 @@ describe("renderStatus", () => {
 				tag,
 			),
 		).toBe(
-			`<dim>${TOOL_ICONS.caveman}</dim>  <accent>${TOOL_ICONS.rtk}</accent>  <accent>${TOOL_ICONS.toon}</accent>  <accent>${TOOL_ICONS.ponytail}</accent> `,
+			`<dim>${CV}</dim>  <accent>${RK}</accent>  <accent>${TN}</accent>  <accent>${PT}</accent> `,
 		);
 	});
 
 	it("all dim when nothing enabled (cell never empty)", () => {
 		expect(renderStatus({}, tag)).toBe(
-			`<dim>${TOOL_ICONS.caveman}</dim>  <dim>${TOOL_ICONS.rtk}</dim>  <dim>${TOOL_ICONS.toon}</dim>  <dim>${TOOL_ICONS.ponytail}</dim> `,
+			`<dim>${CV}</dim>  <dim>${RK}</dim>  <dim>${TN}</dim>  <dim>${PT}</dim> `,
 		);
 	});
 
 	it("preserves fixed order regardless of insertion order", () => {
 		expect(renderStatus({ toon: true, caveman: true }, tag)).toBe(
-			`<accent>${TOOL_ICONS.caveman}</accent>  <dim>${TOOL_ICONS.rtk}</dim>  <accent>${TOOL_ICONS.toon}</accent>  <dim>${TOOL_ICONS.ponytail}</dim> `,
+			`<accent>${CV}</accent>  <dim>${RK}</dim>  <accent>${TN}</accent>  <dim>${PT}</dim> `,
 		);
 	});
-});
-
-describe("icon modes", () => {
-	it("nerd is the default mode used by renderStatus", () => {
-		expect(renderStatus({ rtk: true }, tag)).toContain(TOOL_ICONS.rtk);
-	});
-
-	it("renders the unicode (outline-suit) set when mode=unicode", () => {
-		const icons = getIcons("unicode");
-		const out = renderStatus({ caveman: true }, tag, "unicode");
-		expect(out).toContain(icons.caveman);
-		// outline white spade + text variation selector
-		expect(icons.caveman).toBe("\u2664\uFE0E");
-	});
-
-	it("renders the ascii set when mode=ascii", () => {
-		const out = renderStatus(
-			{ caveman: true, rtk: false, toon: true, ponytail: false },
-			tag,
-			"ascii",
-		);
-		expect(out).toBe(
-			`<accent>Cv</accent>  <dim>Rk</dim>  <accent>Tn</accent>  <dim>Pt</dim> `,
-		);
-	});
-
-	it("falls back to nerd for an unknown mode", () => {
-		// @ts-expect-error exercising the runtime guard in getIcons
-		expect(getIcons("bogus")).toBe(getIcons("nerd"));
-	});
-
-	it("exposes exactly nerd/unicode/ascii in cycle order", () => {
-		expect([...ICON_MODES]).toEqual(["nerd", "unicode", "ascii"]);
-	});
-});
-
-describe("envIconMode", () => {
-	const saved = { ...process.env };
-	afterEach(() => {
-		process.env.OPTIMIZER_ICONS = saved.OPTIMIZER_ICONS;
-		process.env.PRETTY_ICONS = saved.PRETTY_ICONS;
-	});
-
-	it("defaults to nerd when nothing set", () => {
-		process.env.OPTIMIZER_ICONS = undefined;
-		process.env.PRETTY_ICONS = undefined;
-		expect(envIconMode()).toBe("nerd");
-	});
 
-	it("OPTIMIZER_ICONS wins over PRETTY_ICONS", () => {
-		process.env.OPTIMIZER_ICONS = "unicode";
-		process.env.PRETTY_ICONS = "none";
-		expect(envIconMode()).toBe("unicode");
-	});
-
-	it("PRETTY_ICONS=none maps to ascii", () => {
-		process.env.OPTIMIZER_ICONS = undefined;
-		process.env.PRETTY_ICONS = "none";
-		expect(envIconMode()).toBe("ascii");
+	it("resolves icons via the shared catalog (non-empty glyphs)", () => {
+		// toolIcon delegates to pix-pretty's icon(); every tool has a glyph.
+		expect([CV, RK, TN, PT].every((g) => g.length > 0)).toBe(true);
 	});
 });
 
@@ -126,11 +74,12 @@ describe("OptimizerStatus", () => {
 		const status = new OptimizerStatus();
 		const ctx = fakeCtx();
 		status.set("rtk", true, ctx as never);
-		const last = ctx.calls.at(-1)!;
+		const last = ctx.calls.at(-1);
+		if (!last) throw new Error("no calls");
 		expect(last.key).toBe(STATUS_KEY);
 		// caveman + toon + ponytail still unset (dim), rtk accent.
 		expect(last.text).toBe(
-			`<dim>${TOOL_ICONS.caveman}</dim>  <accent>${TOOL_ICONS.rtk}</accent>  <dim>${TOOL_ICONS.toon}</dim>  <dim>${TOOL_ICONS.ponytail}</dim> `,
+			`<dim>${CV}</dim>  <accent>${RK}</accent>  <dim>${TN}</dim>  <dim>${PT}</dim> `,
 		);
 	});
 
@@ -139,9 +88,10 @@ describe("OptimizerStatus", () => {
 		const ctx = fakeCtx();
 		status.set("caveman", true, ctx as never);
 		status.set("toon", true, ctx as never);
-		const last = ctx.calls.at(-1)!;
+		const last = ctx.calls.at(-1);
+		if (!last) throw new Error("no calls");
 		expect(last.text).toBe(
-			`<accent>${TOOL_ICONS.caveman}</accent>  <dim>${TOOL_ICONS.rtk}</dim>  <accent>${TOOL_ICONS.toon}</accent>  <dim>${TOOL_ICONS.ponytail}</dim> `,
+			`<accent>${CV}</accent>  <dim>${RK}</dim>  <accent>${TN}</accent>  <dim>${PT}</dim> `,
 		);
 	});
 
@@ -150,29 +100,10 @@ describe("OptimizerStatus", () => {
 		const ctx = fakeCtx();
 		status.set("rtk", true, ctx as never);
 		status.set("rtk", false, ctx as never);
-		const last = ctx.calls.at(-1)!;
+		const last = ctx.calls.at(-1);
+		if (!last) throw new Error("no calls");
 		expect(last.text).toBe(
-			`<dim>${TOOL_ICONS.caveman}</dim>  <dim>${TOOL_ICONS.rtk}</dim>  <dim>${TOOL_ICONS.toon}</dim>  <dim>${TOOL_ICONS.ponytail}</dim> `,
+			`<dim>${CV}</dim>  <dim>${RK}</dim>  <dim>${TN}</dim>  <dim>${PT}</dim> `,
 		);
 	});
-
-	it("seeds icon mode from the constructor", () => {
-		const status = new OptimizerStatus("ascii");
-		expect(status.mode).toBe("ascii");
-		const ctx = fakeCtx();
-		status.set("caveman", true, ctx as never);
-		expect(ctx.calls.at(-1)!.text).toContain("Cv");
-	});
-
-	it("setMode switches the rendered glyph set and repaints", () => {
-		const status = new OptimizerStatus("nerd");
-		const ctx = fakeCtx();
-		status.set("rtk", true, ctx as never);
-		expect(ctx.calls.at(-1)!.text).toContain(TOOL_ICONS.rtk);
-		status.setMode("ascii", ctx as never);
-		const last = ctx.calls.at(-1)!;
-		expect(last.key).toBe(STATUS_KEY);
-		expect(last.text).toContain("Rk");
-		expect(last.text).not.toContain(TOOL_ICONS.rtk);
-	});
 });

package/src/status.ts

@@ -17,6 +17,11 @@ import type {
 	ExtensionContext,
 	ThemeColor,
 } from "@earendil-works/pi-coding-agent";
+import {
+	type IconKey,
+	icon,
+	onIconModeChange,
+} from "@xynogen/pix-pretty/icon-catalog";
 
 /**
  * Each optimizer tool (caveman/rtk/toon/ponytail) exposes a handle so the
@@ -43,71 +48,23 @@ export const STATUS_KEY = "pix-optimizer";
 export type OptimizerTool = "caveman" | "rtk" | "toon" | "ponytail";
 
 /**
- * Icon presentation modes. The optimizer cell defaults to Nerd Font glyphs,
- * which require a patched font (e.g. MesloLGS NF). Terminals without one show
- * missing-glyph tofu, so two font-independent fallbacks are offered:
- *   - `unicode`: outline playing-card suits (standard BMP, ships with virtually
- *     every monospace font) + U+FE0E to force text (non-emoji) presentation.
- *   - `ascii`: two-letter labels, renders on literally any terminal.
- * Mode is chosen via the /optimizer menu (persisted) or the OPTIMIZER_ICONS /
- * PRETTY_ICONS env vars.
+ * Icons come from the shared pix-pretty catalog and follow the ONE global icon
+ * mode (set via /pretty). The optimizer no longer owns a mode: each tool maps
+ * to a semantic catalog key, and the cell renders whatever the active mode
+ * resolves — nerd / unicode / ascii — with no per-package knob.
  */
-export type IconMode = "nerd" | "unicode" | "ascii";
-
-/** All selectable icon modes, in /optimizer cycle order. */
-export const ICON_MODES: readonly IconMode[] = ["nerd", "unicode", "ascii"];
-
-/** Force text (non-emoji) presentation for symbols that default to emoji. */
-const VS_TEXT = "\uFE0E";
-
-/** Per-mode glyph table for each tool. */
-const ICON_SETS: Record<IconMode, Record<OptimizerTool, string>> = {
-	nerd: {
-		caveman: "󰜐",
-		rtk: "󰓥",
-		toon: "󰗀",
-		ponytail: "󰆐",
-	},
-	unicode: {
-		caveman: `\u2664${VS_TEXT}`, // ♤ white spade
-		rtk: `\u2661${VS_TEXT}`, // ♡ white heart
-		toon: `\u2662${VS_TEXT}`, // ♢ white diamond
-		ponytail: `\u2667${VS_TEXT}`, // ♧ white club
-	},
-	ascii: {
-		caveman: "Cv",
-		rtk: "Rk",
-		toon: "Tn",
-		ponytail: "Pt",
-	},
+const TOOL_ICON_KEY: Record<OptimizerTool, IconKey> = {
+	caveman: "opt.caveman",
+	rtk: "opt.rtk",
+	toon: "opt.toon",
+	ponytail: "opt.ponytail",
 };
 
-/** Resolve the glyph table for a mode. */
-export function getIcons(mode: IconMode): Record<OptimizerTool, string> {
-	return ICON_SETS[mode] ?? ICON_SETS.nerd;
-}
-
-/**
- * Default icon mode from the environment. OPTIMIZER_ICONS takes precedence;
- * PRETTY_ICONS=none|off maps to ascii so one stack-wide var disables glyphs.
- * Anything unrecognized (or unset) falls back to `nerd`. A persisted menu
- * choice overrides this at load time (see persist.loadIconMode).
- */
-export function envIconMode(): IconMode {
-	const raw = (process.env.OPTIMIZER_ICONS ?? "").toLowerCase();
-	if (raw === "nerd" || raw === "unicode" || raw === "ascii") return raw;
-	const pretty = (process.env.PRETTY_ICONS ?? "").toLowerCase();
-	if (pretty === "none" || pretty === "off") return "ascii";
-	return "nerd";
+/** Current glyph for a tool, resolved against the active global icon mode. */
+export function toolIcon(tool: OptimizerTool): string {
+	return icon(TOOL_ICON_KEY[tool]);
 }
 
-/**
- * Default Nerd Font glyph table. Kept as a named export for back-compat with
- * callers/tests that reference the nerd set directly; equivalent to
- * getIcons("nerd").
- */
-export const TOOL_ICONS: Record<OptimizerTool, string> = ICON_SETS.nerd;
-
 /** Fixed left-to-right order of icons in the cell. */
 const TOOL_ORDER: readonly OptimizerTool[] = [
 	"caveman",
@@ -127,8 +84,8 @@ export type Colorize = (color: ThemeColor, text: string) => string;
 /**
  * Build the colored status string for a set of tool states. ALL tool icons are
  * always shown, in TOOL_ORDER; each is accent-colored when its tool is enabled
- * and dim when disabled. `color` applies the theme color (e.g. theme.fg).
- * `mode` selects the glyph table (nerd / unicode / ascii); defaults to nerd.
+ * and dim when disabled. Glyphs resolve against the active global icon mode
+ * (see /pretty). `color` applies the theme color (e.g. theme.fg).
  *
  * Pure + exported for tests (pass a tagging colorizer to assert per-icon color).
  * A trailing space separates the cell from the next status segment.
@@ -136,11 +93,9 @@ export type Colorize = (color: ThemeColor, text: string) => string;
 export function renderStatus(
 	states: Partial<Record<OptimizerTool, boolean>>,
 	color: Colorize,
-	mode: IconMode = "nerd",
 ): string {
-	const icons = getIcons(mode);
 	return `${TOOL_ORDER.map((t) =>
-		color(states[t] === true ? ENABLED_COLOR : DISABLED_COLOR, icons[t]),
+		color(states[t] === true ? ENABLED_COLOR : DISABLED_COLOR, toolIcon(t)),
 	).join("  ")} `;
 }
 
@@ -151,11 +106,16 @@ export function renderStatus(
  */
 export class OptimizerStatus {
 	private states: Partial<Record<OptimizerTool, boolean>> = {};
-	private iconMode: IconMode;
-
-	/** `mode` seeds the icon set (persisted choice or env default). */
-	constructor(mode: IconMode = "nerd") {
-		this.iconMode = mode;
+	/** Latest ui ctx seen, so an icon-mode change can repaint without a toggle. */
+	private lastCtx: Pick<ExtensionContext, "ui"> | undefined;
+
+	constructor() {
+		// The cell is a pushed status (setStatus), so it does NOT auto-refresh
+		// when /pretty flips the global icon mode. Repaint it on mode change
+		// using the last-seen ctx (no-op until the cell has painted once).
+		onIconModeChange(() => {
+			if (this.lastCtx) this.paint(this.lastCtx);
+		});
 	}
 
 	/** Current enabled state for one tool (undefined until first set). */
@@ -163,17 +123,6 @@ export class OptimizerStatus {
 		return this.states[tool];
 	}
 
-	/** Current icon presentation mode. */
-	get mode(): IconMode {
-		return this.iconMode;
-	}
-
-	/** Switch icon mode and repaint the shared cell. */
-	setMode(mode: IconMode, ctx: Pick<ExtensionContext, "ui">): void {
-		this.iconMode = mode;
-		this.paint(ctx);
-	}
-
 	/** Update one tool's enabled state and repaint the shared cell. */
 	set(
 		tool: OptimizerTool,
@@ -186,11 +135,8 @@ export class OptimizerStatus {
 
 	/** Repaint the shared cell from current states. */
 	paint(ctx: Pick<ExtensionContext, "ui">): void {
-		const text = renderStatus(
-			this.states,
-			(c, t) => ctx.ui.theme.fg(c, t),
-			this.iconMode,
-		);
+		this.lastCtx = ctx;
+		const text = renderStatus(this.states, (c, t) => ctx.ui.theme.fg(c, t));
 		ctx.ui.setStatus(STATUS_KEY, text);
 	}
 }