@xynogen/pix-optimizer 1.0.6 → 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 (+ bundled skill)
+- **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,13 +63,16 @@ Two layers, both active automatically:
 cargo install rtk-ai
 ```
 
-### TOON / JSON Compression (`✂`)
+### TOON / JSON Compression (`󰗀`)
 
-Guidance + a bundled `toon-json` skill for handling information-dense JSON via
-`jq` (query/reshape) and `toon` (compress). The system-prompt nudge is injected
-**only when the user prompt mentions JSON** (`json`/`jsonl`/`jq`/`toon`/
-`openapi`/…). TOON shines on uniform/tabular arrays; deeply nested or
-array-of-arrays data and API contracts stay as JSON.
+Guidance for handling information-dense JSON via `jq` (query/reshape) and
+`toon` (compress). The system-prompt nudge is injected **only when the user
+prompt mentions JSON** (`json`/`jsonl`/`jq`/`toon`/`openapi`/…). TOON shines
+on uniform/tabular arrays; deeply nested or array-of-arrays data and API
+contracts stay as JSON.
+
+The `toon-json` skill (full workflow + when-NOT-to-use guidance) is bundled in
+`pix-skills` and auto-discovered from there.
 
 **Requirement:** `jq` and `toon` on `PATH`.
 
@@ -75,6 +80,26 @@ array-of-arrays data and API contracts stay as JSON.
 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
@@ -85,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, bundled skill registration  |
+| `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
 
@@ -113,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.6",
-	"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/json.test.ts

@@ -5,7 +5,6 @@ import {
 	JSON_SYSTEM_PROMPT,
 	mentionsJson,
 	objectDepth,
-	skillDir,
 } from "./json.ts";
 
 describe("JSON_SYSTEM_PROMPT", () => {
@@ -168,10 +167,3 @@ describe("adviseToon", () => {
 		expect(adviseToon(d2, 2).useToon).toBe(true);
 	});
 });
-
-describe("skillDir", () => {
-	it("points at the bundled toon-json skill", () => {
-		const dir = skillDir();
-		expect(dir.endsWith("skills/toon-json")).toBe(true);
-	});
-});

package/src/json.ts

