@xynogen/pix-optimizer 1.0.7 → 1.1.0

package/README.md

@@ -4,9 +4,10 @@ Token-optimization suite for Pi Coding Agent. Three tools wired into one
 extension via `src/index.ts`, fronted by a single `/opt` 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)
+- **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)
 
 ## Command
 
@@ -17,16 +18,17 @@ One command routes to every tool:
 /opt caveman <level>  → set caveman level (1/2/3/lite/full/ultra/micro/off/config)
 /opt rtk [on|off]     → toggle RTK rewriting
 /opt toon [on|off]    → toggle jq+TOON guidance
+/opt ponytail <level> → set ponytail level (1/2/3/lite/full/ultra/off/config)
 ```
 
 ## Status bar
 
-A single cell always shows all three icons in a fixed order (`⛏ ⚔ ✂`), color-
+A single cell always shows the enabled icons in a fixed order (`󰜐 󰓥 󰗀 󰆐`), color-
 coded by state: **accent** when the tool is enabled, **dim** when disabled.
 
 ## Features
 
-### Caveman Mode (`⛏`)
+### Caveman Mode (`󰜐`)
 
 Cuts ~75% of output tokens while keeping full technical accuracy.
 
@@ -40,7 +42,7 @@ Cuts ~75% of output tokens while keeping full technical accuracy.
 `/opt caveman config` opens a settings dialog. Default level for new sessions
 and status-bar visibility are saved to `~/.pi/agent/caveman.json`.
 
-### RTK Tool Rewriting (`⚔`)
+### RTK Tool Rewriting (`󰓥`)
 
 Two layers, both active automatically:
 
@@ -61,7 +63,7 @@ Two layers, both active automatically:
 cargo install rtk-ai
 ```
 
-### TOON / JSON Compression (`✂`)
+### TOON / JSON Compression (`󰗀`)
 
 Guidance for handling information-dense JSON via `jq` (query/reshape) and
 `toon` (compress). The system-prompt nudge is injected **only when the user
@@ -78,6 +80,26 @@ The `toon-json` skill (full workflow + when-NOT-to-use guidance) is bundled in
 npm i -g @toon-format/cli
 ```
 
+### Ponytail Mode (`󰆐`)
+
+"Lazy senior dev" mode. Governs **what** the agent builds (minimal code,
+YAGNI), orthogonal to Caveman which governs **how** it talks — they pair. Before
+writing code the agent stops at the first rung that holds: does this need to
+exist → stdlib → native platform → installed dep → one line → minimum that
+works. Validation, error handling, security, and accessibility are never cut.
+
+| # | Name  | Description                          |
+|---|-------|--------------------------------------|
+| 1 | lite  | Name the lazier alternative, you pick |
+| 2 | full  | The ladder enforced (default)        |
+| 3 | ultra | YAGNI extremist                      |
+
+`/opt ponytail config` opens a settings dialog. Default level for new sessions
+and status-bar visibility are saved to `~/.pi/agent/ponytail.json`.
+
+**No install required** — pure prompt injection, no external binary or PATH
+dependency (unlike RTK and TOON).
+
 ## Installation
 
 ```bash
@@ -88,15 +110,16 @@ pi install npm:@xynogen/pix-optimizer
 
 | File              | Role                                                      |
 |-------------------|-----------------------------------------------------------|
-| `src/index.ts`    | Wires the three tools + shared status, registers `/opt`   |
+| `src/index.ts`    | Wires the four tools + shared status, registers `/opt`    |
 | `src/opt.ts`      | The `/opt` router: parse, complete, dispatch              |
 | `src/status.ts`   | Shared status-bar cell + `OptimizerHandle` contract       |
 | `src/caveman.ts`  | Caveman logic, levels, prompt, settings dialog            |
 | `src/rtk.ts`      | RTK prompt + bash command rewriting                       |
 | `src/json.ts`     | jq+TOON guidance, heuristics, system-prompt injection     |
+| `src/ponytail.ts` | Ponytail logic, levels, prompt, settings dialog           |
 
 Each tool registers its own lifecycle hooks and exposes an `OptimizerHandle`
-that `/opt` dispatches to. All three share one `OptimizerStatus`.
+that `/opt` dispatches to. All four share one `OptimizerStatus`.
 
 ## Development
 
@@ -116,9 +139,14 @@ This package was built by merging two upstream Pi community packages:
   approach: prompt injection + live bash command rewriting that handles chained commands
   (`&&`, `||`, `;`, `|`).
 
