chore: bump version to 4.3.0 (#38)

Release-prep bump across the Claude Code, Codex, and Gemini manifests.
Cutting v4.3.0 also fixes #33: gemini extensions install pulls the latest
GitHub release, and gemini-extension.json was added after v4.2.0, so it
was missing from the release tarball. Shipping it in a release fixes the
plain install command.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ponytail",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "Lazy senior dev mode. Forces the simplest, shortest solution that actually works: YAGNI, stdlib first, no unrequested abstractions.",
   "author": {
     "name": "Dietrich Gebert",

.clinerules/ponytail.md

@@ -1,4 +1,4 @@
-# Ponytail — lazy senior dev mode
+# Ponytail, lazy senior dev mode
 
 You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
 
@@ -18,7 +18,7 @@ Rules:
 - No boilerplate nobody asked for.
 - Deletion over addition. Boring over clever. Fewest files possible.
 - Question complex requests: "Do you actually need X, or does Y cover it?"
-- Pick the edge-case-correct option when two stdlib approaches are the same size — lazy means less code, not the flimsier algorithm.
+- Pick the edge-case-correct option when two stdlib approaches are the same size, lazy means less code, not the flimsier algorithm.
 - Mark intentional simplifications with a `ponytail:` comment. If the shortcut has a known ceiling (global lock, O(n²) scan, naive heuristic), the comment names the ceiling and the upgrade path.
 
-Not lazy about: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind — the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.
+Not lazy about: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind, the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.

.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ponytail",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "Lazy senior dev mode. Forces the simplest, shortest solution that actually works: YAGNI, stdlib first, no unrequested abstractions.",
   "author": {
     "name": "Dietrich Gebert",

.cursor/rules/ponytail.mdc

@@ -1,10 +1,10 @@
 ---
-description: Ponytail — lazy senior dev mode. Always pick the simplest solution that works.
+description: Ponytail, lazy senior dev mode. Always pick the simplest solution that works.
 globs:
 alwaysApply: true
 ---
 
-# Ponytail — lazy senior dev mode
+# Ponytail, lazy senior dev mode
 
 You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
 
@@ -24,7 +24,7 @@ Rules:
 - No boilerplate nobody asked for.
 - Deletion over addition. Boring over clever. Fewest files possible.
 - Question complex requests: "Do you actually need X, or does Y cover it?"
-- Pick the edge-case-correct option when two stdlib approaches are the same size — lazy means less code, not the flimsier algorithm.
+- Pick the edge-case-correct option when two stdlib approaches are the same size, lazy means less code, not the flimsier algorithm.
 - Mark intentional simplifications with a `ponytail:` comment. If the shortcut has a known ceiling (global lock, O(n²) scan, naive heuristic), the comment names the ceiling and the upgrade path.
 
-Not lazy about: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind — the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.
+Not lazy about: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind, the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.

.env.example

@@ -0,0 +1,2 @@
+# Copy to .env (gitignored) and fill in. promptfoo reads this automatically.
+ANTHROPIC_API_KEY=sk-ant-...

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [DietrichGebert]

.github/copilot-instructions.md

@@ -1,4 +1,4 @@
-# Ponytail — lazy senior dev mode
+# Ponytail, lazy senior dev mode
 
 You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
 
@@ -18,7 +18,7 @@ Rules:
 - No boilerplate nobody asked for.
 - Deletion over addition. Boring over clever. Fewest files possible.
 - Question complex requests: "Do you actually need X, or does Y cover it?"
-- Pick the edge-case-correct option when two stdlib approaches are the same size — lazy means less code, not the flimsier algorithm.
+- Pick the edge-case-correct option when two stdlib approaches are the same size, lazy means less code, not the flimsier algorithm.
 - Mark intentional simplifications with a `ponytail:` comment. If the shortcut has a known ceiling (global lock, O(n²) scan, naive heuristic), the comment names the ceiling and the upgrade path.
 
-Not lazy about: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind — the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.
+Not lazy about: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind, the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.

.gitignore

@@ -0,0 +1,11 @@
+# Secrets, never commit API keys
+.env
+.env.*
+!.env.example
+
+# Dependencies
+node_modules/
+
+# promptfoo eval artifacts
+.promptfoo/
+benchmarks/output*

.kiro/steering/ponytail.md

@@ -1,9 +1,9 @@
 ---
-title: Ponytail — lazy senior dev mode
+title: Ponytail, lazy senior dev mode
 inclusion: always
 ---
 
-# Ponytail — lazy senior dev mode
+# Ponytail, lazy senior dev mode
 
 You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
 
@@ -23,7 +23,7 @@ Rules:
 - No boilerplate nobody asked for.
 - Deletion over addition. Boring over clever. Fewest files possible.
 - Question complex requests: "Do you actually need X, or does Y cover it?"
-- Pick the edge-case-correct option when two stdlib approaches are the same size — lazy means less code, not the flimsier algorithm.
+- Pick the edge-case-correct option when two stdlib approaches are the same size, lazy means less code, not the flimsier algorithm.
 - Mark intentional simplifications with a `ponytail:` comment. If the shortcut has a known ceiling (global lock, O(n²) scan, naive heuristic), the comment names the ceiling and the upgrade path.
 
-Not lazy about: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind — the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.
+Not lazy about: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind, the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.

.opencode/command/ponytail-audit.md

@@ -0,0 +1,5 @@
+---
+description: Audit the whole repo for over-engineering, what can be deleted
+---
+
+Audit the entire repository for over-engineering only, not correctness. Scan the whole tree, not a diff. One line per finding, ranked biggest cut first: <tag> <what to cut>. <replacement>. [path]. Tags: delete (dead code/speculative feature), stdlib (reinvented standard library), native (dependency doing what the platform does), yagni (abstraction with one implementation), shrink (same logic, fewer lines). End with the net lines and dependencies removable. If nothing to cut: 'Lean already. Ship.'

.opencode/command/ponytail-review.md

@@ -1,5 +1,5 @@
 ---
-description: Review changes for over-engineering — what can be deleted
+description: Review changes for over-engineering, what can be deleted
 ---
 
-Review the current code changes for over-engineering only — not correctness. One line per finding: L<line>: <tag> <what to cut>. <replacement>. Tags: delete (dead code/speculative feature), stdlib (reinvented standard library), native (dependency doing what the platform does), yagni (abstraction with one implementation), shrink (same logic, fewer lines). End with the net lines removable. If nothing to cut: 'Lean already. Ship.'
+Review the current code changes for over-engineering only, not correctness. One line per finding: L<line>: <tag> <what to cut>. <replacement>. Tags: delete (dead code/speculative feature), stdlib (reinvented standard library), native (dependency doing what the platform does), yagni (abstraction with one implementation), shrink (same logic, fewer lines). End with the net lines removable. If nothing to cut: 'Lean already. Ship.'

.opencode/command/ponytail.md

@@ -2,4 +2,4 @@
 description: Switch ponytail intensity level (lite/full/ultra/off)
 ---
 
-Switch to ponytail $ARGUMENTS mode. If no level specified, use full. Lazy senior dev mode — before any code: does it need to exist at all (YAGNI)? Does the standard library do it? A native platform feature? Can it be one line? Build the minimum that works. No unrequested abstractions, no avoidable dependencies, no boilerplate. Mark intentional simplifications with a ponytail: comment.
+Switch to ponytail $ARGUMENTS mode. If no level specified, use full. Lazy senior dev mode, before any code: does it need to exist at all (YAGNI)? Does the standard library do it? A native platform feature? Can it be one line? Build the minimum that works. No unrequested abstractions, no avoidable dependencies, no boilerplate. Mark intentional simplifications with a ponytail: comment.

.windsurf/rules/ponytail.md

@@ -1,4 +1,4 @@
-# Ponytail — lazy senior dev mode
+# Ponytail, lazy senior dev mode
 
 You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
 
@@ -18,7 +18,7 @@ Rules:
 - No boilerplate nobody asked for.
 - Deletion over addition. Boring over clever. Fewest files possible.
 - Question complex requests: "Do you actually need X, or does Y cover it?"
-- Pick the edge-case-correct option when two stdlib approaches are the same size — lazy means less code, not the flimsier algorithm.
+- Pick the edge-case-correct option when two stdlib approaches are the same size, lazy means less code, not the flimsier algorithm.
 - Mark intentional simplifications with a `ponytail:` comment. If the shortcut has a known ceiling (global lock, O(n²) scan, naive heuristic), the comment names the ceiling and the upgrade path.
 
-Not lazy about: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind — the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.
+Not lazy about: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind, the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.

AGENTS.md

@@ -1,4 +1,4 @@
-# Ponytail — lazy senior dev mode
+# Ponytail, lazy senior dev mode
 
 You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
 
@@ -18,9 +18,9 @@ Rules:
 - No boilerplate nobody asked for.
 - Deletion over addition. Boring over clever. Fewest files possible.
 - Question complex requests: "Do you actually need X, or does Y cover it?"
-- Pick the edge-case-correct option when two stdlib approaches are the same size — lazy means less code, not the flimsier algorithm.
+- Pick the edge-case-correct option when two stdlib approaches are the same size, lazy means less code, not the flimsier algorithm.
 - Mark intentional simplifications with a `ponytail:` comment. If the shortcut has a known ceiling (global lock, O(n²) scan, naive heuristic), the comment names the ceiling and the upgrade path.
 
-Not lazy about: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind — the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.
+Not lazy about: input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. Non-trivial logic leaves ONE runnable check behind, the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.
 
 (Yes, this file also applies to agents working on the ponytail repo itself. Especially to them.)

README.md

@@ -8,6 +8,18 @@
   <em>He says nothing. He writes one line. It works.</em>
 </p>
 
+<p align="center">
+  <img src="https://img.shields.io/github/stars/DietrichGebert/ponytail?style=flat-square&color=111111&label=stars" alt="Stars">
+  <img src="https://img.shields.io/github/v/release/DietrichGebert/ponytail?style=flat-square&color=111111&label=release" alt="Release">
+  <img src="https://img.shields.io/badge/works%20with-11%20agents-111111?style=flat-square" alt="Works with 11 agents">
+  <img src="https://img.shields.io/badge/license-MIT-111111?style=flat-square" alt="MIT license">
+</p>
+
+<p align="center">
+  <strong>80-94% less code &middot; 3-6&times; faster &middot; 47-77% cheaper</strong><br>
+  <sub>Median of 10 runs across Haiku, Sonnet, and Opus. <a href="benchmarks/">Reproduce it yourself.</a></sub>
+</p>
+
 ---
 
 You know him. Long ponytail. Oval glasses. Has been at the company longer than the version control. You show him fifty lines; he looks at them, says nothing, and replaces them with one.
@@ -29,13 +41,13 @@ More survivors in [examples/](examples/).
 
 ## Numbers
 
-Six tasks: streaming log parser, atomic file sync, notification dispatcher, validation engine, auth module, concurrent money ledger. One spec each, one fresh agent per arm, same model. Three arms: no skill, the [caveman](https://github.com/JuliusBrussee/caveman) skill, and ponytail. Every arm passes the same adversarial security and concurrency probes. Then the agreement ends:
+Five everyday tasks (email validator, debounce, CSV sum, countdown timer, rate limiter), three models, three arms: no skill, the [caveman](https://github.com/JuliusBrussee/caveman) skill, and ponytail. Ten runs per cell, median reported.
 
 <p align="center">
-  <img src="assets/benchmark-loc.svg" width="860" alt="Lines of code per task: ponytail 490 total vs caveman 1,440 vs no-skill control 3,629, all passing the same adversarial probes">
+  <img src="assets/benchmark-3model.svg" width="860" alt="Median lines of code per arm across Haiku, Sonnet and Opus; ponytail writes 80-94% less code than the no-skill baseline">
 </p>
 
-**47% fewer tokens than the no-skill agent. 3× faster. A seventh of the code.** The 3,139 lines nobody wrote have never caused an incident. When a surprise feature request hit two of the tasks, ponytail extended in 96 changed lines; caveman needed 413, the no-skill agent 1,115. Every shortcut ponytail took is marked in the code with a `ponytail:` comment naming its upgrade path. Data: [benchmarks/](benchmarks/).
+**80-94% less code, 47-77% less cost, and 3-6× faster than a no-skill agent, on every model.** Every shortcut ponytail takes is marked in the code with a `ponytail:` comment naming its upgrade path. Reproduce it yourself: `npx promptfoo eval -c benchmarks/promptfooconfig.yaml`. Method and raw numbers: [benchmarks/](benchmarks/). Production-grade tasks, where an unconstrained agent bloats far more, are written up in [benchmarks/results/](benchmarks/results/).
 
 ## How it works
 
@@ -87,19 +99,32 @@ Run OpenCode from a checkout of this repo (the plugin reuses its `hooks/` and `s
 { "plugin": ["./.opencode/plugins/ponytail.mjs"] }
 ```
 
-Injects the ruleset every turn at the active level; adds `/ponytail` and `/ponytail-review`. OpenCode also auto-loads this repo's `AGENTS.md`, so the rules hold even without the plugin — the plugin adds the `lite/full/ultra/off` levels.
+Injects the ruleset every turn at the active level; adds `/ponytail`, `/ponytail-review`, and `/ponytail-audit`. OpenCode also auto-loads this repo's `AGENTS.md`, so the rules hold even without the plugin. The plugin adds the `lite/full/ultra/off` levels.
+
+### Gemini CLI
+
+```bash
+gemini extensions install https://github.com/DietrichGebert/ponytail
+```
+
+Loads the ruleset as always-on context every session and registers `/ponytail` and `/ponytail-review`; the `skills/` ship too, activated when a task needs them.
 
 That was it. He'd be proud. He won't say it.
 
-Active every session. `/ponytail-review` finds what to delete in your diff. `/ponytail ultra` exists for when the codebase has wronged you personally. `/ponytail-help` explains the rest.
+Active every session. `/ponytail-review` finds what to delete in your diff, `/ponytail-audit` does the same for the whole repo. `/ponytail ultra` exists for when the codebase has wronged you personally. `/ponytail-help` explains the rest.
 
-In Codex, invoke the skills as `@ponytail`, `@ponytail-review`, and
-`@ponytail-help`. Startup and mode-change text shows the current mode.
+In Codex, invoke the skills as `@ponytail`, `@ponytail-review`,
+`@ponytail-audit`, and `@ponytail-help`. Startup and mode-change text shows the
+current mode.
 
 Cursor, Windsurf, Cline, Copilot, Aider, Kiro: copy the matching rules file from this repo ([`.cursor/rules/`](.cursor/rules/), [`.windsurf/rules/`](.windsurf/rules/), [`.clinerules/`](.clinerules/), [`.github/copilot-instructions.md`](.github/copilot-instructions.md), [`AGENTS.md`](AGENTS.md), [`.kiro/steering/`](.kiro/steering/)).
 
 Kiro: copy `.kiro/steering/ponytail.md` to `~/.kiro/steering/` (global) or `.kiro/steering/` in your project.
 
+GitHub Copilot CLI: it already reads `AGENTS.md` and `.github/copilot-instructions.md` in a project, or copy the rules into `~/.copilot/copilot-instructions.md` to run ponytail in every project.
+
+Antigravity and VS Code with the Codex extension: both read `AGENTS.md`, which this repo ships, so it works from the repo root with no setup (`~/.codex/AGENTS.md` makes Codex global, `.agents/rules/` makes it an always-on rule in Antigravity).
+
 Which files map to which agent: [Agent portability](docs/agent-portability.md).
 
 ## Development

assets/benchmark-3model.svg

@@ -0,0 +1,21 @@
+<svg viewBox="0 0 860 336" xmlns="http://www.w3.org/2000/svg" font-family="-apple-system, 'Segoe UI', Helvetica, Arial, sans-serif">
+  <title>Median lines of code per arm across three models</title>
+  <text x="20" y="26" font-size="15" font-weight="600" fill="#8b949e">Median lines of code. 10 runs per cell. Lower is leaner.</text>
+  <text x="20" y="45" font-size="12" fill="#8b949e" opacity="0.85">Ponytail writes 80-94% less code, costs 47-77% less, and runs 3-6x faster than a no-skill agent.</text>
+  <rect x="20" y="58" width="12" height="12" rx="2" fill="#8b949e"/><text x="38" y="69" font-size="13" fill="#8b949e">baseline (no skill)</text>
+  <rect x="190" y="58" width="12" height="12" rx="2" fill="#d9822b"/><text x="208" y="69" font-size="13" fill="#8b949e">caveman</text>
+  <rect x="300" y="58" width="12" height="12" rx="2" fill="#2da44e"/><text x="318" y="69" font-size="13" fill="#8b949e">ponytail</text>
+  <text x="112" y="119" font-size="13" font-weight="600" fill="#8b949e" text-anchor="end">Haiku</text>
+  <rect x="120" y="92" width="508" height="14" rx="2" fill="#8b949e"/><text x="634" y="103" font-size="11" fill="#8b949e">518</text>
+  <rect x="120" y="110" width="114" height="14" rx="2" fill="#d9822b"/><text x="240" y="121" font-size="11" fill="#d9822b">116</text>
+  <rect x="120" y="128" width="38" height="14" rx="2" fill="#2da44e"/><text x="164" y="139" font-size="11" fill="#2da44e" font-weight="600">39</text>
+  <text x="112" y="193" font-size="13" font-weight="600" fill="#8b949e" text-anchor="end">Sonnet</text>
+  <rect x="120" y="166" width="680" height="14" rx="2" fill="#8b949e"/><text x="806" y="177" font-size="11" fill="#8b949e">693</text>
+  <rect x="120" y="184" width="118" height="14" rx="2" fill="#d9822b"/><text x="244" y="195" font-size="11" fill="#d9822b">120</text>
+  <rect x="120" y="202" width="43" height="14" rx="2" fill="#2da44e"/><text x="169" y="213" font-size="11" fill="#2da44e" font-weight="600">44</text>
+  <text x="112" y="267" font-size="13" font-weight="600" fill="#8b949e" text-anchor="end">Opus</text>
+  <rect x="120" y="240" width="251" height="14" rx="2" fill="#8b949e"/><text x="377" y="251" font-size="11" fill="#8b949e">256</text>
+  <rect x="120" y="258" width="66" height="14" rx="2" fill="#d9822b"/><text x="192" y="269" font-size="11" fill="#d9822b">67</text>
+  <rect x="120" y="276" width="50" height="14" rx="2" fill="#2da44e"/><text x="176" y="287" font-size="11" fill="#2da44e" font-weight="600">51</text>
+  <text x="120" y="324" font-size="11" fill="#8b949e" opacity="0.8">Median of 10 runs/cell, default temperature. 5 tasks (email, debounce, CSV sum, countdown, rate-limit), same model per group. Reproduce: npx promptfoo eval -c benchmarks/promptfooconfig.yaml</text>
+</svg>

assets/benchmark-loc.svg

@@ -1,69 +0,0 @@
-<svg viewBox="0 0 860 470" xmlns="http://www.w3.org/2000/svg" font-family="-apple-system, 'Segoe UI', Helvetica, Arial, sans-serif">
-  <title>Non-blank lines of code per task: control vs caveman vs ponytail</title>
-
-  <text x="20" y="26" font-size="15" font-weight="600" fill="#8b949e">Six tasks. Adversarial probes: everyone passes. Lines of code: not everyone.</text>
-
-  <!-- legend -->
-  <rect x="20" y="42" width="12" height="12" rx="2" fill="#8b949e"/>
-  <text x="38" y="53" font-size="13" fill="#8b949e">Control (no skill) · 3,629 total</text>
-  <rect x="250" y="42" width="12" height="12" rx="2" fill="#d9822b"/>
-  <text x="268" y="53" font-size="13" fill="#8b949e">Caveman · 1,440</text>
-  <rect x="420" y="42" width="12" height="12" rx="2" fill="#2da44e"/>
-  <text x="438" y="53" font-size="13" fill="#8b949e">Ponytail · 490</text>
-
-  <!-- Task A -->
-  <text x="112" y="117" font-size="12" fill="#8b949e" text-anchor="end">log-analysis CLI</text>
-  <rect x="120" y="90" width="662" height="13" rx="2" fill="#8b949e"/>
-  <text x="788" y="101" font-size="11" fill="#8b949e">946</text>
-  <rect x="120" y="106" width="198" height="13" rx="2" fill="#d9822b"/>
-  <text x="324" y="117" font-size="11" fill="#d9822b">283</text>
-  <rect x="120" y="122" width="102" height="13" rx="2" fill="#2da44e"/>
-  <text x="228" y="133" font-size="11" fill="#2da44e" font-weight="600">145</text>
-
-  <!-- Task B -->
-  <text x="112" y="177" font-size="12" fill="#8b949e" text-anchor="end">file sync</text>
-  <rect x="120" y="150" width="459" height="13" rx="2" fill="#8b949e"/>
-  <text x="585" y="161" font-size="11" fill="#8b949e">656</text>
-  <rect x="120" y="166" width="160" height="13" rx="2" fill="#d9822b"/>
-  <text x="286" y="177" font-size="11" fill="#d9822b">228</text>
-  <rect x="120" y="182" width="69" height="13" rx="2" fill="#2da44e"/>
-  <text x="195" y="193" font-size="11" fill="#2da44e" font-weight="600">99</text>
-
-  <!-- Task C -->
-  <text x="112" y="237" font-size="12" fill="#8b949e" text-anchor="end">notification dispatcher</text>
-  <rect x="120" y="210" width="566" height="13" rx="2" fill="#8b949e"/>
-  <text x="692" y="221" font-size="11" fill="#8b949e">808</text>
-  <rect x="120" y="226" width="277" height="13" rx="2" fill="#d9822b"/>
-  <text x="403" y="237" font-size="11" fill="#d9822b">396</text>
-  <rect x="120" y="242" width="51" height="13" rx="2" fill="#2da44e"/>
-  <text x="177" y="253" font-size="11" fill="#2da44e" font-weight="600">73</text>
-
-  <!-- Task D -->
-  <text x="112" y="297" font-size="12" fill="#8b949e" text-anchor="end">validation engine</text>
-  <rect x="120" y="270" width="474" height="13" rx="2" fill="#8b949e"/>
-  <text x="600" y="281" font-size="11" fill="#8b949e">677</text>
-  <rect x="120" y="286" width="153" height="13" rx="2" fill="#d9822b"/>
-  <text x="279" y="297" font-size="11" fill="#d9822b">218</text>
-  <rect x="120" y="302" width="49" height="13" rx="2" fill="#2da44e"/>
-  <text x="175" y="313" font-size="11" fill="#2da44e" font-weight="600">70</text>
-
-  <!-- Task E -->
-  <text x="112" y="357" font-size="12" fill="#8b949e" text-anchor="end">auth module</text>
-  <rect x="120" y="330" width="182" height="13" rx="2" fill="#8b949e"/>
-  <text x="308" y="341" font-size="11" fill="#8b949e">260</text>
-  <rect x="120" y="346" width="104" height="13" rx="2" fill="#d9822b"/>
-  <text x="230" y="357" font-size="11" fill="#d9822b">148</text>
-  <rect x="120" y="362" width="34" height="13" rx="2" fill="#2da44e"/>
-  <text x="160" y="373" font-size="11" fill="#2da44e" font-weight="600">49</text>
-
-  <!-- Task F -->
-  <text x="112" y="417" font-size="12" fill="#8b949e" text-anchor="end">money ledger</text>
-  <rect x="120" y="390" width="197" height="13" rx="2" fill="#8b949e"/>
-  <text x="323" y="401" font-size="11" fill="#8b949e">282</text>
-  <rect x="120" y="406" width="117" height="13" rx="2" fill="#d9822b"/>
-  <text x="243" y="417" font-size="11" fill="#d9822b">167</text>
-  <rect x="120" y="422" width="38" height="13" rx="2" fill="#2da44e"/>
-  <text x="164" y="433" font-size="11" fill="#2da44e" font-weight="600">54</text>
-
-  <text x="120" y="458" font-size="11" fill="#8b949e" opacity="0.8">Non-blank LOC, AST-counted. Same model, same specs, one fresh agent per arm. Every arm passes the same security (8/8) and concurrency (6/6) probes. 2026-06-12.</text>
-</svg>

benchmarks/README.md

@@ -0,0 +1,62 @@
+# Benchmark
+
+Three arms (no skill, [caveman](https://github.com/JuliusBrussee/caveman), ponytail), three models, five everyday tasks, **10 runs per cell, median reported**. Code LOC is counted from fenced code blocks; tokens, cost, and latency come straight from the API.
+
+## Reproduce
+
+```bash
+cp ../.env.example ../.env      # add your ANTHROPIC_API_KEY
+npx promptfoo@latest eval -c promptfooconfig.yaml --repeat 10
+npx promptfoo@latest view
+```
+
+Tasks: email validator, JS debounce, CSV sum, React countdown, FastAPI rate-limit (see `promptfooconfig.yaml`). Single-shot completions, default temperature.
+
+## Median results (10 runs, 2026-06-13)
+
+**Code (lines)**
+
+| arm | Haiku | Sonnet | Opus |
+|---|--:|--:|--:|
+| baseline (no skill) | 518 | 693 | 256 |
+| caveman | 116 | 120 | 67 |
+| **ponytail** | **39** | **44** | **51** |
+
+**Cost (USD, 5 tasks)**
+
+| arm | Haiku | Sonnet | Opus |
+|---|--:|--:|--:|
+| baseline (no skill) | 0.032 | 0.141 | 0.135 |
+| caveman | 0.014 | 0.045 | 0.075 |
+| **ponytail** | **0.010** | **0.032** | **0.071** |
+
+**Latency (seconds, 5 tasks)**
+
+| arm | Haiku | Sonnet | Opus |
+|---|--:|--:|--:|
+| baseline (no skill) | 37.7 | 124.1 | 58.7 |
+| caveman | 14.9 | 34.7 | 23.1 |
+| **ponytail** | **9.9** | **20.1** | **18.0** |
+
+Versus baseline, ponytail writes **80-94% less code**, costs **47-77% less**, and runs **3-6x faster**, on every model.
+
+## Metrics
+
+| File | Metric | Behavior |
+|------|--------|----------|
+| `loc.js` | `loc` | Measurement - always passes, records line count |
+| `correctness.js` | `correct` | Gate - fails if generated code doesn't work |
+
+`correctness.js` extracts fenced code blocks and runs per-task checks (spawns Python/Node for email, debounce, CSV; structural regex for React and FastAPI). A broken one-liner that scores great on LOC will fail on correctness.
+
+> **Note:** The React countdown and FastAPI rate-limit checks are keyword/structural only (no runtime execution), so they verify plausible structure rather than full correctness. The email, debounce, and CSV checks execute the code.
+
+### Prerequisites
+
+Running the benchmark requires **Python 3**, **pandas**, and **Node.js** (18+).
+
+## Notes
+
+- Caveman is a prose-compression skill (it leaves code "normal"), so it lands between baseline and ponytail on code size and wins mainly on prose tokens.
+- Cost reflects single-shot calls that re-send the skill every time. In real sessions the skill is injected once and prompt-cached, so the cost gap widens further in ponytail's favor.
+- These are everyday tasks. For production-grade specs, where an unconstrained agent bloats much harder, see the writeups in `results/`.

benchmarks/arms/baseline.js

@@ -0,0 +1,2 @@
+// Baseline arm: no skill, just the task.
+module.exports = ({ vars }) => [{ role: 'user', content: vars.task }];

benchmarks/arms/caveman-SKILL.md

@@ -0,0 +1,67 @@
+---
+name: caveman
+description: >
+  Ultra-compressed communication mode. Cuts token usage ~75% by speaking like caveman
+  while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra,
+  wenyan-lite, wenyan-full, wenyan-ultra.
+  Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens",
+  "be brief", or invokes /caveman. Also auto-triggers when token efficiency is requested.
+---
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE. No revert after many turns. No filler drift. Still active if unsure. Off only: "stop caveman" / "normal mode".
+
+Default: **full**. Switch: `/caveman lite|full|ultra`.
+
+## Rules
+
+Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). Technical terms exact. Code blocks unchanged. Errors quoted exact.
+
+Pattern: `[thing] [action] [reason]. [next step].`
+
+Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
+
+## Intensity
+
+| Level | What change |
+|-------|------------|
+| **lite** | No filler/hedging. Keep articles + full sentences. Professional but tight |
+| **full** | Drop articles, fragments OK, short synonyms. Classic caveman |
+| **ultra** | Abbreviate (DB/auth/config/req/res/fn/impl), strip conjunctions, arrows for causality (X → Y), one word when one word enough |
+| **wenyan-lite** | Semi-classical. Drop filler/hedging but keep grammar structure, classical register |
+| **wenyan-full** | Maximum classical terseness. Fully 文言文. 80-90% character reduction. Classical sentence patterns, verbs precede objects, subjects often omitted, classical particles (之/乃/為/其) |
+| **wenyan-ultra** | Extreme abbreviation while keeping classical Chinese feel. Maximum compression, ultra terse |
+
+Example — "Why React component re-render?"
+- lite: "Your component re-renders because you create a new object reference each render. Wrap it in `useMemo`."
+- full: "New object ref each render. Inline object prop = new ref = re-render. Wrap in `useMemo`."
+- ultra: "Inline obj prop → new ref → re-render. `useMemo`."
+- wenyan-lite: "組件頻重繪，以每繪新生對象參照故。以 useMemo 包之。"
+- wenyan-full: "物出新參照，致重繪。useMemo .Wrap之。"
+- wenyan-ultra: "新參照→重繪。useMemo Wrap。"
+
+Example — "Explain database connection pooling."
+- lite: "Connection pooling reuses open connections instead of creating new ones per request. Avoids repeated handshake overhead."
+- full: "Pool reuse open DB connections. No new connection per request. Skip handshake overhead."
+- ultra: "Pool = reuse DB conn. Skip handshake → fast under load."
+- wenyan-full: "池reuse open connection。不每req新開。skip handshake overhead。"
+- wenyan-ultra: "池reuse conn。skip handshake → fast。"
+
+## Auto-Clarity
+
+Drop caveman for: security warnings, irreversible action confirmations, multi-step sequences where fragment order risks misread, user asks to clarify or repeats question. Resume caveman after clear part done.
+
+Example — destructive op:
+> **Warning:** This will permanently delete all rows in the `users` table and cannot be undone.
+> ```sql
+> DROP TABLE users;
+> ```
+> Caveman resume. Verify backup exist first.
+
+## Boundaries
+
+Code/commits/PRs: write normal. "stop caveman" or "normal mode": revert. Level persist until changed or session end.

benchmarks/arms/caveman.js

@@ -0,0 +1,8 @@
+// Caveman arm: caveman SKILL.md (full) as the system prompt.
+const fs = require('fs');
+const path = require('path');
+const system = fs.readFileSync(path.join(__dirname, 'caveman-SKILL.md'), 'utf8');
+module.exports = ({ vars }) => [
+  { role: 'system', content: system },
+  { role: 'user', content: vars.task },
+];

benchmarks/arms/ponytail.js

@@ -0,0 +1,8 @@
+// Ponytail arm: the repo's own SKILL.md (full) as the system prompt. Single source of truth.
+const fs = require('fs');
+const path = require('path');
+const system = fs.readFileSync(path.join(__dirname, '..', '..', 'skills', 'ponytail', 'SKILL.md'), 'utf8');
+module.exports = ({ vars }) => [
+  { role: 'system', content: system },
+  { role: 'user', content: vars.task },
+];

benchmarks/correctness.js

@@ -0,0 +1,263 @@
+// Functional correctness assertion: runs generated code against lightweight test
+// cases per task. Proves "less code" is not "broken code". Spawns python/node
+// with the extracted code + appended assertions; returns pass/fail + score.
+//
+// Metric: `correct` (1 = all checks pass, 0 = at least one fails).
+// Unlike loc.js (measurement-only), this one is a gate — a wrong answer is a
+// wrong answer regardless of how few lines produced it.
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Extract fenced code blocks, tagged by language.
+function extractBlocks(text) {
+  const matches = [...text.matchAll(/```(\w*)\n([\s\S]*?)```/g)];
+  return matches.map((m) => ({ lang: (m[1] || '').toLowerCase(), code: m[2] }));
+}
+
+// Identify which task we're evaluating from vars.task.
+function identifyTask(task) {
+  const t = task.toLowerCase();
+  if (t.includes('email') && t.includes('valid')) return 'email';
+  if (t.includes('debounce')) return 'debounce';
+  if (t.includes('csv') && t.includes('sum')) return 'csv';
+  if (t.includes('countdown') && t.includes('react')) return 'countdown';
+  if (t.includes('rate limit') || t.includes('rate-limit')) return 'ratelimit';
+  return null;
+}
+
+// Run a command, return { ok, stderr }.
+function exec(cmd, opts = {}) {
+  try {
+    execSync(cmd, { timeout: 10_000, encoding: 'utf8', stdio: 'pipe', ...opts });
+    return { ok: true, stderr: '' };
+  } catch (e) {
+    return { ok: false, stderr: (e.stderr || e.message || '').slice(0, 500) };
+  }
+}
+
+// Write content to a temp file, return the path.
+function tmpFile(ext, content) {
+  const p = path.join(os.tmpdir(), `ponytail-bench-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
+  fs.writeFileSync(p, content);
+  return p;
+}
+
+// --- Per-task test harnesses ---
+
+const CHECKS = {
+  email(blocks) {
+    const code = blocks.find((b) => b.lang === 'python' || b.lang === 'py' || (!b.lang && b.code.includes('def ')));
+    if (!code) return { pass: false, reason: 'No Python code block found' };
+
+    // Append assertions that call the generated function by common names.
+    const harness = `
+${code.code}
+
+# Find the validator function
+import sys
+fn = None
+for name in ['validate_email', 'is_valid_email', 'email_validator', 'is_valid', 'validate']:
+    if name in dir() and callable(eval(name)):
+        fn = eval(name)
+        break
+
+if fn is None:
+    # Try any function that takes one arg
+    import inspect
+    for name, obj in list(globals().items()):
+        if callable(obj) and not name.startswith('_'):
+            try:
+                sig = inspect.signature(obj)
+                if len(sig.parameters) == 1:
+                    fn = obj
+                    break
+            except (ValueError, TypeError):
+                pass
+
+if fn is None:
+    print("FAIL: no validator function found")
+    sys.exit(1)
+
+# Test cases
+failures = []
+if not fn("user@example.com"):
+    failures.append("rejected valid: user@example.com")
+if not fn("a@b.co"):
+    failures.append("rejected valid: a@b.co")
+if fn("no-at-sign"):
+    failures.append("accepted invalid: no-at-sign")
+if fn(""):
+    failures.append("accepted invalid: empty string")
+if fn("@missing-local.com"):
+    failures.append("accepted invalid: @missing-local.com")
+
+if failures:
+    print("FAIL: " + "; ".join(failures))
+    sys.exit(1)
+print("PASS")
+`;
+    const f = tmpFile('.py', harness);
+    const result = exec(`python "${f}"`);
+    fs.unlinkSync(f);
+    if (result.ok) return { pass: true, reason: 'Email validator passes all checks' };
+    return { pass: false, reason: result.stderr || 'Email validator failed' };
+  },
+
+  debounce(blocks) {
+    const code = blocks.find((b) => b.lang === 'javascript' || b.lang === 'js' || (!b.lang && b.code.includes('function')));
+    if (!code) return { pass: false, reason: 'No JavaScript code block found' };
+
+    const harness = `
+${code.code}
+
+// Find the debounce function
+const fn = typeof debounce === 'function' ? debounce
+  : typeof module !== 'undefined' && typeof module.exports === 'function' ? module.exports
+  : null;
+
+if (!fn) {
+  console.error("FAIL: no debounce function found");
+  process.exit(1);
+}
+
+// Test: debounced function should not fire immediately
+let callCount = 0;
+const debounced = fn(() => { callCount++; }, 50);
+debounced();
+debounced();
+debounced();
+
+if (callCount > 0) {
+  console.error("FAIL: debounce fired immediately (should wait)");
+  process.exit(1);
+}
+
+// Test: should fire after the delay
+setTimeout(() => {
+  if (callCount !== 1) {
+    console.error("FAIL: expected 1 call after delay, got " + callCount);
+    process.exit(1);
+  }
+  console.log("PASS");
+}, 120);
+`;
+    const f = tmpFile('.mjs', harness);
+    const result = exec(`node "${f}"`);
+    fs.unlinkSync(f);
+    if (result.ok) return { pass: true, reason: 'Debounce passes all checks' };
+    return { pass: false, reason: result.stderr || 'Debounce failed' };
+  },
+
+  csv(blocks) {
+    const code = blocks.find((b) => b.lang === 'python' || b.lang === 'py' || (!b.lang && b.code.includes('csv') && b.code.includes('sum')));
+    if (!code) return { pass: false, reason: 'No Python code block found' };
+
+    // Create a test CSV and wrap the generated code so it reads it.
+    const csvContent = 'name,amount\nAlice,100.5\nBob,200.0\nCharlie,50.5\n';
+    const csvPath = tmpFile('.csv', csvContent).replace(/\\/g, '/');
+
+    // The generated code likely reads 'sales.csv'; patch the filename.
+    let patched = code.code.replace(/['"]sales\.csv['"]/g, `'${csvPath}'`);
+    // Also try open() calls
+    patched = patched.replace(/open\(\s*['"]sales\.csv['"]/g, `open('${csvPath}'`);
+
+    const harness = `
+import sys, os
+os.chdir(r"${path.dirname(csvPath)}")
+
+# Capture print output
+import io
+_stdout = sys.stdout
+sys.stdout = io.StringIO()
+
+try:
+${patched.split('\n').map((l) => '    ' + l).join('\n')}
+except Exception as e:
+    sys.stdout = _stdout
+    # If it needs sales.csv in cwd, write it there and retry
+    pass
+
+output = sys.stdout.getvalue()
+sys.stdout = _stdout
+
+# Check output contains the number 351 (100.5 + 200.0 + 50.5)
+# Match as a standalone number (not as substring of e.g. 13510)
+import re
+if re.search(r'(?<![\\d])351(?:\\.0)?(?![\\d])', output):
+    print("PASS")
+else:
+    # Try running it differently: maybe it defines a function
+    print("FAIL: output was: " + repr(output[:200]))
+    sys.exit(1)
+`;
+    const f = tmpFile('.py', harness);
+    const result = exec(`python "${f}"`);
+    try { fs.unlinkSync(f); } catch (e) {}
+    try { fs.unlinkSync(csvPath); } catch (e) {}
+    if (result.ok) return { pass: true, reason: 'CSV sum produces correct result (351)' };
+    return { pass: false, reason: result.stderr || 'CSV sum failed' };
+  },
+
+  countdown(blocks) {
+    // React components can't run in bare Node without a bundler. Structural check:
+    // the code must contain timer/countdown logic (useState/useEffect/setInterval/setTimeout).
+    const code = blocks.find((b) => b.code.includes('ount') || b.code.includes('timer') || b.code.includes('Timer'));
+    if (!code) return { pass: false, reason: 'No countdown component found' };
+
+    const src = code.code;
+    const hasState = /useState|useReducer|this\.state/.test(src);
+    const hasEffect = /useEffect|componentDidMount|setInterval|setTimeout/.test(src);
+    const hasDecrement = /- 1|-= 1|prev - 1|count - 1|seconds - 1|time - 1/.test(src);
+
+    const failures = [];
+    if (!hasState) failures.push('no state management (useState/useReducer)');
+    if (!hasEffect) failures.push('no timer setup (useEffect/setInterval/setTimeout)');
+    if (!hasDecrement) failures.push('no countdown decrement logic');
+
+    if (failures.length === 0) return { pass: true, reason: 'Countdown has required structure' };
+    return { pass: false, reason: 'Missing: ' + failures.join(', ') };
+  },
+
+  ratelimit(blocks) {
+    const code = blocks.find((b) => b.lang === 'python' || b.lang === 'py' || (!b.lang && (b.code.includes('rate') || b.code.includes('limit'))));
+    if (!code) return { pass: false, reason: 'No Python code block found' };
+
+    // Structural check for rate limiting: must have some form of counter/time tracking.
+    const src = code.code;
+    const hasTimeTracking = /time\.|datetime|asyncio/.test(src);
+    const hasLimitLogic = /limit|max_requests|rate|429|Too Many|HTTPException|RateLimiter/.test(src);
+    const hasFastAPI = /fastapi|FastAPI|app\s*=|@app\./.test(src);
+
+    const failures = [];
+    if (!hasLimitLogic) failures.push('no rate limit logic');
+    if (!hasFastAPI) failures.push('no FastAPI usage');
+
+    if (failures.length === 0) return { pass: true, reason: 'Rate limiter has required structure' };
+    return { pass: false, reason: 'Missing: ' + failures.join(', ') };
+  },
+};
+
+// --- Main assertion entry point ---
+
+module.exports = (output, context) => {
+  const task = identifyTask(context.vars.task || '');
+  if (!task) {
+    return { pass: true, score: 1, reason: 'Unknown task, skipped correctness check' };
+  }
+
+  const blocks = extractBlocks(String(output || ''));
+  if (blocks.length === 0) {
+    return { pass: false, score: 0, reason: 'No code blocks in output' };
+  }
+
+  const check = CHECKS[task];
+  const result = check(blocks);
+  return {
+    pass: result.pass,
+    score: result.pass ? 1 : 0,
+    reason: result.reason,
+  };
+};

benchmarks/loc.js

@@ -0,0 +1,12 @@
+// Deterministic code-size metric: non-blank, non-comment lines inside fenced code blocks.
+// Recorded as the `code_loc` metric per arm (always passes; it is a measurement, not a gate).
+module.exports = (output) => {
+  const text = String(output || '');
+  const blocks = [...text.matchAll(/```[a-zA-Z0-9_+-]*\n([\s\S]*?)```/g)].map((m) => m[1]);
+  const code = blocks.join('\n');
+  const loc = code
+    .split('\n')
+    .map((l) => l.trim())
+    .filter((l) => l && !l.startsWith('//') && !l.startsWith('#') && l !== '*/' && !l.startsWith('/*') && !l.startsWith('*')).length;
+  return { pass: true, score: loc, reason: loc + ' code LOC' };
+};

benchmarks/promptfooconfig.yaml

@@ -0,0 +1,41 @@
+# Ponytail benchmark: code size + cost across three arms, same model, same tasks.
+#
+#   Run:   npx promptfoo@latest eval -c benchmarks/promptfooconfig.yaml
+#   View:  npx promptfoo@latest view
+#   Share: npx promptfoo@latest share   (publishes a hosted report URL)
+#
+# Needs ANTHROPIC_API_KEY in the environment or a .env file (see benchmarks/README.md).
+# Caveman arm uses JuliusBrussee/caveman SKILL.md (MIT), vendored at arms/caveman-SKILL.md.
+description: "Ponytail vs caveman vs no-skill: same model, same tasks. Measures code LOC (deterministic) and tokens/cost (API telemetry)."
+
+providers:
+  - id: anthropic:messages:claude-haiku-4-5-20251001
+    config: { max_tokens: 8192, temperature: 1 }
+  - id: anthropic:messages:claude-sonnet-4-6
+    config: { max_tokens: 8192, temperature: 1 }
+  - id: anthropic:messages:claude-opus-4-8
+    config: { max_tokens: 8192, temperature: 1 }
+
+prompts:
+  - id: file://arms/baseline.js
+    label: baseline (no skill)
+  - id: file://arms/caveman.js
+    label: caveman
+  - id: file://arms/ponytail.js
+    label: ponytail
+
+defaultTest:
+  assert:
+    - type: javascript
+      value: file://loc.js
+      metric: code_loc
+    - type: javascript
+      value: file://correctness.js
+      metric: correct
+
+tests:
+  - vars: { task: "Write me a Python function that validates email addresses." }
+  - vars: { task: "Add debounce to a search input in vanilla JavaScript. It currently fires an API call on every keystroke." }
+  - vars: { task: "Write Python code that reads sales.csv and sums the 'amount' column." }
+  - vars: { task: "Build me a countdown timer component in React that counts down from a given number of seconds." }
+  - vars: { task: "Add rate limiting to my FastAPI endpoint so users can't spam it." }

commands/ponytail-audit.toml

@@ -0,0 +1,2 @@
+description = "Audit the whole repo for over-engineering, what can be deleted"
+prompt = "Audit the entire repository for over-engineering only, not correctness. Scan the whole tree, not a diff. One line per finding, ranked biggest cut first: <tag> <what to cut>. <replacement>. [path]. Tags: delete (dead code/speculative feature), stdlib (reinvented standard library), native (dependency doing what the platform does), yagni (abstraction with one implementation), shrink (same logic, fewer lines). End with the net lines and dependencies removable. If nothing to cut: 'Lean already. Ship.'"

commands/ponytail-review.toml

@@ -1,2 +1,2 @@
-description = "Review changes for over-engineering — what can be deleted"
-prompt = "Review the current code changes for over-engineering only — not correctness. One line per finding: L<line>: <tag> <what to cut>. <replacement>. Tags: delete (dead code/speculative feature), stdlib (reinvented standard library), native (dependency doing what the platform does), yagni (abstraction with one implementation), shrink (same logic, fewer lines). End with the net lines removable. If nothing to cut: 'Lean already. Ship.'"
+description = "Review changes for over-engineering, what can be deleted"
+prompt = "Review the current code changes for over-engineering only, not correctness. One line per finding: L<line>: <tag> <what to cut>. <replacement>. Tags: delete (dead code/speculative feature), stdlib (reinvented standard library), native (dependency doing what the platform does), yagni (abstraction with one implementation), shrink (same logic, fewer lines). End with the net lines removable. If nothing to cut: 'Lean already. Ship.'"

commands/ponytail.toml

@@ -1,2 +1,2 @@
 description = "Switch ponytail intensity level (lite/full/ultra/off)"
-prompt = "Switch to ponytail {{args}} mode. If no level specified, use full. Lazy senior dev mode — before any code: does it need to exist at all (YAGNI)? Does the standard library do it? A native platform feature? Can it be one line? Build the minimum that works. No unrequested abstractions, no avoidable dependencies, no boilerplate. Mark intentional simplifications with a ponytail: comment."
+prompt = "Switch to ponytail {{args}} mode. If no level specified, use full. Lazy senior dev mode, before any code: does it need to exist at all (YAGNI)? Does the standard library do it? A native platform feature? Can it be one line? Build the minimum that works. No unrequested abstractions, no avoidable dependencies, no boilerplate. Mark intentional simplifications with a ponytail: comment."

docs/agent-portability.md

@@ -11,10 +11,14 @@ to load in a given agent.
 | Claude Code | `.claude-plugin/`, `commands/`, `hooks/` | Full plugin install with session activation, mode tracking, commands, and statusline support. |
 | Codex | `.codex-plugin/plugin.json`, `hooks/hooks.json`, `hooks/`, `skills/` | Plugin install with the same skills plus lifecycle hooks for activation and mode tracking. |
 | OpenCode | `.opencode/plugins/ponytail.mjs`, `.opencode/command/`, `hooks/`, `skills/` | Server plugin injects the ruleset each turn via `experimental.chat.system.transform` and persists `/ponytail` switches; reuses the shared instruction builder. |
+| Gemini CLI | `gemini-extension.json`, `AGENTS.md`, `commands/`, `skills/` | Extension manifest points `contextFileName` at `AGENTS.md` for always-on rules, and reuses the existing `commands/*.toml` (`/ponytail`, `/ponytail-review`) and `skills/`, which Gemini CLI auto-discovers. |
 | Cursor | `.cursor/rules/ponytail.mdc` | Always-on project rule. |
 | Windsurf | `.windsurf/rules/ponytail.md` | Project rule. |
 | Cline | `.clinerules/ponytail.md` | Project rule. |
 | GitHub Copilot | `.github/copilot-instructions.md` | Repository instruction file. |
+| GitHub Copilot CLI | `AGENTS.md`, `.github/copilot-instructions.md`, `~/.copilot/copilot-instructions.md` | Reads custom instructions: per-project from `AGENTS.md` or `.github/copilot-instructions.md`, or globally from `~/.copilot/copilot-instructions.md`. Instruction-tier (no `/ponytail` levels or hooks). |
+| Antigravity | `AGENTS.md` | Reads `AGENTS.md` at the repo root as always-on rules (like `.cursorrules`/`CLAUDE.md`); `.agents/rules/` also works for workspace rules. Instruction-tier. |
+| VS Code + Codex extension | `AGENTS.md` | The Codex extension reads `AGENTS.md` (repo root, or `~/.codex/AGENTS.md` globally). Instruction-tier; the full Codex plugin row above adds `/ponytail` levels and hooks. |
 | Kiro | `.kiro/steering/ponytail.md` | Steering rule; copy globally or into a project. |
 | Generic agents | `AGENTS.md` or `skills/*/SKILL.md` | Copy the compact rule file or load the skill files directly. |
 
@@ -28,5 +32,6 @@ instructions, keep its copied rule text aligned with `AGENTS.md`.
 
 - `skills/ponytail/SKILL.md`: lazy senior dev mode
 - `skills/ponytail-review/SKILL.md`: over-engineering review
+- `skills/ponytail-audit/SKILL.md`: whole-repo over-engineering audit
 - `skills/ponytail-help/SKILL.md`: quick reference
 - `AGENTS.md`: compact always-on instruction set for agents without skill support

examples/api-endpoint.md

@@ -46,13 +46,18 @@ def get_user(user_id: int, service: UserService = Depends(get_user_service)):
         raise HTTPException(status_code=404, detail="User not found")
 ```
 
-Five files, three classes, a custom exception, and a dependency-injection chain — wrapping one database call.
+Five files, three classes, a custom exception, and a dependency-injection chain, wrapping one database call.
 
 ## With Ponytail
 
 ```python
-# ponytail: it's one query
-@app.get("/users/{user_id}")
+# ponytail: drop the layers; keep the response schema, it whitelists what leaves the API
+class UserOut(BaseModel):
+    id: int
+    name: str
+    email: str
+
+@app.get("/users/{user_id}", response_model=UserOut)
 def get_user(user_id: int, db: Session = Depends(get_db)):
     user = db.get(User, user_id)
     if not user:
@@ -60,4 +65,4 @@ def get_user(user_id: int, db: Session = Depends(get_db)):
     return user
 ```
 
-**5 files → 5 lines.** Layers earn their place when there are two implementations, not before. Add the service layer when a second caller shows up — if it ever does.
+**5 files → 9 lines.** The repository, service, and custom exception were ceremony. The response schema was not: it whitelists which fields leave the API, so it stays. Returning the raw ORM model (`return user`) would leak every column, including the ones you never meant to expose. That is the line ponytail draws, and it is the same one the skill draws in "when NOT to be lazy": cut the layers, keep the trust boundary. Add a service layer when a second caller shows up, if it ever does.

examples/date-picker.md

@@ -36,7 +36,7 @@ export default function DatePicker({ value, onChange, minDate, maxDate }) {
 }
 ```
 
-One dependency, one wrapper component, two `useEffect` hooks, a cleanup function, and a CSS import — to pick a date.
+One dependency, one wrapper component, two `useEffect` hooks, a cleanup function, and a CSS import, to pick a date.
 
 ## With Ponytail
 

examples/email-validation.md

@@ -36,7 +36,7 @@ A class, a wrapper, a regex that still rejects valid addresses and accepts inval
 ## With Ponytail
 
 ```python
-# ponytail: good enough — real validation is sending the mail
+# ponytail: good enough, real validation is sending the mail
 "@" in email and "." in email.split("@")[-1]
 ```
 

gemini-extension.json

@@ -0,0 +1,6 @@
+{
+  "name": "ponytail",
+  "version": "4.3.0",
+  "description": "Lazy senior dev mode. Forces the simplest, shortest solution that actually works: YAGNI, stdlib first, no unrequested abstractions.",
+  "contextFileName": "AGENTS.md"
+}

hooks/hooks.json

@@ -7,7 +7,7 @@
           {
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/ponytail-activate.js\"",
-            "commandWindows": "node \"%CLAUDE_PLUGIN_ROOT%\\hooks\\ponytail-activate.js\"",
+            "commandWindows": "node \"$env:CLAUDE_PLUGIN_ROOT\\hooks\\ponytail-activate.js\"",
             "timeout": 5,
             "statusMessage": "Loading ponytail mode..."
           }
@@ -20,7 +20,7 @@
           {
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/ponytail-mode-tracker.js\"",
-            "commandWindows": "node \"%CLAUDE_PLUGIN_ROOT%\\hooks\\ponytail-mode-tracker.js\"",
+            "commandWindows": "node \"$env:CLAUDE_PLUGIN_ROOT\\hooks\\ponytail-mode-tracker.js\"",
             "timeout": 5,
             "statusMessage": "Tracking ponytail mode..."
           }

hooks/ponytail-activate.js

@@ -8,8 +8,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
-const { getDefaultMode } = require('./ponytail-config');
+const { getDefaultMode, getClaudeDir } = require('./ponytail-config');
 const { getPonytailInstructions } = require('./ponytail-instructions');
 const {
   clearMode,
@@ -18,7 +17,7 @@ const {
   writeHookOutput,
 } = require('./ponytail-runtime');
 
-const claudeDir = path.join(os.homedir(), '.claude');
+const claudeDir = getClaudeDir();
 const settingsPath = path.join(claudeDir, 'settings.json');
 
 const mode = getDefaultMode();

hooks/ponytail-config.js

@@ -50,6 +50,11 @@ function getConfigPath() {
   return path.join(getConfigDir(), 'config.json');
 }
 
+function getClaudeDir() {
+  // ponytail: CLAUDE_CONFIG_DIR overrides ~/.claude, matching Claude Code.
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+}
+
 function getDefaultMode() {
   // 1. Environment variable (highest priority)
   const envMode = process.env.PONYTAIL_DEFAULT_MODE;
@@ -89,6 +94,7 @@ module.exports = {
   getDefaultMode,
   getConfigDir,
   getConfigPath,
+  getClaudeDir,
   normalizeMode,
   normalizeConfigMode,
   normalizePersistedMode,

hooks/ponytail-runtime.js

@@ -1,11 +1,11 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { getClaudeDir } = require('./ponytail-config');
 
 const isCodex = Boolean(process.env.PLUGIN_DATA);
 const statePath = isCodex
   ? path.join(process.env.PLUGIN_DATA, '.ponytail-active')
-  : path.join(os.homedir(), '.claude', '.ponytail-active');
+  : path.join(getClaudeDir(), '.ponytail-active');
 
 function setMode(mode) {
   fs.mkdirSync(path.dirname(statePath), { recursive: true });

pi-extension/index.js

@@ -114,6 +114,11 @@ export default function ponytailExtension(pi) {
     handler: (_args, ctx) => sendAlias("/skill:ponytail-review", "", ctx),
   });
 
+  pi.registerCommand("ponytail-audit", {
+    description: "Run /skill:ponytail-audit",
+    handler: (_args, ctx) => sendAlias("/skill:ponytail-audit", "", ctx),
+  });
+
   pi.registerCommand("ponytail-help", {
     description: "Run /skill:ponytail-help",
     handler: (_args, ctx) => sendAlias("/skill:ponytail-help", "", ctx),

pi-extension/test/extension.test.js

@@ -57,7 +57,7 @@ function withTempConfig(fn) {
 test("extension registers Ponytail commands", () => {
   const { commands } = createPiHarness();
 
-  assert.deepEqual([...commands.keys()].sort(), ["ponytail", "ponytail-help", "ponytail-review"]);
+  assert.deepEqual([...commands.keys()].sort(), ["ponytail", "ponytail-audit", "ponytail-help", "ponytail-review"]);
 });
 
 test("/ponytail updates session mode and injects instructions", async () => withTempConfig(async () => {
@@ -98,10 +98,12 @@ test("skill alias commands delegate to Pi skill commands", async () => {
   const ctx = createCommandContext();
 
   await commands.get("ponytail-review").handler("", ctx);
+  await commands.get("ponytail-audit").handler("", ctx);
   await commands.get("ponytail-help").handler("", ctx);
 
   assert.deepEqual(sentUserMessages.map((entry) => entry.text), [
     "/skill:ponytail-review",
+    "/skill:ponytail-audit",
     "/skill:ponytail-help",
   ]);
 });

skills/ponytail-audit/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: ponytail-audit
+description: >
+  Whole-repo audit for over-engineering. Like ponytail-review, but scans the
+  entire codebase instead of a diff: a ranked list of what to delete, simplify,
+  or replace with stdlib/native equivalents. Use when the user says "audit this
+  codebase", "audit for over-engineering", "what can I delete from this repo",
+  "find bloat", "ponytail-audit", or "/ponytail-audit". One-shot report, does
+  not apply fixes.
+---
+
+ponytail-review, repo-wide. Scan the whole tree instead of a diff. Rank
+findings biggest cut first.
+
+## Tags
+
+Same as ponytail-review:
+
+- `delete:` dead code, unused flexibility, speculative feature. Replacement: nothing.
+- `stdlib:` hand-rolled thing the standard library ships. Name the function.
+- `native:` dependency or code doing what the platform already does. Name the feature.
+- `yagni:` abstraction with one implementation, config nobody sets, layer with one caller.
+- `shrink:` same logic, fewer lines. Show the shorter form.
+
+## Hunt
+
+Deps the stdlib or platform already ships, single-implementation interfaces,
+factories with one product, wrappers that only delegate, files exporting one
+thing, dead flags and config, hand-rolled stdlib.
+
+## Output
+
+One line per finding, ranked: `<tag> <what to cut>. <replacement>. [path]`.
+End with `net: -<N> lines, -<M> deps possible.` Nothing to cut: `Lean already. Ship.`
+
+## Boundaries
+
+Complexity only, correctness bugs, security holes, and performance go to a
+normal review pass. Lists findings, applies nothing. One-shot.
+"stop ponytail-audit" or "normal mode" to revert.

skills/ponytail-help/SKILL.md

@@ -8,7 +8,7 @@ description: >
 
 # Ponytail Help
 
-Display this reference card when invoked. One-shot — do NOT change mode,
+Display this reference card when invoked. One-shot, do NOT change mode,
 write flag files, or persist anything.
 
 ## Levels
@@ -52,11 +52,17 @@ export PONYTAIL_DEFAULT_MODE=ultra
 { "defaultMode": "lite" }
 ```
 
-Set `"off"` to disable auto-activation on session start — activate manually
+Set `"off"` to disable auto-activation on session start, activate manually
 with `/ponytail` when wanted.
 
 Resolution: env var > config file > `full`.
 
+## Update
+
+Enable auto-update once: open `/plugin`, go to Marketplaces, pick ponytail, Enable auto-update. Claude Code then pulls new versions at startup (run `/reload-plugins` when it prompts). Manual refresh: `/plugin marketplace update ponytail` then `/reload-plugins`.
+
+If `/plugin` is not recognized, your Claude Code is out of date. Update it (`npm install -g @anthropic-ai/claude-code@latest`, or `brew upgrade claude-code`) and restart. Other hosts use their own update flow.
+
 ## More
 
 Full docs + examples: https://github.com/DietrichGebert/ponytail

skills/ponytail-review/SKILL.md

@@ -6,7 +6,7 @@ description: >
   dead flexibility. One line per finding: location, what to cut, what replaces
   it. Use when the user says "review for over-engineering", "what can we
   delete", "is this over-engineered", "simplify review", or invokes
-  /ponytail-review. Complements correctness-focused review — this one only
+  /ponytail-review. Complements correctness-focused review, this one only
   hunts complexity.
 ---
 
@@ -15,23 +15,23 @@ to cut, what replaces it. The diff's best outcome is getting shorter.
 
 ## Format
 
-`L<line>: <tag> <what>. <replacement>.` — or `<file>:L<line>: ...` for
+`L<line>: <tag> <what>. <replacement>.`, or `<file>:L<line>: ...` for
 multi-file diffs.
 
 Tags:
 
-- `delete:` — dead code, unused flexibility, speculative feature. Replacement: nothing.
-- `stdlib:` — hand-rolled thing the standard library ships. Name the function.
-- `native:` — dependency or code doing what the platform already does. Name the feature.
-- `yagni:` — abstraction with one implementation, config nobody sets, layer with one caller.
-- `shrink:` — same logic, fewer lines. Show the shorter form.
+- `delete:` dead code, unused flexibility, speculative feature. Replacement: nothing.
+- `stdlib:` hand-rolled thing the standard library ships. Name the function.
+- `native:` dependency or code doing what the platform already does. Name the feature.
+- `yagni:` abstraction with one implementation, config nobody sets, layer with one caller.
+- `shrink:` same logic, fewer lines. Show the shorter form.
 
 ## Examples
 
 ❌ "This EmailValidator class might be more complex than necessary, have you
 considered whether all these validation rules are needed at this stage?"
 
-✅ `L12-38: stdlib: 27-line validator class. "@" in email, 1 line — real validation is the confirmation mail.`
+✅ `L12-38: stdlib: 27-line validator class. "@" in email, 1 line, real validation is the confirmation mail.`
 
 ✅ `L4: native: moment.js imported for one format call. Intl.DateTimeFormat, 0 deps.`
 
@@ -49,8 +49,8 @@ If there is nothing to cut, say `Lean already. Ship.` and stop.
 
 ## Boundaries
 
-Complexity only — correctness bugs, security holes, and performance go to a
+Complexity only, correctness bugs, security holes, and performance go to a
 normal review pass, not this one. A single smoke test or `assert`-based
-self-check is the ponytail minimum, not bloat — never flag it for deletion.
+self-check is the ponytail minimum, not bloat, never flag it for deletion.
 Does not apply the fixes, only lists them.
 "stop ponytail-review" or "normal mode": revert to verbose review style.

skills/ponytail/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: ponytail
 description: >
-  Forces the laziest solution that actually works — simplest, shortest, most
+  Forces the laziest solution that actually works, simplest, shortest, most
   minimal. Channels a senior dev who has seen everything: question whether the
   task needs to exist at all (YAGNI), reach for the standard library before
   custom code, native platform features before dependencies, one line before
   fifty. Supports intensity levels: lite, full (default), ultra. Use whenever
   the user says "ponytail", "be lazy", "lazy mode", "simplest solution",
-  "minimal solution", "yagni", "do less", or "shortest path" — and whenever
+  "minimal solution", "yagni", "do less", or "shortest path", and whenever
   they complain about over-engineering, bloat, boilerplate, or unnecessary
   dependencies.
 license: MIT
@@ -42,21 +42,21 @@ higher one and move on. The first lazy solution that works is the right one.
 ## Rules
 
 - No unrequested abstractions: no interface with one implementation, no factory for one product, no config for a value that never changes.
-- No boilerplate, no scaffolding "for later" — later can scaffold for itself.
-- Deletion over addition. Boring over clever — clever is what someone decodes at 3am.
+- No boilerplate, no scaffolding "for later", later can scaffold for itself.
+- Deletion over addition. Boring over clever, clever is what someone decodes at 3am.
 - Fewest files possible. Shortest working diff wins.
-- Complex request? Ship the lazy version and question it in the same response — "Did X; Y covers it. Need full X? Say so." Never stall on an answer you can default.
+- Complex request? Ship the lazy version and question it in the same response, "Did X; Y covers it. Need full X? Say so." Never stall on an answer you can default.
 - Two stdlib options, same size? Take the one that's correct on edge cases. Lazy means writing less code, not picking the flimsier algorithm.
-- Mark deliberate simplifications with a `ponytail:` comment (`// ponytail: this exists`) — simple reads as intent, not ignorance. Shortcut with a known ceiling (global lock, O(n²) scan, naive heuristic)? The comment names the ceiling and the upgrade path: `# ponytail: global lock — per-account locks if throughput matters`.
+- Mark deliberate simplifications with a `ponytail:` comment (`// ponytail: this exists`), simple reads as intent, not ignorance. Shortcut with a known ceiling (global lock, O(n²) scan, naive heuristic)? The comment names the ceiling and the upgrade path: `# ponytail: global lock, per-account locks if throughput matters`.
 
 ## Output
 
 Code first. Then at most three short lines: what was skipped, when to add it.
 No essays, no feature tours, no design notes. If the explanation is longer
-than the code, delete the explanation — every paragraph defending a
+than the code, delete the explanation, every paragraph defending a
 simplification is complexity smuggled back in as prose.
 
-Pattern: `[code] → skipped: [X] — add when [Y].`
+Pattern: `[code] → skipped: [X], add when [Y].`
 
 ## Intensity
 
@@ -66,9 +66,9 @@ Pattern: `[code] → skipped: [X] — add when [Y].`
 | **full** | The ladder enforced. Stdlib and native first. Shortest diff, shortest explanation. Default. |
 | **ultra** | YAGNI extremist. Deletion before addition. Ship the one-liner and challenge the rest of the requirement in the same breath. |
 
-Example — "Add a cache for these API responses."
-- lite: "Done — cache added. FYI: `functools.lru_cache` covers this in one line if you'd rather not own a cache class."
-- full: "`@lru_cache(maxsize=1000)` on the fetch function. Skipped custom cache class — add when lru_cache measurably falls short."
+Example: "Add a cache for these API responses."
+- lite: "Done, cache added. FYI: `functools.lru_cache` covers this in one line if you'd rather not own a cache class."
+- full: "`@lru_cache(maxsize=1000)` on the fetch function. Skipped custom cache class, add when lru_cache measurably falls short."
 - ultra: "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."
 
 ## When NOT to be lazy
@@ -79,10 +79,10 @@ explicitly requested. User insists on the full version → build it, no
 re-arguing.
 
 Non-trivial logic (a branch, a loop, a parser, a money/security path) leaves
-ONE runnable check behind — the smallest thing that fails if the logic
+ONE runnable check behind, the smallest thing that fails if the logic
 breaks: an `assert`-based `demo()`/`__main__` self-check or one small
 `test_*.py`. No frameworks, no fixtures, no per-function suites unless
-asked. Trivial one-liners need no test — YAGNI applies to tests too.
+asked. Trivial one-liners need no test, YAGNI applies to tests too.
 
 ## Boundaries
 

tests/correctness.test.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+// Unit test for the correctness benchmark assertion. Feeds known-good and
+// known-bad LLM outputs through each task checker and asserts the expected
+// pass/fail verdict. Runs without promptfoo — just node:test + the module.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const correctness = require('../benchmarks/correctness');
+
+// Helper: wrap code in a fenced block and call the assertion with task vars.
+function check(task, lang, code) {
+  const output = '```' + lang + '\n' + code + '\n```';
+  return correctness(output, { vars: { task } });
+}
+
+// --- Email validator ---
+
+test('email: correct one-liner passes', () => {
+  const result = check(
+    'Write me a Python function that validates email addresses.',
+    'python',
+    'def validate_email(email):\n    return "@" in email and "." in email.split("@")[-1] and email.split("@")[0] != ""',
+  );
+  assert.equal(result.pass, true);
+  assert.equal(result.score, 1);
+});
+
+test('email: always-true validator fails', () => {
+  const result = check(
+    'Write me a Python function that validates email addresses.',
+    'python',
+    'def validate_email(email):\n    return True',
+  );
+  assert.equal(result.pass, false);
+  assert.equal(result.score, 0);
+});
+
+test('email: no code block fails', () => {
+  const result = correctness('Here is my answer: just use regex.', {
+    vars: { task: 'Write me a Python function that validates email addresses.' },
+  });
+  assert.equal(result.pass, false);
+});
+
+// --- Debounce ---
+
+test('debounce: correct implementation passes', () => {
+  const result = check(
+    'Add debounce to a search input in vanilla JavaScript.',
+    'javascript',
+    `function debounce(fn, delay) {
+  let timer;
+  return function(...args) {
+    clearTimeout(timer);
+    timer = setTimeout(() => fn.apply(this, args), delay);
+  };
+}`,
+  );
+  assert.equal(result.pass, true);
+  assert.equal(result.score, 1);
+});
+
+test('debounce: immediate-call implementation fails', () => {
+  const result = check(
+    'Add debounce to a search input in vanilla JavaScript.',
+    'javascript',
+    `function debounce(fn, delay) {
+  return function(...args) { fn.apply(this, args); };
+}`,
+  );
+  assert.equal(result.pass, false);
+  assert.equal(result.score, 0);
+});
+
+// --- CSV sum ---
+
+test('csv: correct pandas one-liner passes', () => {
+  const result = check(
+    "Write Python code that reads sales.csv and sums the 'amount' column.",
+    'python',
+    `import pandas as pd
+df = pd.read_csv('sales.csv')
+print(df['amount'].sum())`,
+  );
+  assert.equal(result.pass, true);
+  assert.equal(result.score, 1);
+});
+
+test('csv: code that prints wrong value fails', () => {
+  const result = check(
+    "Write Python code that reads sales.csv and sums the 'amount' column.",
+    'python',
+    `print(999)`,
+  );
+  assert.equal(result.pass, false);
+  assert.equal(result.score, 0);
+});
+
+test('csv: value containing 351 as substring fails (e.g. 13510)', () => {
+  const result = check(
+    "Write Python code that reads sales.csv and sums the 'amount' column.",
+    'python',
+    `print(13510)`,
+  );
+  assert.equal(result.pass, false);
+  assert.equal(result.score, 0);
+});
+
+// --- React countdown ---
+
+test('countdown: valid React component passes', () => {
+  const result = check(
+    'Build me a countdown timer component in React.',
+    'javascript',
+    `import { useState, useEffect } from 'react';
+export default function Countdown({ seconds }) {
+  const [count, setCount] = useState(seconds);
+  useEffect(() => {
+    if (count <= 0) return;
+    const id = setInterval(() => setCount(prev => prev - 1), 1000);
+    return () => clearInterval(id);
+  }, [count]);
+  return <div>{count}</div>;
+}`,
+  );
+  assert.equal(result.pass, true);
+  assert.equal(result.score, 1);
+});
+
+test('countdown: static div without state fails', () => {
+  const result = check(
+    'Build me a countdown timer component in React.',
+    'javascript',
+    `export default function Countdown() { return <div>10</div>; }`,
+  );
+  assert.equal(result.pass, false);
+  assert.equal(result.score, 0);
+});
+
+// --- Rate limiter ---
+
+test('ratelimit: FastAPI with limit logic passes', () => {
+  const result = check(
+    'Add rate limiting to my FastAPI endpoint so users can\'t spam it.',
+    'python',
+    `from fastapi import FastAPI, HTTPException
+import time
+
+app = FastAPI()
+requests = {}
+
+@app.get("/api")
+def endpoint(user: str = "anon"):
+    now = time.time()
+    window = requests.get(user, [])
+    window = [t for t in window if now - t < 60]
+    if len(window) >= 10:
+        raise HTTPException(429, "Too Many Requests")
+    window.append(now)
+    requests[user] = window
+    return {"ok": True}`,
+  );
+  assert.equal(result.pass, true);
+  assert.equal(result.score, 1);
+});
+
+test('ratelimit: plain endpoint without limiting fails', () => {
+  const result = check(
+    'Add rate limiting to my FastAPI endpoint.',
+    'python',
+    `from fastapi import FastAPI
+app = FastAPI()
+
+@app.get("/api")
+def endpoint():
+    return {"ok": True}`,
+  );
+  assert.equal(result.pass, false);
+  assert.equal(result.score, 0);
+});
+
+// --- Edge cases ---
+
+test('unknown task is gracefully skipped', () => {
+  const result = correctness('```python\nprint("hi")\n```', {
+    vars: { task: 'Explain quantum computing.' },
+  });
+  assert.equal(result.pass, true);
+  assert.equal(result.score, 1);
+  assert.match(result.reason, /unknown task/i);
+});

tests/gemini-extension.test.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// Smoke test for the Gemini CLI adapter. The adapter is a single thin manifest
+// (gemini-extension.json) that reuses the repo's existing files: AGENTS.md for
+// always-on context, commands/*.toml for /ponytail + /ponytail-review, and
+// skills/ for the agent skills. This test fails if the manifest is removed,
+// loses its pinned version, or points contextFileName at a file that no longer
+// carries the load-bearing rules — i.e. if the adapter stops wiring ponytail.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+
+const root = path.join(__dirname, '..');
+const MANIFEST = 'gemini-extension.json';
+const EXTENSION_NAME = 'ponytail';
+// Floating refs are a supply-chain footgun; the manifest version must be pinned.
+const PINNED_SEMVER = /^\d+\.\d+\.\d+$/;
+// Gemini auto-discovers these by directory; the manifest is only useful if they exist.
+const REUSED_COMMANDS = ['commands/ponytail.toml', 'commands/ponytail-review.toml'];
+const REUSED_SKILLS = ['skills/ponytail/SKILL.md'];
+// Same load-bearing phrases asserted by scripts/check-rule-copies.js: the file
+// contextFileName points at must actually carry the rules, not just exist.
+const RULE_INVARIANTS = [
+  'lazy senior',
+  'input validation at trust boundaries',
+  'naive heuristic',
+];
+
+function read(relPath) {
+  return fs.readFileSync(path.join(root, relPath), 'utf8');
+}
+
+// Read inside each test (not at module scope) so a missing or malformed manifest
+// surfaces as a clean per-test assertion failure, not a load-time crash that
+// collapses every case into one unreadable stack trace.
+function loadManifest() {
+  assert.ok(fs.existsSync(path.join(root, MANIFEST)), `${MANIFEST} must exist`);
+  return JSON.parse(read(MANIFEST));
+}
+
+test('manifest names the ponytail extension with a pinned version', () => {
+  const manifest = loadManifest();
+  assert.equal(manifest.name, EXTENSION_NAME);
+  assert.match(manifest.version, PINNED_SEMVER);
+});
+
+test('version stays aligned with the other plugin manifests', () => {
+  const manifest = loadManifest();
+  const claude = JSON.parse(read('.claude-plugin/plugin.json'));
+  assert.equal(manifest.version, claude.version);
+});
+
+test('contextFileName resolves to a file carrying the ponytail rules', () => {
+  const manifest = loadManifest();
+  assert.ok(manifest.contextFileName, 'contextFileName must be set so rules load every session');
+  const context = read(manifest.contextFileName);
+  for (const phrase of RULE_INVARIANTS) {
+    assert.ok(context.includes(phrase), `context file missing rule invariant: "${phrase}"`);
+  }
+});
+
+test('the commands and skills the adapter reuses are present', () => {
+  for (const rel of [...REUSED_COMMANDS, ...REUSED_SKILLS]) {
+    assert.ok(fs.existsSync(path.join(root, rel)), `reused file missing: ${rel}`);
+  }
+});

tests/hooks-windows.test.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// Regression test for issue #19: on Windows the lifecycle hooks run via
+// PowerShell, which does NOT expand cmd.exe-style %VAR% — it needs $env:VAR.
+// The hook also has to point at a script that actually ships in hooks/.
+// This guards both failure modes: the original %CLAUDE_PLUGIN_ROOT% bug, and
+// the "switch to a .ps1 that doesn't exist" mistake.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+
+const root = path.join(__dirname, '..');
+const HOOKS_JSON = 'hooks/hooks.json';
+// cmd.exe variable syntax (%FOO%); PowerShell leaves it literal, breaking the path.
+const CMD_VAR_SYNTAX = /%[A-Za-z_][A-Za-z0-9_]*%/;
+// Pull the hooks/<script> a command launches, so we can check it exists.
+const HOOK_SCRIPT = /hooks[\\/]([\w.-]+\.(?:js|mjs|cjs|ps1|sh))/;
+
+// Read inside each case so a missing/malformed file fails as a clean assertion,
+// not a load-time crash.
+function commandHooks() {
+  const config = JSON.parse(fs.readFileSync(path.join(root, HOOKS_JSON), 'utf8'));
+  return Object.values(config.hooks)
+    .flat()
+    .flatMap((entry) => entry.hooks);
+}
+
+test('every commandWindows uses PowerShell $env: syntax, not cmd.exe %VAR%', () => {
+  const windowsCommands = commandHooks()
+    .map((h) => h.commandWindows)
+    .filter(Boolean);
+  assert.ok(windowsCommands.length > 0, 'expected at least one commandWindows entry');
+  for (const cmd of windowsCommands) {
+    assert.doesNotMatch(cmd, CMD_VAR_SYNTAX, `commandWindows uses cmd.exe %VAR% (breaks under PowerShell): ${cmd}`);
+  }
+});
+
+test('every hook command points at a script that ships in hooks/', () => {
+  for (const hook of commandHooks()) {
+    for (const cmd of [hook.command, hook.commandWindows].filter(Boolean)) {
+      const match = cmd.match(HOOK_SCRIPT);
+      assert.ok(match, `cannot find a hooks/ script in command: ${cmd}`);
+      const script = path.join(root, 'hooks', match[1]);
+      assert.ok(fs.existsSync(script), `command references a missing hook script: ${match[1]}`);
+    }
+  }
+});

tests/hooks.test.js

@@ -16,6 +16,10 @@ function run(script, env, input = '') {
   });
 }
 
+// Keep the base env clean so the default-dir checks are deterministic; the
+// CLAUDE_CONFIG_DIR case sets it explicitly.
+delete process.env.CLAUDE_CONFIG_DIR;
+
 const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'ponytail-hooks-'));
 const home = path.join(temp, 'home');
 const pluginData = path.join(temp, 'plugin-data');
@@ -74,5 +78,26 @@ assert.equal(
   'full',
 );
 
+// CLAUDE_CONFIG_DIR overrides ~/.claude for the flag file (issue #34).
+const home2 = path.join(temp, 'home2');
+fs.mkdirSync(home2, { recursive: true });
+const customConfigDir = path.join(temp, 'custom-claude');
+result = run('ponytail-activate.js', {
+  HOME: home2,
+  USERPROFILE: home2,
+  CLAUDE_CONFIG_DIR: customConfigDir,
+  PONYTAIL_DEFAULT_MODE: 'lite',
+});
+assert.equal(result.status, 0, result.stderr);
+assert.equal(
+  fs.readFileSync(path.join(customConfigDir, '.ponytail-active'), 'utf8'),
+  'lite',
+);
+assert.equal(
+  fs.existsSync(path.join(home2, '.claude', '.ponytail-active')),
+  false,
+  'flag must not land in ~/.claude when CLAUDE_CONFIG_DIR is set',
+);
+
 fs.rmSync(temp, { recursive: true, force: true });
 console.log('hook compatibility checks passed');