@@ -1,12 +1,12 @@
 /**
  * json.ts — JSON token-optimization via jq + TOON.
  *
- * Two parts, mirroring rtk.ts/caveman.ts:
- *   1. A small system-prompt nudge teaching the model to run JSON through
- *      `jq` (query/reshape) and `toon` (compress for context), and to convert
- *      back to JSON only when a strict contract requires it.
- *   2. A bundled `toon-json` skill, surfaced via `resources_discover`, that
- *      holds the full workflow + when-NOT-to-use guidance.
+ * A small system-prompt nudge teaching the model to run JSON through
+ * `jq` (query/reshape) and `toon` (compress for context), and to convert
+ * back to JSON only when a strict contract requires it.
+ *
+ * The bundled `toon-json` skill lives in pix-skills and is auto-discovered
+ * from there — no resources_discover hook needed here.
  *
  * TOON = Token-Oriented Object Notation (https://github.com/toon-format/spec).
  * It shines on uniform/tabular arrays of objects (declare keys once, stream
@@ -17,8 +17,6 @@
  * by index.ts alongside caveman(pi) and rtk(pi).
  */
 
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 import type {
 	ExtensionAPI,
 	ExtensionCommandContext,
@@ -207,15 +205,6 @@ export function objectDepth(value: unknown): number {
 
 // ── Bundled skill path ────────────────────────────────────────────────────────
 
-/**
- * Absolute path to the bundled `toon-json` skill directory, resolved relative
- * to this module so it works regardless of the extension's install location.
- */
-export function skillDir(): string {
-	const here = fileURLToPath(new URL(".", import.meta.url));
-	return join(here, "skills", "toon-json");
-}
-
 // ── Pi extension ──────────────────────────────────────────────────────────────
 
 export function json(
@@ -245,12 +234,6 @@ export function json(
 		syncStatus(ctx);
 	});
 
-	// Surface the bundled skill so the model can load the full workflow.
-	pi.on("resources_discover", async () => {
-		if (!enabled) return undefined;
-		return { skillPaths: [skillDir()] };
-	});
-
 	// Inject the JSON-handling nudge into the system prompt, but ONLY when the
 	// user prompt actually mentions JSON / a related token — otherwise it's dead
 	// weight in every turn. Probe jq/toon lazily here (not at session_start) so

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";

package/src/skills/toon-json/SKILL.md

@@ -1,101 +0,0 @@
----
-name: toon-json
-description: Manipulate information-dense JSON efficiently with jq + TOON. Use when fetching/reading large or repetitive JSON (LLM schemas, OpenAPI specs, API responses, datasets, config dumps) into context. Query/reshape with jq, compress to TOON to cut tokens, decode back to JSON only when a strict contract needs it.
----
-
-# TOON + jq: Dense JSON Workflow
-
-## Goal
-Carry only the JSON slice you need, in the cheapest encoding. Query with `jq`,
-compress with `toon`, and round-trip back to JSON **only** when a contract
-requires strict JSON.
-
-TOON (Token-Oriented Object Notation, https://github.com/toon-format/spec) is a
-line-oriented encoding of the JSON data model. Uniform arrays of objects declare
-their keys once and stream bare rows, so token cost drops sharply on tabular and
-dense data.
-
-## The pipeline
-
-```bash
-# Fetch → reshape → compress (most common)
-curl -s https://api.example.com/models | jq '.data' | toon
-
-# Local file, show token savings
-cat openapi.json | jq '.paths' | toon --stats
-
-# Just compress, no query
-cat data.json | toon
-
-# Convert TOON back to JSON (strict contract / downstream parser)
-echo "$TOON_BLOB" | toon -d
-cat data.toon | toon --decode
-```
-
-`toon` auto-detects direction from input. Force it with `-e` (encode JSON→TOON)
-or `-d` (decode TOON→JSON).
-
-### Useful flags
-- `--stats` — print token/byte statistics for the conversion
-- `--delimiter=,|\t|"|"` — array delimiter (comma default; tab/pipe can tokenize better)
-- `--keyFolding=safe` — collapse single-key nesting chains
-- `--no-strict` — lenient decode
-
-## Decide before you compress
-
-TOON is not always smaller. Pick based on shape:
-
-| Shape | Action | Why |
-|---|---|---|
-| Uniform array of objects (same keys, primitive values) | **TOON** | Sweet spot — keys declared once, rows streamed; savings scale with rows × fields |
-| Flat object / primitive array | **TOON** | Drops quotes and braces |
-| Shallow nesting | **TOON** | Indentation cheaper than braces at low depth |
-| Deeply nested / non-uniform | **JSON** | Indentation cost grows; compact JSON can win |
-| Array of arrays | **JSON** | TOON's one structurally-worse case (explicit list markers + inner headers) |
-| API contract / payload to send or store | **JSON** | Must stay valid JSON for the consumer |
-
-Rule of thumb: **TOON for reading dense data into context. JSON for contracts.**
-
-## When NOT to use TOON
-- Anything sent to or stored by an API that expects JSON.
-- Data a downstream tool/parser must consume as strict JSON.
-- Deeply nested config trees or highly irregular structures.
-- Tiny payloads where the conversion overhead isn't worth it.
-
-In those cases, still use `jq` to slice down to what you need — just skip the
-`| toon` step.
-
-## Worked examples
-
-LLM model list (uniform array → great TOON candidate):
-
-```bash
-curl -s https://api.example.com/v1/models | jq '.data | map({id, owned_by, context})' | toon
-```
-```
-[3]{id,owned_by,context}:
-  gpt-x,acme,128000
-  gpt-y,acme,200000
-  gpt-z,acme,1000000
-```
-
-OpenAPI paths summary (reshape first, then compress):
-
-```bash
-cat openapi.json \
-  | jq '[.paths | to_entries[] | {path: .key, methods: (.value | keys)}]' \
-  | toon --stats
-```
-
-Round-trip back to JSON for an API call:
-
-```bash
-RESHAPED=$(cat payload.toon | toon -d)
-curl -s -X POST https://api.example.com/ingest -d "$RESHAPED"
-```
-
-## Checklist
-1. **Query** — narrow with `jq` to the exact slice needed.
-2. **Decide** — uniform/tabular/shallow → TOON; nested/array-of-arrays/contract → JSON.
-3. **Compress** — `| toon` (add `--stats` to confirm savings).
-4. **Round-trip** — `toon -d` only when strict JSON is required downstream.