-Both upstreams are MIT licensed. Neither codebase was copied directly — the logic was
+- **Ponytail mode** — ruleset adapted from [`git:github.com/DietrichGebert/ponytail`](https://github.com/DietrichGebert/ponytail),
+  the "lazy senior dev" skill. Reimplemented here as a native `/opt` tool with three intensity
+  levels, a settings dialog, and per-session persistence — no external hooks or files. The
+  ruleset (the YAGNI ladder + safety carve-outs) is rewritten as a system-prompt fragment.
+
+All upstreams are MIT licensed. No codebase was copied directly — the logic was
 rewritten and combined into a single extension with a unified `/opt` command and shared status bar.
-This package does not sync back to either upstream.
+This package does not sync back to any upstream.
 
 ## Full distro
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@xynogen/pix-optimizer",
-	"version": "1.0.7",
-	"description": "Performance optimization suite for Pi Coding Agent - caveman mode + RTK tool rewriting + jq/TOON JSON compression",
+	"version": "1.1.0",
+	"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",
 	"scripts": {
@@ -30,6 +30,7 @@
 		"toon",
 		"jq",
 		"json",
+		"ponytail",
 		"performance"
 	],
 	"author": "xynogen",

package/src/index.ts

@@ -2,11 +2,12 @@
  * pix-optimizer — token-optimization suite for Pi Coding Agent.
  *
  * Three tools, combined into one extension + one command:
- *   - caveman: terse-output system prompt
- *   - rtk:     prefixes shell commands with `rtk` + injects RTK prompt
- *   - toon:    jq + TOON guidance for dense JSON (+ bundled skill)
+ *   - caveman:  terse-output system prompt
+ *   - rtk:      prefixes shell commands with `rtk` + injects RTK prompt
+ *   - toon:     jq + TOON guidance for dense JSON (+ bundled skill)
+ *   - ponytail: lazy-senior-dev system prompt (minimal code, YAGNI)
  *
- * They share ONE status-bar cell (⛏ ⚔ ✂, only enabled tools shown) and ONE
+ * They share ONE status-bar cell (󰜐 󰓥 󰗀 󰆐, only enabled tools shown) and ONE
  * command (/opt <tool> [args]). index.ts wires lifecycle hooks via each
  * module, then registers the merged command from their handles.
  */
@@ -15,6 +16,7 @@ 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 { ponytail } from "./ponytail.ts";
 import { rtk } from "./rtk.ts";
 import {
 	type OptimizerHandle,
@@ -32,6 +34,7 @@ export default function optimizer(pi: ExtensionAPI) {
 		caveman: caveman(pi, status),
 		rtk: rtk(pi, status),
 		toon: json(pi, status),
+		ponytail: ponytail(pi, status),
 	};
 
 	registerOptCommand(pi, handles);

package/src/opt.test.ts

@@ -13,7 +13,12 @@ function fakeHandles(): Record<OptimizerTool, OptimizerHandle> {
 				.filter((v) => v.startsWith(prefix.trim().toLowerCase()))
 				.map((v) => ({ value: v, label: v, description: v })),
 	});
-	return { caveman: mk("caveman"), rtk: mk("rtk"), toon: mk("toon") };
+	return {
+		caveman: mk("caveman"),
+		rtk: mk("rtk"),
+		toon: mk("toon"),
+		ponytail: mk("ponytail"),
+	};
 }
 
 describe("parseInvocation", () => {
@@ -49,7 +54,12 @@ describe("completeInvocation", () => {
 	it("returns all tool names for empty prefix", () => {
 		const handles = fakeHandles();
 		const out = completeInvocation("", handles);
-		expect(out?.map((i) => i.value)).toEqual(["caveman", "rtk", "toon"]);
+		expect(out?.map((i) => i.value)).toEqual([
+			"caveman",
+			"rtk",
+			"toon",
+			"ponytail",
+		]);
 	});
 
 	it("delegates to the tool completer after the name", () => {
@@ -70,6 +80,7 @@ describe("buildOptHelp", () => {
 		expect(help).toContain("/opt caveman help");
 		expect(help).toContain("/opt rtk help");
 		expect(help).toContain("/opt toon help");
+		expect(help).toContain("/opt ponytail help");
 		expect(help).toContain("Usage: /opt <tool> [args]");
 	});
 });

package/src/opt.ts

@@ -81,7 +81,7 @@ export function registerOptCommand(
 	handles: Record<OptimizerTool, OptimizerHandle>,
 ): void {
 	pi.registerCommand("opt", {
-		description: "pix-optimizer: caveman / rtk / toon token tools",
+		description: "pix-optimizer: caveman / rtk / toon / ponytail tools",
 		getArgumentCompletions: (prefix: string) =>
 			completeInvocation(prefix, handles),
 		handler: async (args, ctx) => {

package/src/ponytail.test.ts

@@ -0,0 +1,236 @@
+import { describe, expect, it } from "bun:test";
+import {
+	buildHelp,
+	buildPrompt,
+	DEFAULT_CONFIG,
+	LEVEL_NUMBERS,
+	LEVELS,
+	type Level,
+	parseConfig,
+	resolveLevel,
+	STATUS_LABELS,
+	STOP_ALIASES,
+	toggleLevel,
+} from "./ponytail.ts";
+
+// ── LEVELS ────────────────────────────────────────────────────────────────────
+
+describe("LEVELS", () => {
+	it("contains off as first entry", () => {
+		expect(LEVELS[0]).toBe("off");
+	});
+
+	it("contains all expected levels", () => {
+		const expected: Level[] = ["off", "lite", "full", "ultra"];
+		for (const l of expected) expect(LEVELS).toContain(l);
+	});
+
+	it("has no micro level (caveman-only)", () => {
+		expect(LEVELS).not.toContain("micro" as Level);
+	});
+});
+
+// ── STOP_ALIASES ──────────────────────────────────────────────────────────────
+
+describe("STOP_ALIASES", () => {
+	it("includes off, stop, quit", () => {
+		expect(STOP_ALIASES.has("off")).toBe(true);
+		expect(STOP_ALIASES.has("stop")).toBe(true);
+		expect(STOP_ALIASES.has("quit")).toBe(true);
+	});
+
+	it("does not include active levels", () => {
+		expect(STOP_ALIASES.has("full")).toBe(false);
+		expect(STOP_ALIASES.has("ultra")).toBe(false);
+	});
+});
+
+// ── STATUS_LABELS ─────────────────────────────────────────────────────────────
+
+describe("STATUS_LABELS", () => {
+	it("has a label for every non-off level", () => {
+		const nonOff = LEVELS.filter((l) => l !== "off") as Exclude<Level, "off">[];
+		for (const l of nonOff) {
+			expect(STATUS_LABELS[l]).toBeTruthy();
+		}
+	});
+
+	it("levels are uppercase", () => {
+		expect(STATUS_LABELS.lite).toBe("LITE");
+		expect(STATUS_LABELS.full).toBe("FULL");
+		expect(STATUS_LABELS.ultra).toBe("ULTRA");
+	});
+});
+
+// ── resolveLevel ──────────────────────────────────────────────────────────────
+
+describe("resolveLevel", () => {
+	it("resolves valid levels", () => {
+		expect(resolveLevel("lite")).toBe("lite");
+		expect(resolveLevel("full")).toBe("full");
+		expect(resolveLevel("ultra")).toBe("ultra");
+		expect(resolveLevel("off")).toBe("off");
+	});
+
+	it("maps stop aliases to off", () => {
+		expect(resolveLevel("stop")).toBe("off");
+		expect(resolveLevel("quit")).toBe("off");
+	});
+
+	it("is case-insensitive", () => {
+		expect(resolveLevel("FULL")).toBe("full");
+		expect(resolveLevel("Ultra")).toBe("ultra");
+		expect(resolveLevel("STOP")).toBe("off");
+	});
+
+	it("trims whitespace", () => {
+		expect(resolveLevel("  full  ")).toBe("full");
+	});
+
+	it("returns null for unknown input", () => {
+		expect(resolveLevel("unknown")).toBeNull();
+		expect(resolveLevel("")).toBeNull();
+		expect(resolveLevel("config")).toBeNull(); // config handled separately
+		expect(resolveLevel("micro")).toBeNull(); // no micro level
+	});
+});
+
+// ── numeric levels ────────────────────────────────────────────────────────────
+
+describe("numeric levels", () => {
+	it("maps 1/2/3 to lite/full/ultra", () => {
+		expect(resolveLevel("1")).toBe("lite");
+		expect(resolveLevel("2")).toBe("full");
+		expect(resolveLevel("3")).toBe("ultra");
+	});
+
+	it("maps 0 to off", () => {
+		expect(resolveLevel("0")).toBe("off");
+	});
+
+	it("LEVEL_NUMBERS only covers 1-3", () => {
+		expect(Object.keys(LEVEL_NUMBERS).sort()).toEqual(["1", "2", "3"]);
+	});
+
+	it("rejects out-of-range numbers", () => {
+		expect(resolveLevel("4")).toBeNull();
+		expect(resolveLevel("9")).toBeNull();
+	});
+
+	it("trims whitespace around numbers", () => {
+		expect(resolveLevel("  2  ")).toBe("full");
+	});
+});
+
+// ── buildHelp ─────────────────────────────────────────────────────────────────
+
+describe("buildHelp", () => {
+	it("lists numeric shortcuts", () => {
+		const help = buildHelp("off");
+		expect(help).toContain("1");
+		expect(help).toContain("lite");
+		expect(help).toContain("2");
+		expect(help).toContain("full");
+		expect(help).toContain("3");
+		expect(help).toContain("ultra");
+	});
+
+	it("shows current level when active", () => {
+		expect(buildHelp("ultra")).toContain("ULTRA");
+	});
+
+	it("shows off when disabled", () => {
+		expect(buildHelp("off")).toContain("off");
+	});
+
+	it("mentions config", () => {
+		expect(buildHelp("off")).toContain("config");
+	});
+});
+
+// ── toggleLevel ───────────────────────────────────────────────────────────────
+
+describe("toggleLevel", () => {
+	it("off → full", () => {
+		expect(toggleLevel("off")).toBe("full");
+	});
+
+	it("full → off", () => {
+		expect(toggleLevel("full")).toBe("off");
+	});
+
+	it("any non-off level → off", () => {
+		const nonOff = LEVELS.filter((l) => l !== "off") as Level[];
+		for (const l of nonOff) {
+			expect(toggleLevel(l)).toBe("off");
+		}
+	});
+});
+
+// ── buildPrompt ───────────────────────────────────────────────────────────────
+
+describe("buildPrompt", () => {
+	it("returns empty string for off", () => {
+		expect(buildPrompt("off")).toBe("");
+	});
+
+	it("includes BASE ladder for all active levels", () => {
+		for (const l of ["lite", "full", "ultra"] as Level[]) {
+			expect(buildPrompt(l)).toContain("PONYTAIL MODE ACTIVE");
+			expect(buildPrompt(l)).toContain("first rung that holds");
+		}
+	});
+
+	it("includes SAFETY clause for all active levels", () => {
+		for (const l of ["lite", "full", "ultra"] as Level[]) {
+			expect(buildPrompt(l)).toContain("When NOT to be lazy");
+		}
+	});
+
+	it("each level has distinct intensity instructions", () => {
+		const lite = buildPrompt("lite");
+		const ultra = buildPrompt("ultra");
+		expect(lite).toContain("name the lazier alternative");
+		expect(ultra).toContain("YAGNI extremist");
+		expect(lite).not.toContain("YAGNI extremist");
+	});
+});
+
+// ── parseConfig ───────────────────────────────────────────────────────────────
+
+describe("parseConfig", () => {
+	it("parses valid config", () => {
+		const cfg = parseConfig({ defaultLevel: "ultra", showStatus: false });
+		expect(cfg.defaultLevel).toBe("ultra");
+		expect(cfg.showStatus).toBe(false);
+	});
+
+	it("falls back to defaults for invalid defaultLevel", () => {
+		const cfg = parseConfig({ defaultLevel: "invalid", showStatus: true });
+		expect(cfg.defaultLevel).toBe(DEFAULT_CONFIG.defaultLevel);
+	});
+
+	it("default level is full", () => {
+		expect(DEFAULT_CONFIG.defaultLevel).toBe("full");
+	});
+
+	it("falls back to defaults for missing fields", () => {
+		const cfg = parseConfig({});
+		expect(cfg.defaultLevel).toBe(DEFAULT_CONFIG.defaultLevel);
+		expect(cfg.showStatus).toBe(DEFAULT_CONFIG.showStatus);
+	});
+
+	it("falls back to defaults for null/undefined", () => {
+		const cfg = parseConfig(null);
+		expect(cfg.defaultLevel).toBe(DEFAULT_CONFIG.defaultLevel);
+		expect(cfg.showStatus).toBe(DEFAULT_CONFIG.showStatus);
+	});
+
+	it("accepts all valid levels as defaultLevel", () => {
+		for (const l of LEVELS) {
+			expect(
+				parseConfig({ defaultLevel: l, showStatus: true }).defaultLevel,
+			).toBe(l);
+		}
+	});
+});

package/src/ponytail.ts

@@ -0,0 +1,439 @@
+/**
+ * ponytail.ts — pure logic + Pi extension
+ *
+ * "Lazy senior dev" mode: governs WHAT the agent builds (minimal code, YAGNI),
+ * orthogonal to caveman which governs HOW it talks. Pure helpers exported for
+ * tests; ponytail(pi, status) is the extension entry, wired by index.ts.
+ *
+ * Ruleset adapted from DietrichGebert/ponytail (MIT), the "lazy senior dev"
+ * skill. We inject it as a system-prompt fragment — no external hooks/files.
+ */
+
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type {
+	ExtensionAPI,
+	ExtensionCommandContext,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import {
+	Container,
+	type SettingItem,
+	SettingsList,
+	Text,
+} from "@earendil-works/pi-tui";
+import type { OptimizerHandle, OptimizerStatus } from "./status.ts";
+
+// ── Levels ────────────────────────────────────────────────────────────────────
+
+export const LEVELS = ["off", "lite", "full", "ultra"] as const;
+
+export type Level = (typeof LEVELS)[number];
+
+export const STOP_ALIASES = new Set(["off", "stop", "quit", "0"]);
+
+// Numeric shortcuts: /opt ponytail 1|2|3
+export const LEVEL_NUMBERS: Record<string, Level> = {
+	"1": "lite",
+	"2": "full",
+	"3": "ultra",
+};
+
+const PONYTAIL_COMMAND_OPTIONS = [
+	{ value: "1", label: "1 (lite)", description: "Name the lazier alternative" },
+	{ value: "2", label: "2 (full)", description: "The ladder enforced" },
+	{ value: "3", label: "3 (ultra)", description: "YAGNI extremist" },
+	{ value: "lite", label: "lite", description: "Name the lazier alternative" },
+	{ value: "full", label: "full", description: "The ladder enforced" },
+	{ value: "ultra", label: "ultra", description: "YAGNI extremist" },
+	{ value: "off", label: "off", description: "Disable ponytail mode" },
+	{ value: "stop", label: "stop", description: "Disable ponytail mode" },
+	{ value: "quit", label: "quit", description: "Disable ponytail mode" },
+	{ value: "config", label: "config", description: "Open settings dialog" },
+] as const;
+
+// ── Status labels ─────────────────────────────────────────────────────────────
+
+export const STATUS_LABELS: Record<Exclude<Level, "off">, string> = {
+	lite: "LITE",
+	full: "FULL",
+	ultra: "ULTRA",
+};
+
+// ── Prompt fragments ──────────────────────────────────────────────────────────
+
+const BASE = `\
+PONYTAIL MODE ACTIVE. You are a lazy senior developer. Lazy means efficient, \
+not careless. The best code is the code never written.
+
+Before writing any code, stop at the first rung that holds:
+1. Does this need to exist at all? Speculative need = skip it, say so in one line. (YAGNI)
+2. Stdlib does it? Use it.
+3. Native platform feature covers it? Use it (\`<input type="date">\` over a picker lib, CSS over JS, DB constraint over app code).
+4. Already-installed dependency solves it? Use it. Never add a new one for what a few lines can do.
+5. Can it be one line? One line.
+6. Only then: the minimum code that works.
+
+The ladder is a reflex, not a research project. Two rungs work → take the higher one and move on.
+
+Rules:
+- No unrequested abstractions: no interface with one impl, no factory for one product, no config for a value that never changes.
+- No boilerplate, no scaffolding "for later". Deletion over addition. Boring over clever. Fewest files possible.
+- Complex request? Ship the lazy version and question it in the same response. Never stall on an answer you can default.
+- Two same-size stdlib options? Take the one correct on edge cases. Lazy means less code, not the flimsier algorithm.
+- Mark deliberate simplifications with a \`ponytail:\` comment. A shortcut with a known ceiling names the ceiling and the upgrade path.`;
+
+const INTENSITY: Record<Exclude<Level, "off">, string> = {
+	lite: `\
+Build what's asked, but name the lazier alternative in one line. User picks.
+Example: "Done, cache added. FYI: \`functools.lru_cache\` covers this in one line if you'd rather not own a cache class."`,
+
+	full: `\
+The ladder enforced. Stdlib and native first. Shortest diff, shortest explanation.
+Example: "\`@lru_cache(maxsize=1000)\` on the fetch function. Skipped custom cache class, add when lru_cache measurably falls short."`,
+
+	ultra: `\
+YAGNI extremist. Deletion before addition. Ship the one-liner and challenge the rest of the requirement in the same breath.
+Example: "No cache until a profiler says so. When it does: \`@lru_cache\`. A hand-rolled TTL cache class is a bug farm with a hit rate."`,
+};
+
+const SAFETY = `\
+When NOT to be lazy: never simplify away input validation at trust boundaries, \
+error handling that prevents data loss, security, accessibility, or anything \
+explicitly requested. Hardware is never the spec ideal — leave the calibration knob.
+Lazy code without its check is unfinished: non-trivial logic leaves ONE runnable check behind \
+(an assert-based self-check or one small test file; no frameworks). Trivial one-liners need no test.
+Output: code first, then at most three short lines — what was skipped, when to add it.
+Boundaries: ponytail governs what you build, not how you talk. "stop ponytail" / "normal mode" reverts.`;
+
+/**
+ * Build the system prompt injection for a given level.
+ * Returns empty string when level is "off".
+ */
+export function buildPrompt(level: Level): string {
+	if (level === "off") return "";
+	return [BASE, "", `Intensity: ${INTENSITY[level]}`, "", SAFETY].join("\n");
+}
+
+// ── Level resolution ──────────────────────────────────────────────────────────
+
+/**
+ * Resolve a raw command arg to a Level, or return null if unrecognised.
+ * Handles stop aliases (stop/quit → "off") and valid level names.
+ */
+export function resolveLevel(arg: string): Level | null {
+	const a = arg.trim().toLowerCase();
+	if (STOP_ALIASES.has(a)) return "off";
+	if (LEVEL_NUMBERS[a]) return LEVEL_NUMBERS[a];
+	if (LEVELS.includes(a as Level)) return a as Level;
+	return null;
+}
+
+/**
+ * Help text shown when /opt ponytail is run with no argument.
+ */
+export function buildHelp(current: Level): string {
+	const statusLine =
+		current === "off" ? "off" : `${STATUS_LABELS[current]} (${current})`;
+	return [
+		`Ponytail mode: ${statusLine}`,
+		"",
+		"Usage: /opt ponytail <level>",
+		"  1  lite   - name the lazier alternative, you pick",
+		"  2  full   - the ladder enforced (default)",
+		"  3  ultra  - YAGNI extremist",
+		"  0  off    - disable (aliases: off, stop, quit)",
+		"",
+		"  config    - open settings dialog",
+	].join("\n");
+}
+
+/**
+ * Toggle: off → full, anything else → off.
+ */
+export function toggleLevel(current: Level): Level {
+	return current === "off" ? "full" : "off";
+}
+
+// ── Config ────────────────────────────────────────────────────────────────────
+
+export interface PonytailConfig {
+	/** Level to apply on new sessions. "off" means don't auto-enable. */
+	defaultLevel: Level;
+	/** Whether to show the status bar indicator. */
+	showStatus: boolean;
+}
+
+export const DEFAULT_CONFIG: PonytailConfig = {
+	defaultLevel: "full",
+	showStatus: true,
+};
+
+const CONFIG_PATH = join(homedir(), ".pi", "agent", "ponytail.json");
+
+export function parseConfig(raw: unknown): PonytailConfig {
+	const parsed = raw as Record<string, unknown>;
+	return {
+		defaultLevel: LEVELS.includes(parsed?.defaultLevel as Level)
+			? (parsed.defaultLevel as Level)
+			: DEFAULT_CONFIG.defaultLevel,
+		showStatus:
+			typeof parsed?.showStatus === "boolean"
+				? parsed.showStatus
+				: DEFAULT_CONFIG.showStatus,
+	};
+}
+
+let _saveQueue: Promise<void> = Promise.resolve();
+
+async function loadConfig(): Promise<PonytailConfig> {
+	try {
+		const raw = await readFile(CONFIG_PATH, "utf8");
+		return parseConfig(JSON.parse(raw));
+	} catch {
+		return { ...DEFAULT_CONFIG };
+	}
+}
+
+async function saveConfig(config: PonytailConfig): Promise<void> {
+	const snapshot = `${JSON.stringify(config, null, 2)}\n`;
+	_saveQueue = _saveQueue.then(async () => {
+		await mkdir(join(homedir(), ".pi", "agent"), { recursive: true });
+		await writeFile(CONFIG_PATH, snapshot, "utf8");
+	});
+	return _saveQueue;
+}
+
+// ── Pi extension ────────────────────────────────────────────────────────────
+
+export function ponytail(
+	pi: ExtensionAPI,
+	status: OptimizerStatus,
+): OptimizerHandle {
+	let level: Level = "off";
+	let config: PonytailConfig = { ...DEFAULT_CONFIG };
+	let configLoadPromise: Promise<void> | null = null;
+
+	const ensureConfigLoaded = async () => {
+		if (!configLoadPromise) {
+			configLoadPromise = (async () => {
+				config = await loadConfig();
+				if (level === "off" && config.defaultLevel !== "off") {
+					level = config.defaultLevel;
+				}
+			})();
+		}
+		await configLoadPromise;
+	};
+
+	// -- Status: report into the shared optimizer indicator. --
+
+	function syncStatus(ctx: Pick<ExtensionContext, "ui">) {
+		const on = level !== "off" && config.showStatus;
+		status.set("ponytail", on, ctx);
+	}
+
+	// Inject ponytail prompt via before_agent_start
+	pi.on("before_agent_start", async (event, _ctx) => {
+		const prompt = buildPrompt(level);
+		if (!prompt) return undefined;
+		const existing = event.systemPrompt ?? "";
+		return { systemPrompt: `${prompt}\n\n${existing}` };
+	});
+
+	// -- Restore state on session load --
+
+	pi.on("session_start", async (_event, ctx) => {
+		await ensureConfigLoaded();
+
+		let sessionLevel: Level | null = null;
+		for (const entry of ctx.sessionManager.getEntries()) {
+			if (entry.type === "custom" && entry.customType === "ponytail-level") {
+				sessionLevel = (entry.data as { level: Level })?.level ?? null;
+			}
+		}
+
+		if (sessionLevel !== null) {
+			level = sessionLevel;
+		} else if (config.defaultLevel !== "off") {
+			level = config.defaultLevel;
+			pi.appendEntry("ponytail-level", { level });
+		}
+
+		syncStatus(ctx);
+	});
+
+	pi.on("agent_start", async (_event, ctx) => {
+		syncStatus(ctx);
+	});
+	pi.on("agent_end", async (_event, ctx) => {
+		syncStatus(ctx);
+	});
+	pi.on("session_shutdown", async () => {});
+
+	// -- Subcommand handler (dispatched by the merged /opt router) --
+
+	async function run(
+		args: string,
+		ctx: ExtensionCommandContext,
+	): Promise<void> {
+		const arg = args.trim().toLowerCase();
+
+		// No argument → show help
+		if (!arg) {
+			ctx.ui.notify(buildHelp(level), "info");
+			return;
+		}
+
+		if (arg === "config") {
+			await openConfig(ctx);
+			return;
+		}
+
+		const resolved = resolveLevel(arg);
+		if (resolved === null) {
+			ctx.ui.notify(
+				`Unknown: "${arg}". Use 1/2/3, ${LEVELS.join(", ")}, stop, quit, or config`,
+				"error",
+			);
+			return;
+		}
+		level = resolved;
+
+		pi.appendEntry("ponytail-level", { level });
+		syncStatus(ctx);
+
+		ctx.ui.notify(
+			level === "off"
+				? "Ponytail mode off."
+				: `Ponytail: ${STATUS_LABELS[level]}`,
+			"info",
+		);
+	}
+
+	function complete(prefix: string) {
+		const normalized = prefix.trim().toLowerCase();
+		const items = PONYTAIL_COMMAND_OPTIONS.filter((item) =>
+			item.value.startsWith(normalized),
+		);
+		return items.length > 0 ? items.map((i) => ({ ...i })) : null;
+	}
+
+	// -- config: interactive SettingsList --
+
+	async function openConfig(ctx: ExtensionContext) {
+		await ensureConfigLoaded();
+
+		await ctx.ui.custom((_tui, theme, _kb, done) => {
+			const items: SettingItem[] = [
+				{
+					id: "defaultLevel",
+					label: "Default level for new sessions",
+					currentValue: config.defaultLevel,
+					values: [...LEVELS],
+				},
+				{
+					id: "showStatus",
+					label: "Show status bar",
+					currentValue: config.showStatus ? "on" : "off",
+					values: ["on", "off"],
+				},
+			];
+
+			const container = new Container();
+			container.addChild(
+				new Text(theme.fg("accent", theme.bold(" Ponytail Config")), 0, 0),
+			);
+			container.addChild(
+				new Text(theme.fg("dim", " Saved to ~/.pi/agent/ponytail.json"), 0, 0),
+			);
+			container.addChild(
+				new Text(
+					theme.fg("dim", " Default level applies to future sessions."),
+					0,
+					0,
+				),
+			);
+			container.addChild(new Text("", 0, 0));
+
+			const applySettingChange = (id: string, newValue: string) => {
+				if (id === "defaultLevel" && LEVELS.includes(newValue as Level)) {
+					config.defaultLevel = newValue as Level;
+				} else if (id === "showStatus") {
+					config.showStatus = newValue === "on";
+				}
+				saveConfig(config);
+				syncStatus(ctx);
+			};
+
+			const settingsList = new SettingsList(
+				items,
+				Math.min(items.length + 2, 10),
+				getSettingsListTheme(),
+				applySettingChange,
+				() => done(undefined),
+			);
+
+			container.addChild(settingsList);
+			container.addChild(
+				new Text(
+					theme.fg("dim", " ←→/hl/tab change • ↑↓/jk move • esc close"),
+					0,
+					0,
+				),
+			);
+
+			const cycleSelectedValue = (direction: -1 | 1) => {
+				const selectedIndex = (
+					settingsList as unknown as { selectedIndex: number }
+				).selectedIndex;
+				const item = items[selectedIndex];
+				if (!item?.values?.length) return;
+				const currentIndex = item.values.indexOf(item.currentValue);
+				const nextIndex =
+					(currentIndex + direction + item.values.length) % item.values.length;
+				const newValue = item.values[nextIndex]!;
+				item.currentValue = newValue;
+				settingsList.updateValue(item.id, newValue);
+				applySettingChange(item.id, newValue);
+			};
+
+			return {
+				render: (w: number) => container.render(w),
+				invalidate: () => container.invalidate(),
+				handleInput: (data: string) => {
+					if (data === "j") data = "\u001b[B";
+					else if (data === "k") data = "\u001b[A";
+					else if (data === "h") {
+						cycleSelectedValue(-1);
+						_tui.requestRender();
+						return;
+					} else if (data === "l" || data === "\u001b[C" || data === "\t") {
+						cycleSelectedValue(1);
+						_tui.requestRender();
+						return;
+					} else if (data === "\u001b[D") {
+						cycleSelectedValue(-1);
+						_tui.requestRender();
+						return;
+					} else if (data === "\u001b" || data === "q") {
+						done(undefined);
+						return;
+					}
+
+					settingsList.handleInput(data);
+					_tui.requestRender();
+				},
+			};
+		});
+	}
+
+	return {
+		name: "ponytail",
+		help: "ponytail <1|2|3|lite|full|ultra|off|config> — lazy senior dev (minimal code)",
+		run,
+		complete,
+	};
+}

package/src/status.test.ts

@@ -11,26 +11,36 @@ const tag = (c: string, t: string) => `<${c}>${t}</${c}>`;
 
 describe("renderStatus", () => {
 	it("shows ALL icons in order, accent when enabled", () => {
-		expect(renderStatus({ caveman: true, rtk: true, toon: true }, tag)).toBe(
-			`<accent>${TOOL_ICONS.caveman}</accent>  <accent>${TOOL_ICONS.rtk}</accent>  <accent>${TOOL_ICONS.toon}</accent> `,
+		expect(
+			renderStatus(
+				{ caveman: true, rtk: true, toon: true, ponytail: true },
+				tag,
+			),
+		).toBe(
+			`<accent>${TOOL_ICONS.caveman}</accent>  <accent>${TOOL_ICONS.rtk}</accent>  <accent>${TOOL_ICONS.toon}</accent>  <accent>${TOOL_ICONS.ponytail}</accent> `,
 		);
 	});
 
 	it("dims disabled tools but still shows them", () => {
-		expect(renderStatus({ caveman: false, rtk: true, toon: true }, tag)).toBe(
-			`<dim>${TOOL_ICONS.caveman}</dim>  <accent>${TOOL_ICONS.rtk}</accent>  <accent>${TOOL_ICONS.toon}</accent> `,
+		expect(
+			renderStatus(
+				{ caveman: false, rtk: true, toon: true, ponytail: true },
+				tag,
+			),
+		).toBe(
+			`<dim>${TOOL_ICONS.caveman}</dim>  <accent>${TOOL_ICONS.rtk}</accent>  <accent>${TOOL_ICONS.toon}</accent>  <accent>${TOOL_ICONS.ponytail}</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.caveman}</dim>  <dim>${TOOL_ICONS.rtk}</dim>  <dim>${TOOL_ICONS.toon}</dim>  <dim>${TOOL_ICONS.ponytail}</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> `,
+			`<accent>${TOOL_ICONS.caveman}</accent>  <dim>${TOOL_ICONS.rtk}</dim>  <accent>${TOOL_ICONS.toon}</accent>  <dim>${TOOL_ICONS.ponytail}</dim> `,
 		);
 	});
 });
@@ -55,9 +65,9 @@ describe("OptimizerStatus", () => {
 		status.set("rtk", true, ctx as never);
 		const last = ctx.calls.at(-1)!;
 		expect(last.key).toBe(STATUS_KEY);
-		// caveman + toon still unset (dim), rtk accent.
+		// 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.caveman}</dim>  <accent>${TOOL_ICONS.rtk}</accent>  <dim>${TOOL_ICONS.toon}</dim>  <dim>${TOOL_ICONS.ponytail}</dim> `,
 		);
 	});
 
@@ -68,7 +78,7 @@ describe("OptimizerStatus", () => {
 		status.set("toon", true, ctx as never);
 		const last = ctx.calls.at(-1)!;
 		expect(last.text).toBe(
-			`<accent>${TOOL_ICONS.caveman}</accent>  <dim>${TOOL_ICONS.rtk}</dim>  <accent>${TOOL_ICONS.toon}</accent> `,
+			`<accent>${TOOL_ICONS.caveman}</accent>  <dim>${TOOL_ICONS.rtk}</dim>  <accent>${TOOL_ICONS.toon}</accent>  <dim>${TOOL_ICONS.ponytail}</dim> `,
 		);
 	});
 
@@ -79,7 +89,7 @@ describe("OptimizerStatus", () => {
 		status.set("rtk", false, ctx as never);
 		const last = ctx.calls.at(-1)!;
 		expect(last.text).toBe(
-			`<dim>${TOOL_ICONS.caveman}</dim>  <dim>${TOOL_ICONS.rtk}</dim>  <dim>${TOOL_ICONS.toon}</dim> `,
+			`<dim>${TOOL_ICONS.caveman}</dim>  <dim>${TOOL_ICONS.rtk}</dim>  <dim>${TOOL_ICONS.toon}</dim>  <dim>${TOOL_ICONS.ponytail}</dim> `,
 		);
 	});
 });

package/src/status.ts

@@ -7,8 +7,8 @@
  * the cell renders only the icons whose tool is currently enabled, in a fixed
  * order, accent-colored. When everything is off the cell is empty.
  *
- *   all on:        ⛏ ⚔ ✂
- *   caveman off:   ⚔ ✂
+ *   all on:        󰜐 󰓥 󰗀 󰆐
+ *   caveman off:   󰓥 󰗀 󰆐
  *   all off:       (empty)
  */
 
@@ -44,16 +44,22 @@ export interface OptimizerHandle {
 export const STATUS_KEY = "pix-optimizer";
 
 /** Tools that participate in the shared indicator, in render order. */
-export type OptimizerTool = "caveman" | "rtk" | "toon";
+export type OptimizerTool = "caveman" | "rtk" | "toon" | "ponytail";
 
 export const TOOL_ICONS: Record<OptimizerTool, string> = {
-	caveman: "⛏",
-	rtk: "⚔",
-	toon: "✂",
+	caveman: "󰜐",
+	rtk: "󰓥",
+	toon: "󰗀",
+	ponytail: "󰆐",
 };
 
 /** Fixed left-to-right order of icons in the cell. */
-const TOOL_ORDER: readonly OptimizerTool[] = ["caveman", "rtk", "toon"];
+const TOOL_ORDER: readonly OptimizerTool[] = [
+	"caveman",
+	"rtk",
+	"toon",
+	"ponytail",
+];
 
 /** Theme color for enabled icons. */
 const ENABLED_COLOR: ThemeColor = "accent";