chisle 3.1.0 → 3.2.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Maximum-efficiency dev mode. Zero-fluff prose combined with YAGNI/ladder-first code decisions. One persona: the senior dev who deletes code for fun and bills by the syllable.",
   "hooks": {
     "SessionStart": [

package/.clinerules/chisle.md

@@ -1,18 +1,18 @@
 # Chisle
 
-Chisle — maximum-efficiency dev mode. Two compressions, always active together.
+Chisle: maximum-efficiency dev mode. Two compressions, always active together.
 
 **Prose:** Default to fragments. Drop articles, filler (just/really/basically/
 actually), pleasantries (sure/certainly/happy to), hedging, linking verbs where
 meaning survives. Causality as arrows (X → Y). Technical terms, code, API names,
-errors: exact, verbatim. Terse ≠ incomplete — keep every decisive fact (the fix,
+errors: exact, verbatim. Terse ≠ incomplete: keep every decisive fact (the fix,
 the gotcha, the why); cut the words around them, never the facts. Structure is
-tokens — answer at the question's altitude; no manufactured headings, bullet
+tokens, so answer at the question's altitude; no manufactured headings, bullet
 lists, or sections the question didn't ask for. "Summarize/compare X vs Y" is
-the trap: skip headed pro/con bullet walls — name the decisive tradeoffs in
+the trap: skip headed pro/con bullet walls, name the decisive tradeoffs in
 prose, give the verdict, stop.
 
-**Code — the efficiency ladder.** Stop at the first rung that holds:
+**Code: the efficiency ladder.** Stop at the first rung that holds:
 1. Does this need to exist at all? (YAGNI)
 2. Already in this codebase? Reuse it.
 3. Stdlib does it? Use it.
@@ -21,14 +21,21 @@ prose, give the verdict, stop.
 6. Can it be one line?
 7. Only then: the minimum code that works.
 
-No unrequested abstractions. Deletion over addition. Shortest diff wins — after
-you understand the problem, never instead of it.
+No unrequested abstractions. Deletion over addition. Shortest diff wins, after
+you understand the problem and never instead of it.
+
+**Thinking is billed too.** Reasoning tokens cost the same as written ones. The
+ladder is a stopping rule, not a checklist to walk aloud: stop at the first rung
+that holds, don't re-derive the rungs above it or weigh alternatives already
+excluded. Obvious fix → give it; a one-line change gets no design review. Never
+think less about *understanding* the problem: root-cause bugs, read what you
+edit. Depth where the problem is actually hard, nowhere else.
 
 **Context diet:** tool output you pull in is billed on every later turn. Grep
 for the symbol first; read only the matching region, not the whole file. Narrow
 at the source (`ls dir` not `ls -R`, pipe long output through `tail`/`grep`).
 Never re-read what's already in context unless it changed. Never skim what
-you're about to edit — diet trims transport, not understanding.
+you're about to edit: diet trims transport, not understanding.
 
 **Never minimal about:** input validation at trust boundaries, error handling
 that prevents data loss, security, accessibility, anything explicitly requested.

package/.cursor/rules/chisle.mdc

@@ -1,23 +1,23 @@
 ---
-description: Chisle — zero-fluff prose + YAGNI-first code
+description: Chisle, zero-fluff prose + YAGNI-first code
 alwaysApply: true
 ---
 
 # Chisle
 
-Chisle — maximum-efficiency dev mode. Two compressions, always active together.
+Chisle: maximum-efficiency dev mode. Two compressions, always active together.
 
 **Prose:** Default to fragments. Drop articles, filler (just/really/basically/
 actually), pleasantries (sure/certainly/happy to), hedging, linking verbs where
 meaning survives. Causality as arrows (X → Y). Technical terms, code, API names,
-errors: exact, verbatim. Terse ≠ incomplete — keep every decisive fact (the fix,
+errors: exact, verbatim. Terse ≠ incomplete: keep every decisive fact (the fix,
 the gotcha, the why); cut the words around them, never the facts. Structure is
-tokens — answer at the question's altitude; no manufactured headings, bullet
+tokens, so answer at the question's altitude; no manufactured headings, bullet
 lists, or sections the question didn't ask for. "Summarize/compare X vs Y" is
-the trap: skip headed pro/con bullet walls — name the decisive tradeoffs in
+the trap: skip headed pro/con bullet walls, name the decisive tradeoffs in
 prose, give the verdict, stop.
 
-**Code — the efficiency ladder.** Stop at the first rung that holds:
+**Code: the efficiency ladder.** Stop at the first rung that holds:
 1. Does this need to exist at all? (YAGNI)
 2. Already in this codebase? Reuse it.
 3. Stdlib does it? Use it.
@@ -26,14 +26,21 @@ prose, give the verdict, stop.
 6. Can it be one line?
 7. Only then: the minimum code that works.
 
-No unrequested abstractions. Deletion over addition. Shortest diff wins — after
-you understand the problem, never instead of it.
+No unrequested abstractions. Deletion over addition. Shortest diff wins, after
+you understand the problem and never instead of it.
+
+**Thinking is billed too.** Reasoning tokens cost the same as written ones. The
+ladder is a stopping rule, not a checklist to walk aloud: stop at the first rung
+that holds, don't re-derive the rungs above it or weigh alternatives already
+excluded. Obvious fix → give it; a one-line change gets no design review. Never
+think less about *understanding* the problem: root-cause bugs, read what you
+edit. Depth where the problem is actually hard, nowhere else.
 
 **Context diet:** tool output you pull in is billed on every later turn. Grep
 for the symbol first; read only the matching region, not the whole file. Narrow
 at the source (`ls dir` not `ls -R`, pipe long output through `tail`/`grep`).
 Never re-read what's already in context unless it changed. Never skim what
-you're about to edit — diet trims transport, not understanding.
+you're about to edit: diet trims transport, not understanding.
 
 **Never minimal about:** input validation at trust boundaries, error handling
 that prevents data loss, security, accessibility, anything explicitly requested.

package/.github/copilot-instructions.md

@@ -1,18 +1,18 @@
 # Chisle
 
-Chisle — maximum-efficiency dev mode. Two compressions, always active together.
+Chisle: maximum-efficiency dev mode. Two compressions, always active together.
 
 **Prose:** Default to fragments. Drop articles, filler (just/really/basically/
 actually), pleasantries (sure/certainly/happy to), hedging, linking verbs where
 meaning survives. Causality as arrows (X → Y). Technical terms, code, API names,
-errors: exact, verbatim. Terse ≠ incomplete — keep every decisive fact (the fix,
+errors: exact, verbatim. Terse ≠ incomplete: keep every decisive fact (the fix,
 the gotcha, the why); cut the words around them, never the facts. Structure is
-tokens — answer at the question's altitude; no manufactured headings, bullet
+tokens, so answer at the question's altitude; no manufactured headings, bullet
 lists, or sections the question didn't ask for. "Summarize/compare X vs Y" is
-the trap: skip headed pro/con bullet walls — name the decisive tradeoffs in
+the trap: skip headed pro/con bullet walls, name the decisive tradeoffs in
 prose, give the verdict, stop.
 
-**Code — the efficiency ladder.** Stop at the first rung that holds:
+**Code: the efficiency ladder.** Stop at the first rung that holds:
 1. Does this need to exist at all? (YAGNI)
 2. Already in this codebase? Reuse it.
 3. Stdlib does it? Use it.
@@ -21,14 +21,21 @@ prose, give the verdict, stop.
 6. Can it be one line?
 7. Only then: the minimum code that works.
 
-No unrequested abstractions. Deletion over addition. Shortest diff wins — after
-you understand the problem, never instead of it.
+No unrequested abstractions. Deletion over addition. Shortest diff wins, after
+you understand the problem and never instead of it.
+
+**Thinking is billed too.** Reasoning tokens cost the same as written ones. The
+ladder is a stopping rule, not a checklist to walk aloud: stop at the first rung
+that holds, don't re-derive the rungs above it or weigh alternatives already
+excluded. Obvious fix → give it; a one-line change gets no design review. Never
+think less about *understanding* the problem: root-cause bugs, read what you
+edit. Depth where the problem is actually hard, nowhere else.
 
 **Context diet:** tool output you pull in is billed on every later turn. Grep
 for the symbol first; read only the matching region, not the whole file. Narrow
 at the source (`ls dir` not `ls -R`, pipe long output through `tail`/`grep`).
 Never re-read what's already in context unless it changed. Never skim what
-you're about to edit — diet trims transport, not understanding.
+you're about to edit: diet trims transport, not understanding.
 
 **Never minimal about:** input validation at trust boundaries, error handling
 that prevents data loss, security, accessibility, anything explicitly requested.

package/.kiro/steering/chisle.md

@@ -4,19 +4,19 @@ inclusion: always
 
 # Chisle
 
-Chisle — maximum-efficiency dev mode. Two compressions, always active together.
+Chisle: maximum-efficiency dev mode. Two compressions, always active together.
 
 **Prose:** Default to fragments. Drop articles, filler (just/really/basically/
 actually), pleasantries (sure/certainly/happy to), hedging, linking verbs where
 meaning survives. Causality as arrows (X → Y). Technical terms, code, API names,
-errors: exact, verbatim. Terse ≠ incomplete — keep every decisive fact (the fix,
+errors: exact, verbatim. Terse ≠ incomplete: keep every decisive fact (the fix,
 the gotcha, the why); cut the words around them, never the facts. Structure is
-tokens — answer at the question's altitude; no manufactured headings, bullet
+tokens, so answer at the question's altitude; no manufactured headings, bullet
 lists, or sections the question didn't ask for. "Summarize/compare X vs Y" is
-the trap: skip headed pro/con bullet walls — name the decisive tradeoffs in
+the trap: skip headed pro/con bullet walls, name the decisive tradeoffs in
 prose, give the verdict, stop.
 
-**Code — the efficiency ladder.** Stop at the first rung that holds:
+**Code: the efficiency ladder.** Stop at the first rung that holds:
 1. Does this need to exist at all? (YAGNI)
 2. Already in this codebase? Reuse it.
 3. Stdlib does it? Use it.
@@ -25,14 +25,21 @@ prose, give the verdict, stop.
 6. Can it be one line?
 7. Only then: the minimum code that works.
 
-No unrequested abstractions. Deletion over addition. Shortest diff wins — after
-you understand the problem, never instead of it.
+No unrequested abstractions. Deletion over addition. Shortest diff wins, after
+you understand the problem and never instead of it.
+
+**Thinking is billed too.** Reasoning tokens cost the same as written ones. The
+ladder is a stopping rule, not a checklist to walk aloud: stop at the first rung
+that holds, don't re-derive the rungs above it or weigh alternatives already
+excluded. Obvious fix → give it; a one-line change gets no design review. Never
+think less about *understanding* the problem: root-cause bugs, read what you
+edit. Depth where the problem is actually hard, nowhere else.
 
 **Context diet:** tool output you pull in is billed on every later turn. Grep
 for the symbol first; read only the matching region, not the whole file. Narrow
 at the source (`ls dir` not `ls -R`, pipe long output through `tail`/`grep`).
 Never re-read what's already in context unless it changed. Never skim what
-you're about to edit — diet trims transport, not understanding.
+you're about to edit: diet trims transport, not understanding.
 
 **Never minimal about:** input validation at trust boundaries, error handling
 that prevents data loss, security, accessibility, anything explicitly requested.

package/.windsurf/rules/chisle.md

@@ -4,19 +4,19 @@ trigger: always_on
 
 # Chisle
 
-Chisle — maximum-efficiency dev mode. Two compressions, always active together.
+Chisle: maximum-efficiency dev mode. Two compressions, always active together.
 
 **Prose:** Default to fragments. Drop articles, filler (just/really/basically/
 actually), pleasantries (sure/certainly/happy to), hedging, linking verbs where
 meaning survives. Causality as arrows (X → Y). Technical terms, code, API names,
-errors: exact, verbatim. Terse ≠ incomplete — keep every decisive fact (the fix,
+errors: exact, verbatim. Terse ≠ incomplete: keep every decisive fact (the fix,
 the gotcha, the why); cut the words around them, never the facts. Structure is
-tokens — answer at the question's altitude; no manufactured headings, bullet
+tokens, so answer at the question's altitude; no manufactured headings, bullet
 lists, or sections the question didn't ask for. "Summarize/compare X vs Y" is
-the trap: skip headed pro/con bullet walls — name the decisive tradeoffs in
+the trap: skip headed pro/con bullet walls, name the decisive tradeoffs in
 prose, give the verdict, stop.
 
-**Code — the efficiency ladder.** Stop at the first rung that holds:
+**Code: the efficiency ladder.** Stop at the first rung that holds:
 1. Does this need to exist at all? (YAGNI)
 2. Already in this codebase? Reuse it.
 3. Stdlib does it? Use it.
@@ -25,14 +25,21 @@ prose, give the verdict, stop.
 6. Can it be one line?
 7. Only then: the minimum code that works.
 
-No unrequested abstractions. Deletion over addition. Shortest diff wins — after
-you understand the problem, never instead of it.
+No unrequested abstractions. Deletion over addition. Shortest diff wins, after
+you understand the problem and never instead of it.
+
+**Thinking is billed too.** Reasoning tokens cost the same as written ones. The
+ladder is a stopping rule, not a checklist to walk aloud: stop at the first rung
+that holds, don't re-derive the rungs above it or weigh alternatives already
+excluded. Obvious fix → give it; a one-line change gets no design review. Never
+think less about *understanding* the problem: root-cause bugs, read what you
+edit. Depth where the problem is actually hard, nowhere else.
 
 **Context diet:** tool output you pull in is billed on every later turn. Grep
 for the symbol first; read only the matching region, not the whole file. Narrow
 at the source (`ls dir` not `ls -R`, pipe long output through `tail`/`grep`).
 Never re-read what's already in context unless it changed. Never skim what
-you're about to edit — diet trims transport, not understanding.
+you're about to edit: diet trims transport, not understanding.
 
 **Never minimal about:** input validation at trust boundaries, error handling
 that prevents data loss, security, accessibility, anything explicitly requested.

package/AGENTS.md

@@ -25,8 +25,17 @@ Before writing anything, stop at the first rung that holds:
 6. Can it be one line?
 7. Only then: the minimum code that works.
 
-No unrequested abstractions. Deletion over addition. Shortest diff wins —
-after you understand the problem, never instead of it.
+No unrequested abstractions. Deletion over addition. Shortest diff wins,
+after you understand the problem and never instead of it.
+
+## Thinking is billed too
+
+Reasoning tokens cost the same as written ones. The ladder is a stopping rule,
+not a checklist to walk aloud: stop at the first rung that holds, don't
+re-derive the rungs above it or weigh alternatives already excluded. Obvious
+fix, give it; a one-line change gets no design review. Never think less about
+understanding the problem: root-cause bugs, read what you edit. Depth where the
+problem is actually hard, nowhere else.
 
 ## Context diet
 
@@ -34,7 +43,7 @@ Tool output you pull in is billed on every later turn. Grep for the symbol
 first; read only the matching region, not the whole file. Narrow at the source
 (`ls dir` not `ls -R`, pipe long output through `tail`/`grep`). Never re-read
 what's already in context unless it changed. Never skim what you're about to
-edit — diet trims transport, not understanding.
+edit: diet trims transport, not understanding.
 
 ## Never minimal about
 

package/README.md

@@ -5,7 +5,7 @@
 <h1 align="center">Chisle</h1>
 
 <p align="center">
-  <em>Your AI talks less, builds less, reads less — and says more. Like a senior dev who bills by the syllable.</em>
+  <em>Your AI talks less, builds less, reads less, and says more. Like a senior dev who bills by the syllable.</em>
 </p>
 
 <p align="center">
@@ -26,15 +26,15 @@
 </p>
 
 <p align="center">
-  <a href="https://chisle.jaypokale.me"><strong>chisle.jaypokale.me</strong></a> — the site version of this README, with fewer words
+  <a href="https://chisle.jaypokale.me"><strong>chisle.jaypokale.me</strong></a> is the site version of this README, with fewer words
 </p>
 
 ---
 
-"Add debounce to a search input that currently fires an API call on every keystroke." Same model, same prompt, one difference — the injected ruleset. Both answers below are the **verbatim committed output** from [`benchmarks/results/raw/`](benchmarks/results/raw/):
+"Add debounce to a search input that currently fires an API call on every keystroke." Same model, same prompt, one difference: the injected ruleset. Both answers below are the **verbatim committed output** from [`benchmarks/results/raw/`](benchmarks/results/raw/):
 
 <table>
-<tr><th align="left" width="50%">bare agent — 142 lines, 1506 tokens</th><th align="left" width="50%">Chisle — 35 lines, 602 tokens</th></tr>
+<tr><th align="left" width="50%">bare agent: 142 lines, 1506 tokens</th><th align="left" width="50%">Chisle: 35 lines, 602 tokens</th></tr>
 <tr valign="top"><td>
 
 Opens with *"Let me show you the most common approaches"*, then ships a reusable generic `useDebounce<T>` hook in its own file…
@@ -55,7 +55,7 @@ export function useDebounce<T>(
 
 </td><td>
 
-Asks which framework, then answers the question that was actually asked — `setTimeout` in the effect you already have, no new file, no generic:
+Asks which framework, then answers the question that was actually asked: `setTimeout` in the effect you already have, no new file, no generic:
 
 ```jsx
 useEffect(() => {
@@ -71,7 +71,7 @@ Then two lines on why it works, and *"use `lodash.debounce` if already installed
 </td></tr>
 </table>
 
-Not golfed — **boring**. Same behaviour, one less abstraction, no second file, and it names the dependency you might already have instead of reinventing it.
+Not golfed, **boring**. Same behaviour, one less abstraction, no second file, and it names the dependency you might already have instead of reinventing it.
 
 Most efficiency tools compress one thing. Chisle compresses **three**:
 
@@ -79,7 +79,7 @@ Most efficiency tools compress one thing. Chisle compresses **three**:
 |---|---|---|
 | **Output: prose** | filler, hedging, manufactured structure | zero-fluff ruleset, injected per session |
 | **Output: code** | speculative abstractions, unrequested boilerplate | YAGNI efficiency ladder |
-| **Input: context** | oversized tool output flooding the window | Claude `PostToolUse` / Pi `tool_result` — scrub, elide, dedup — plus prevention rules |
+| **Input: context** | oversized tool output flooding the window | Claude `PostToolUse` / Pi `tool_result`: scrub, elide, dedup, plus prevention rules |
 
 Where each one attaches to a session:
 
@@ -102,7 +102,7 @@ flowchart LR
     TOOL -->|raw output| H3
     H3 -->|"compressed, rebuilt into<br/>the tool's own shape"| M
 
-    RE["Read / Edit / Write"] -.->|"never touched —<br/>exact bytes feed later edits"| M
+    RE["Read / Edit / Write"] -.->|"never touched,<br/>exact bytes feed later edits"| M
 
     style M fill:#1f2937,stroke:#d78a3c,color:#e6edf3
     style O fill:#14532d,stroke:#2da44e,color:#e6edf3
@@ -113,10 +113,10 @@ flowchart LR
 The loop on the right is the input axis: tool output is billed again on *every* later request in the session, so shrinking it once pays repeatedly. `Read`, `Edit`, and `Write` are deliberately outside it.
 
 <p align="center">
-  <img src="assets/thumbnail.png" width="820" alt="Chisle — less tokens, same results. Four parts: output compressor (compress noisy tool outputs), context diet (read only what's actually relevant), terse persona (short, focused, YAGNI-first), YAGNI ladder (do less, reuse more, build only when needed).">
+  <img src="assets/thumbnail.png" width="820" alt="Chisle: less tokens, same results. Four parts: output compressor (compress noisy tool outputs), context diet (read only what's actually relevant), terse persona (short, focused, YAGNI-first), YAGNI ladder (do less, reuse more, build only when needed).">
 </p>
 
-Every "be concise" tool has a worst day — the day it makes the model write *more* than no tool at all. Across 20 measured tasks over two suites, the specialists had that day **6** and **8** times, blowing up to **424%** of the baseline. Chisle had it **once**, capped at 173% — and that one failure was root-caused, fixed in the ruleset, and re-validated live at 93%, with the whole investigation [committed to the repo](benchmarks/results/2026-07-07-verify-rerun.md). Think of it as downside insurance for your token bill: not always the single cheapest answer, always the smallest worst case — from the only tool in this class that publishes its own failures. [Why not caveman or ponytail? →](docs/comparison.md)
+Every "be concise" tool has a worst day, the day it makes the model write *more* than no tool at all. Across 20 measured tasks over two suites, the specialists had that day **6** and **8** times, blowing up to **424%** of the baseline. Chisle had it **once**, capped at 173%, and that one failure was root-caused, fixed in the ruleset, and re-validated live at 93%, with the whole investigation [committed to the repo](benchmarks/results/2026-07-07-verify-rerun.md). Think of it as downside insurance for your token bill: not always the single cheapest answer, always the smallest worst case, from the only tool in this class that publishes its own failures. [Why not caveman or ponytail? →](docs/comparison.md)
 
 ---
 
@@ -140,11 +140,11 @@ irm https://raw.githubusercontent.com/JayPokale/Chisle/main/install.ps1 | iex
 
 Preview first with `npx chisle --dry-run`, scope with `--only claude` or `--only pi`, see everything with `npx chisle --help`. Remove with `npx chisle --uninstall`.
 
-**Requirements:** Node ≥18 (installer / `npx`) · Claude Code or Pi for `/chisle` toggling and input-side compression — the always-on ruleset still ships to every other agent.
+**Requirements:** Node ≥18 (installer / `npx`) · Claude Code or Pi for `/chisle` toggling and input-side compression. The always-on ruleset still ships to every other agent.
 
 ### Upgrading
 
-Same command as installing — it is idempotent and overwrites the previous copy:
+Same command as installing. It is idempotent and overwrites the previous copy:
 
 ```bash
 npx chisle              # npm / standalone install
@@ -158,7 +158,7 @@ releases stay quiet on purpose.
 Upgrading to 3.0.0 from 2.x needs nothing: a `lite`/`full`/`ultra` value in
 `CHISLE_DEFAULT_MODE` or `config.json` is no longer meaningful, falls through to
 the default, and Chisle stays active. It says so once so the setting is not
-ignored silently — replace it with `on`/`off` or delete it.
+ignored silently. Replace it with `on`/`off` or delete it.
 
 ### Claude Code plugin (marketplace)
 
@@ -175,13 +175,33 @@ pi install npm:chisle
 
 The package loads the zero-dependency extension and `chisle` skill globally. Pi extensions run with your user permissions; review the source before installation. Project-local installs (`pi install -l npm:chisle`) load only after you trust that project.
 
+### Where the savings show up
+
+Two places, both measured rather than estimated:
+
+```bash
+npx chisle --stats      # what the compressor has saved, cumulative
+```
+
+```text
+chisle: tool-output savings
+
+  saved:      88,967 chars  (~22,241 tokens)
+  outputs:    18 compressed, 4,943 chars each on average
+```
+
+In Claude Code the statusline badge carries the same number live: `[CHISLE] ⇣22k tok`. Pi shows it in the footer for the current session.
+
+This is the **input axis only**, and deliberately so. Chars elided have a real baseline, since the hook knows exactly what it cut. The output axis has none: there is no way to know what the model would have written without the ruleset, which is why that half is measured with A/B benchmark arms instead of a counter. A number that blended the two would be inventing the interesting half.
+
 ### See what it would do, before it does it
 
 ```bash
 npx chisle --dry-run    # prints every file it would touch, changes nothing
+npx chisle --stats      # prints what it has saved, changes nothing
 ```
 
-Want the savings measured on your own work rather than ours? Clone the repo and replay the compressor over local transcripts — it reads them locally, writes nothing, and reports the input the hook would have stripped:
+Want the savings measured on your own work rather than ours? Clone the repo and replay the compressor over local transcripts. It reads them locally, writes nothing, and reports the input the hook would have stripped:
 
 ```bash
 git clone https://github.com/JayPokale/Chisle && cd Chisle
@@ -195,7 +215,7 @@ node benchmarks/replay-compress.js pi    # Pi; marginal over Pi's native truncat
 
 Nothing here is estimated. Every figure below is recomputed from committed raw data; the 2026-07-07 [verification writeup](benchmarks/results/2026-07-07-verify-rerun.md) re-derived the old claims from scratch, re-ran the whole suite against the competitors' **installed plugins**, and retired the one claim that didn't survive.
 
-### Output axis — vs caveman & ponytail, 20 live tasks
+### Output axis: vs caveman & ponytail, 20 live tasks
 
 **59+ live model runs** across two suites (June 4-arm matrix on Haiku + Sonnet sweep; July re-verification run). Arms differ only in the injected system prompt. Billed output tokens vs the no-tool baseline:
 
@@ -208,10 +228,10 @@ Nothing here is estimated. Every figure below is recomputed from committed raw d
 Chisle wins all four columns: it cut the total 20-task bill **nearly in half** while the specialists managed 20–32%, and it did so with the smallest worst day and a twentieth the backfire rate.
 
 <p align="center">
-  <img src="assets/benchmark.svg" width="820" alt="Total billed output across 20 tasks as percent of the no-tool baseline. caveman 80% (worst day 424%, backfired 6), ponytail 68% (worst day 227%, backfired 8), Chisle 52% (worst day 173%, backfired 1 — root-caused and fixed).">
+  <img src="assets/benchmark.svg" width="820" alt="Total billed output across 20 tasks as percent of the no-tool baseline. caveman 80% (worst day 424%, backfired 6), ponytail 68% (worst day 227%, backfired 8), Chisle 52% (worst day 173%, backfired 1, root-caused and fixed).">
 </p>
 
-The bar is the whole 20-task bill; the badge is each tool's worst single day. caveman's worst day cost **4.2×** a bare model; ponytail's — a tool whose entire job is writing less — **2.3×**. Chisle's worst day was 1.7×, it happened once, and the fix is measured and merged.
+The bar is the whole 20-task bill; the badge is each tool's worst single day. caveman's worst day cost **4.2×** a bare model; ponytail's, a tool whose entire job is writing less, **2.3×**. Chisle's worst day was 1.7×, it happened once, and the fix is measured and merged.
 
 In the July run all 24 answers, every arm, **graded correct**: nobody here buys token savings with wrong answers.
 
@@ -224,35 +244,35 @@ Across all 20 cells, split by what the prompt actually asks for:
 | **coding** (wants working code) | 12 | 74% | 59% | **44%** |
 | **non-coding** (wants an explanation) | 8 | 103% | 104% | **87%** |
 
-Code is where the YAGNI ladder has something to bite on: an abstraction to skip, a stdlib call to reach for, a file not to create. Chisle bills **44%** of a bare model there — a third less than ponytail, which is the closest thing to a dedicated lazy-code tool.
+Code is where the YAGNI ladder has something to bite on: an abstraction to skip, a stdlib call to reach for, a file not to create. Chisle bills **44%** of a bare model there, a third less than ponytail, which is the closest thing to a dedicated lazy-code tool.
 
-On explanation-only prompts the picture is worse for everyone. Both specialists land **above 100%** — a tool whose job is writing less made the model write *more* than using nothing at all. Chisle is the only arm that stays under water (87%), which is a smaller win than the coding number and worth saying plainly.
+On explanation-only prompts the picture is worse for everyone. Both specialists land **above 100%**: a tool whose job is writing less made the model write *more* than using nothing at all. Chisle is the only arm that stays under water (87%), which is a smaller win than the coding number and worth saying plainly.
 
 This does revise a claim the earlier Sonnet writeup made. On that suite's three prose prompts caveman was leaner (44% vs 52%), and that still holds *for those cells*. Pooled across all eight non-coding cells it does not: caveman is at 103%. The prose win was suite-specific, not general.
 
 #### Task by task
 
-Averages hide the interesting part, so here is every cell of the June suite — same six prompts, every arm, no cherry-picking:
+Averages hide the interesting part, so here is every cell of the June suite, same six prompts, every arm, no cherry-picking:
 
 <p align="center">
   <img src="assets/per-task.svg" width="820" alt="Billed output per task as a percent of the no-tool baseline across the six-task June suite: Chisle is leanest on five of six, caveman wins the cache task at 8% versus Chisle's 12%.">
 </p>
 
-Chisle is leanest on **5 of 6**. caveman takes `cache` (8% vs our 12%) — it wins by answering in prose where we still emit working code, which is the trade you would want on a task that asked for code. Note the two prose rows where ponytail lands **above** 100%: a tool built to write less made the model write *more* than using no tool at all. That is the failure mode the worst-case column above is really about.
+Chisle is leanest on **5 of 6**. caveman takes `cache` (8% vs our 12%) by answering in prose where we still emit working code, which is the trade you would want on a task that asked for code. Note the two prose rows where ponytail lands **above** 100%: a tool built to write less made the model write *more* than using no tool at all. That is the failure mode the worst-case column above is really about.
 
 #### The headline average is hiding the good part
 
-Split the same 20 cells at their median baseline — short answers below, long answers above — and the tools separate sharply:
+Split the same 20 cells at their median baseline, short answers below and long answers above, and the tools separate sharply:
 
 <p align="center">
   <img src="assets/by-size.svg" width="820" alt="Total billed output split by answer size. On short answers caveman and Chisle are level at about 84% of baseline and ponytail is above 100%. On long answers Chisle drops to about 45% while caveman is 79% and ponytail 59%.">
 </p>
 
-On **short** answers Chisle and caveman are level (84% each) — there is not much to cut in a three-line reply, and the ruleset overhead is proportionally at its worst. On **long** answers Chisle drops to **45%** while caveman only reaches 79%. The 52% headline is the blend of the two, so it understates the case where it matters and overstates the case where it doesn't.
+On **short** answers Chisle and caveman are level (84% each), because there is not much to cut in a three-line reply, and the ruleset overhead is proportionally at its worst. On **long** answers Chisle drops to **45%** while caveman only reaches 79%. The 52% headline is the blend of the two, so it understates the case where it matters and overstates the case where it doesn't.
 
-The effect is not driven by one lucky cell. Dropping the `cache` outlier (the row where the baseline invented 150 lines against a codebase it never saw) *widens* the gap on long answers: caveman degrades to **116%** — worse than using no tool — while Chisle holds at **65%**.
+The effect is not driven by one lucky cell. Dropping the `cache` outlier (the row where the baseline invented 150 lines against a codebase it never saw) *widens* the gap on long answers: caveman degrades to **116%**, worse than using no tool, while Chisle holds at **65%**.
 
-Two honest limits. Per-task rank correlation between baseline size and leanness is weak (Spearman ρ = −0.15), so this is a difference between aggregate bills, not a tidy per-task law — with n=10 a side, treat it as a strong signal rather than a settled result. And much of the widening gap comes from the specialists getting *worse* on long answers, not only from Chisle getting better.
+Two honest limits. Per-task rank correlation between baseline size and leanness is weak (Spearman ρ = −0.15), so this is a difference between aggregate bills, not a tidy per-task law. With n=10 a side, treat it as a strong signal rather than a settled result. And much of the widening gap comes from the specialists getting *worse* on long answers, not only from Chisle getting better.
 
 #### Size or kind? Both, and they're tangled
 
@@ -269,11 +289,11 @@ Coding prompts average ~1129 baseline tokens against ~393 for explanation prompt
   <img src="assets/by-kind.svg" width="820" alt="Billed output by task kind crossed with answer size. Code and short: caveman 62%, ponytail 116%, Chisle 70%. Code and long: caveman 76%, ponytail 52%, Chisle 41%. Explanation and short: caveman 104%, ponytail 98%, Chisle 96%. Explanation and long: caveman 103%, ponytail 111%, Chisle 77%.">
 </p>
 
-Size matters *within* each kind — coding goes 70% → 41%, non-coding 96% → 77% — so it isn't merely code in disguise. But the cells are thin, and the non-coding "long" bucket spans only 522–542 tokens, which is barely long at all.
+Size matters *within* each kind: coding goes 70% → 41% and non-coding 96% → 77%, so it isn't merely code in disguise. But the cells are thin, and the non-coding "long" bucket spans only 522–542 tokens, which is barely long at all.
 
 The one row Chisle loses is **short coding**, where caveman takes it 62% to 70%. That is the honest shape of it: on a small code question there is little to skip, and the ruleset costs more than the ladder saves. The tool earns its keep on the long ones.
 
-`SUITE=large` exists to fill the thin cells — see [below](#see-what-it-would-do-before-it-does-it).
+`SUITE=large` exists to fill the thin cells, see [below](#see-what-it-would-do-before-it-does-it).
 
 These prompts were never designed to test this, which is the real caveat. To probe it directly:
 
@@ -287,22 +307,22 @@ SUITE=large bash benchmarks/run-live.sh <model> benchmarks/results/raw-large
 |---|:---:|:---:|:---:|:---:|:---:|
 | caveman | ✅ | ❌ | ❌ | ❌ 424% | ❌ |
 | ponytail | ❌ | ✅ | ❌ | ❌ 227% | ❌ |
-| headroom | ❌ | ❌ | ✅ proxy | — | ❌ |
+| headroom | ❌ | ❌ | ✅ proxy | n/a | ❌ |
 | **Chisle** | ✅ | ✅ | ✅ hook | **173%, 1/20** | ✅ |
 
 The row that matters is the last one. Every tool here looks good on its best day; the numbers above are the only ones in this class published alongside the run that went wrong. [Full comparison →](docs/comparison.md)
 
-### Input axis — tool-output compression (Claude Code + Pi)
+### Input axis: tool-output compression (Claude Code + Pi)
 
-Measured over 171 real sessions ([receipts](benchmarks/results/2026-07-07-input-axis.md)): tool output is **67.5%** of context content, and every byte of it is re-billed on *every subsequent request* in the session (median: 171 requests). A `PostToolUse` hook shrinks it before the model reads it — deterministic, zero LLM, zero network:
+Measured over 171 real sessions ([receipts](benchmarks/results/2026-07-07-input-axis.md)): tool output is **67.5%** of context content, and every byte of it is re-billed on *every subsequent request* in the session (median: 171 requests). A `PostToolUse` hook shrinks it before the model reads it: deterministic, zero LLM, zero network:
 
 | tier | what it does | loss |
 |---|---|---|
 | **scrub** | strips ANSI escapes, collapses blank runs and `line repeated N×` | none |
 | **elide** | oversized output → head + tail, error-like lines salvaged from the cut | bounded, guarded |
-| **dedup** | byte-identical repeat of a tool's previous output (same session) → one-line marker | none — the copy is already in context |
+| **dedup** | byte-identical repeat of a tool's previous output (same session) → one-line marker | none, the copy is already in context |
 
-Replayed over the same 171 Claude Code sessions: **~61k tokens** saved one-shot, ~46% off every eligible output — floor, not estimate, since each saved byte also stops being re-sent on every later request. Correctness rules: allowlist only (`Bash`, `Agent`, `WebFetch`, `WebSearch`, `Grep`, `Glob`, `mcp__*`) — never `Read`/`Edit`, whose exact bytes feed later edits. Honest ledger: dedup scored **0 hits** on this corpus (rtk-filtered at source); it's kept for the test-rerun case, kill-switchable, and labeled speculative until it earns a number.
+Replayed over the same 171 Claude Code sessions: **~61k tokens** saved one-shot, ~46% off every eligible output: a floor, not an estimate, since each saved byte also stops being re-sent on every later request. Correctness rules: allowlist only (`Bash`, `Agent`, `WebFetch`, `WebSearch`, `Grep`, `Glob`, `mcp__*`), never `Read`/`Edit`, whose exact bytes feed later edits. Honest ledger: dedup scored **0 hits** on this corpus (rtk-filtered at source); it's kept for the test-rerun case, kill-switchable, and labeled speculative until it earns a number.
 
 Pi already truncates built-in output at 50KB/2,000 lines. Replay over 8,044 persisted Pi results measured the compressor's **marginal** saving after that truncation: **27.4% of tool-output chars** ([receipt + raw live Pi arm](benchmarks/results/2026-09-11-pi.md)). Pi compresses `bash`, `powershell`, `grep`, `find`, `ls`, MCP, and explicitly allowlisted extension-tool results; `read`/`edit`/`write` remain untouched. `CHISLE_COMPRESS_TOOLS` supplies the same explicit override for runtime and replay. Runtime dedup only compares earlier turns, so concurrently completed sibling calls cannot dedup one another.
 
@@ -311,11 +331,30 @@ node benchmarks/replay-compress.js       # Claude Code
 node benchmarks/replay-compress.js pi    # Pi
 ```
 
-Outputs over 8k chars are elided. `stop chisle`, `CHISLE_COMPRESS=0`, `CHISLE_COMPRESS_SCRUB=0`, `CHISLE_COMPRESS_DEDUP=0` — every tier has an off switch.
+Outputs over 8k chars are elided. `stop chisle`, `CHISLE_COMPRESS=0`, `CHISLE_COMPRESS_SCRUB=0`, `CHISLE_COMPRESS_DEDUP=0`. Every tier has an off switch.
+
+### Pi arm: where the output axis lost
+
+Six tasks, Pi 0.85.1 on `openai-codex/gpt-5.5`, as % of the vanilla no-tool baseline. Lower is better, bold is the winner of the row:
+
+| segment | vanilla | caveman | ponytail | **Chisle** |
+|---|--:|--:|--:|--:|
+| coding billed tokens | 100% | 87% | **49%** | 73% |
+| non-coding billed tokens | 100% | 43% | 76% | **39%** |
+| **all billed tokens** | 100% | 72% | **59%** | 61% |
+| all visible-answer tokens | 100% | 56% | 49% | **37%** |
+| all answer lines | 100% | 75% | 38% | **37%** |
+| tasks correct | 5/6 | 5/6 | 5/6 | 5/6 |
+
+**Chisle lost billed output here.** ponytail used 63 fewer tokens over the six tasks. Publishing that is the point of this section.
+
+The coding gap is one task. Chisle leads 4 of 6 tasks outright; `auth-bug` alone accounts for 283 of the 337-token coding gap. On that task Chisle produced the shortest answer of any arm (377 chars to ponytail's 632) and was the only arm to find the real defect: ponytail flipped `>` to `>=`, while Chisle identified the seconds-versus-milliseconds unit mismatch behind it. The grader scored every arm as failing regardless, which says more about that task than about the tools.
+
+Six tasks, one model, one run. Raw events and per-task cells: [`benchmarks/results/raw-pi/`](benchmarks/results/raw-pi/).
 
-### Prevention — the context diet
+### Prevention: the context diet
 
-The biggest context whale (whole-file `Read`s — 5.6M chars in the measured corpus) can't be compressed without breaking later edits. So the ruleset attacks it upstream, in every agent: grep for the symbol first, read only the matching region, narrow at the source (`ls dir` not `ls -R`, pipe long output through `tail`/`grep`), never re-read what's already in context.
+The biggest context whale (whole-file `Read`s, 5.6M chars in the measured corpus) can't be compressed without breaking later edits. So the ruleset attacks it upstream, in every agent: grep for the symbol first, read only the matching region, narrow at the source (`ls dir` not `ls -R`, pipe long output through `tail`/`grep`), never re-read what's already in context.
 
 ---
 
@@ -325,7 +364,7 @@ The biggest context whale (whole-file `Read`s — 5.6M chars in the measured cor
 > New object ref each render. Inline object prop = new ref = re-render. `useMemo`.
 
 **"Add a cache for API responses."**
-> `@lru_cache(maxsize=1000)` on the fetch fn. Skipped a custom cache class — add one when `lru_cache` measurably falls short.
+> `@lru_cache(maxsize=1000)` on the fetch fn. Skipped a custom cache class; add one when `lru_cache` measurably falls short.
 
 ---
 
@@ -339,7 +378,7 @@ The biggest context whale (whole-file `Read`s — 5.6M chars in the measured cor
 | `stop chisle` | Deactivate (ruleset *and* input-side compression) |
 | `normal mode` | Deactivate |
 
-Natural language works too: "activate chisle", "chisle mode", "chislify this". Code symbols, function/API names, and error strings stay verbatim — only the noise around them compresses.
+Natural language works too: "activate chisle", "chisle mode", "chislify this". Code symbols, function/API names, and error strings stay verbatim, so only the noise around them compresses.
 
 ---
 
@@ -371,9 +410,9 @@ flowchart TD
     style R fill:#1f2937,stroke:#8b949e,color:#e6edf3
 ```
 
-The ladder runs **after** reading, never instead of it. Note the exit: every rung lands on the same obligation — say what you skipped, so "later" doesn't quietly become "never".
+The ladder runs **after** reading, never instead of it. Note the exit: every rung lands on the same obligation: say what you skipped, so "later" doesn't quietly become "never".
 
-The ladder runs *after* reading the code — lazy about the solution, never about understanding. Lazy is not negligent: trust-boundary validation, data-loss handling, security, and accessibility are never on the chopping block.
+The ladder runs *after* reading the code, lazy about the solution and never about understanding. Lazy is not negligent: trust-boundary validation, data-loss handling, security, and accessibility are never on the chopping block.
 
 Mark deliberate simplifications so "later" doesn't quietly become "never":
 
@@ -386,7 +425,7 @@ Mark deliberate simplifications so "later" doesn't quietly become "never":
 
 ## Config
 
-**On by default.** After install, Chisle activates automatically every session — no `/chisle` needed. Set `off` to stay dormant until you type `/chisle`:
+**On by default.** After install, Chisle activates automatically every session, with no `/chisle` needed. Set `off` to stay dormant until you type `/chisle`:
 
 ```bash
 # env var (highest priority)
@@ -408,10 +447,10 @@ Chisle borrows the best published token-saving techniques and implements the one
 |---|---|---|
 | Prose compression persona | [caveman](https://github.com/JuliusBrussee/caveman) | ✅ + code judgment it lacks |
 | YAGNI/lazy-code ruleset | [ponytail](https://github.com/dietrichgebert/ponytail) | ✅ + prose discipline it lacks |
-| Tool-output elision (head/tail) | [headroom](https://github.com/headroomlabs-ai/headroom)-style, proxy-free | ✅ hook, no proxy — works on subscription OAuth |
+| Tool-output elision (head/tail) | [headroom](https://github.com/headroomlabs-ai/headroom)-style, proxy-free | ✅ hook, no proxy, works on subscription OAuth |
 | ANSI strip / log crush / dedup | headroom transforms | ✅ scrub + dedup tiers |
-| Command rewriting at the source | RTK-style `PreToolUse` ([writeup](https://andrewpatterson.dev/posts/token-savings-rtk-headroom/)) | ❌ stacks — RTK shrinks at source, Chisle catches what it can't reach (subagents, MCP, web) |
-| MCP/codebase-graph indexing | context-mode, [token-optimizer-mcp](https://github.com/ooples/token-optimizer-mcp) | ❌ stacks — orthogonal layer |
+| Command rewriting at the source | RTK-style `PreToolUse` ([writeup](https://andrewpatterson.dev/posts/token-savings-rtk-headroom/)) | ❌ stacks; RTK shrinks at source, Chisle catches what it can't reach (subagents, MCP, web) |
+| MCP/codebase-graph indexing | context-mode, [token-optimizer-mcp](https://github.com/ooples/token-optimizer-mcp) | ❌ stacks, orthogonal layer |
 | CLAUDE.md dieting | [community guides](https://www.firecrawl.dev/blog/claude-code-token-efficiency) | ✅ `/chisle-audit` flags bloated docs/config prose |
 
 ## Multi-agent
@@ -423,7 +462,7 @@ Ships to nine agents: Claude Code and Pi get both axes, live `/chisle` toggling,
 **Doesn't injecting a persona every turn cost tokens?**
 Claude Code uses a ruleset at session start (~1.6k tokens) plus a ~50-token reminder per turn. Pi injects one persistent rules message only when project `AGENTS.md` does not already provide it; resume/reload does not duplicate it, and compaction restores it only if removed.
 
-Worth reading the dissent before you take that on faith: [@enc0ded](https://github.com/enc0ded) measured 173 of their own sessions ([#2](https://github.com/JayPokale/Chisle/issues/2)) and found the injection overhead roughly cancelling the compressor's savings — because the ruleset was being re-sent on every resume and clear, not just at startup. That re-injection is fixed, which removes most of the overhead they measured, but their wider point stands: prose is only ~25% of what the model emits, so the ceiling on the output axis is lower than the headline suggests, and on a one-line throwaway prompt the overhead still exceeds the saving.
+Worth reading the dissent before you take that on faith: [@enc0ded](https://github.com/enc0ded) measured 173 of their own sessions ([#2](https://github.com/JayPokale/Chisle/issues/2)) and found the injection overhead roughly cancelling the compressor's savings, because the ruleset was being re-sent on every resume and clear, not just at startup. That re-injection is fixed, which removes most of the overhead they measured, but their wider point stands: prose is only ~25% of what the model emits, so the ceiling on the output axis is lower than the headline suggests, and on a one-line throwaway prompt the overhead still exceeds the saving.
 
 **Will it golf my code into clever one-liners?**
 No. Boring over clever. Deletion beats addition; obfuscation isn't deletion.
@@ -432,10 +471,10 @@ No. Boring over clever. Deletion beats addition; obfuscation isn't deletion.
 Never. Input validation, data-loss handling, security, and accessibility are off the table. Lazy about solutions, not about reading the problem.
 
 **Can the output compressor eat a line I needed?**
-Designed not to: allowlist keeps `Read`/`Edit` exact, error-looking lines are salvaged from any elided region, dedup only fires on byte-identical same-session repeats, and every tier has a kill switch. If it still bites you, file an issue — that's a bug, not the design.
+Designed not to: allowlist keeps `Read`/`Edit` exact, error-looking lines are salvaged from any elided region, dedup only fires on byte-identical same-session repeats, and every tier has a kill switch. If it still bites you, file an issue. That's a bug, not the design.
 
 **Should the star count worry me?**
-Everyone starts at zero. Run `npx chisle --dry-run`, see what it'd do, decide. And if the receipts convinced you, [a star](https://github.com/JayPokale/Chisle/stargazers) is how the next person finds them — it's also the only payment a zero-dep MIT tool will ever ask for.
+Everyone starts at zero. Run `npx chisle --dry-run`, see what it'd do, decide. And if the receipts convinced you, [a star](https://github.com/JayPokale/Chisle/stargazers) is how the next person finds them, and it's also the only payment a zero-dep MIT tool will ever ask for.
 
 → [More FAQ and competitor comparison](docs/comparison.md)
 
@@ -445,7 +484,7 @@ Everyone starts at zero. Run `npx chisle --dry-run`, see what it'd do, decide. A
 
 See [CONTRIBUTING.md](CONTRIBUTING.md). Edit the skill (`skills/chisle/SKILL.md`) **and** the condensed rule body in `scripts/build-rules.js`, regenerate copies and chart, run the tests. CI enforces all three.
 
-Built by [Jay Pokale](https://github.com/JayPokale) with [Claude](https://claude.com/claude-code), [Antigravity](https://antigravity.google), and [Codex](https://openai.com/blog/openai-codex/) as co-engineers — the input-compression hook, the benchmark verification, and several of the bug hunts documented in the changelog were pair-work.
+Built by [Jay Pokale](https://github.com/JayPokale) with [Claude](https://claude.com/claude-code), [Antigravity](https://antigravity.google), and [Codex](https://openai.com/blog/openai-codex/) as co-engineers: the input-compression hook, the benchmark verification, and several of the bug hunts documented in the changelog were pair-work.
 
 ```bash
 npm test    # 67 tests: flag safety, tracker, settings merge, installer, compressor
@@ -472,5 +511,5 @@ npm test    # 67 tests: flag safety, tracker, settings merge, installer, compres
 ---
 
 <p align="center">
-  Saved you tokens? <a href="https://github.com/JayPokale/Chisle">⭐ Star the repo</a> — it costs zero tokens and keeps the benchmarks running.
+  Saved you tokens? <a href="https://github.com/JayPokale/Chisle">⭐ Star the repo</a>. It costs zero tokens and keeps the benchmarks running.
 </p>

package/bin/install.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// chisle — cross-platform installer.
+// chisle: cross-platform installer.
 //
 // Detects the AI coding agents on this machine and installs Chisle for each:
 //   - Claude Code  → plugin (marketplace add + install), fallback to standalone
@@ -58,13 +58,14 @@ const PROVIDERS = [
 // ── argv ────────────────────────────────────────────────────────────────────
 function parseArgs(argv) {
   const opts = { dryRun: false, force: false, list: false, uninstall: false,
-                 noColor: false, help: false, only: [], configDir: null };
+                 noColor: false, help: false, stats: false, only: [], configDir: null };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     switch (a) {
       case '--dry-run': opts.dryRun = true; break;
       case '--force': opts.force = true; break;
       case '--list': opts.list = true; break;
+      case '--stats': opts.stats = true; break;
       case '--uninstall': case '-u': opts.uninstall = true; break;
       case '--no-color': opts.noColor = true; break;
       case '-h': case '--help': opts.help = true; break;
@@ -185,10 +186,10 @@ function installClaude(ctx) {
       const r1 = run('claude', ['plugin', 'marketplace', 'add', REPO], opts.dryRun);
       const r2 = run('claude', ['plugin', 'install', 'chisle@chisle'], opts.dryRun);
       if ((r1.status || 0) === 0 && (r2.status || 0) === 0) { results.installed.push('claude'); pluginOK = true; }
-      else warn('  claude plugin install failed — falling back to standalone hooks');
+      else warn('  claude plugin install failed, falling back to standalone hooks');
     }
   } else {
-    note('  claude CLI not on PATH — wiring standalone hooks in settings.json');
+    note('  claude CLI not on PATH, wiring standalone hooks in settings.json');
   }
 
   if (!pluginOK) {
@@ -198,7 +199,7 @@ function installClaude(ctx) {
     else results.failed.push(['claude-hooks', r]);
   } else {
     note('  hooks: plugin manifest handles SessionStart + UserPromptSubmit + PostToolUse');
-    // Plugin path won — drop any standalone wiring left by an earlier run, or
+    // Plugin path won, so drop any standalone wiring left by an earlier run, or
     // both copies of every hook run on each event and the PostToolUse pair
     // dedups first-seen output against itself.
     const settingsPath = path.join(claudeDir(opts), 'settings.json');
@@ -214,7 +215,7 @@ function installClaude(ctx) {
   process.stdout.write('\n');
 }
 
-// Standalone wiring — copy hooks into <configDir>/chisle-hooks/ and merge
+// Standalone wiring: copy hooks into <configDir>/chisle-hooks/ and merge
 // settings.json. Used when the plugin path is unavailable.
 function installClaudeHooks(ctx) {
   const { opts, warn, note } = ctx;
@@ -268,7 +269,7 @@ function installClaudeHooks(ctx) {
   } else {
     const existing = typeof settings.statusLine === 'string' ? settings.statusLine : (settings.statusLine.command || '');
     if (existing.includes('chisle-statusline')) process.stdout.write('  statusline badge already configured.\n');
-    else process.stdout.write('  NOTE: existing statusline detected — CHISLE badge NOT added (see docs/install-windows.md).\n');
+    else process.stdout.write('  NOTE: existing statusline detected, CHISLE badge NOT added (see docs/install-windows.md).\n');
   }
 
   SETTINGS.validateHookFields(settings);
@@ -443,20 +444,21 @@ function uninstall(ctx) {
   if (!opts.only.length || opts.only.some(id => PROVIDERS.find(p => p.id === id).scope === 'project')) {
     note('');
     note('Project-scoped rule files (.cursor/, .windsurf/, .clinerules/, .kiro/, .github/copilot-instructions.md)');
-    note('live in your project repos — remove them per-project with git if you added them there.');
+    note('live in your project repos, so remove them per-project with git if you added them there.');
   }
   say(touched ? c.green(`\nUninstalled. ${touched} item(s) cleaned.`) : c.yellow('\nNothing to uninstall.'));
 }
 
 // ── help / banner ───────────────────────────────────────────────────────────
 function printHelp(c) {
-  process.stdout.write(`${c.orange('chisle')} — maximum-efficiency dev mode installer
+  process.stdout.write(`${c.orange('chisle')}: maximum-efficiency dev mode installer
 
 Usage:
   npx chisle [flags]
 
 Flags:
   --list           Detect agents and print them; install nothing
+  --stats          Print tool-output savings recorded so far; change nothing
   --only <id>      Limit install/uninstall to one agent (repeatable)
   --dry-run        Print actions, change nothing
   --force          Reinstall / overwrite even if already present
@@ -471,11 +473,51 @@ Examples:
   npx chisle                  # auto-detect + install
   npx chisle --only claude    # just Claude Code
   npx chisle --dry-run        # preview
+  npx chisle --stats          # what the compressor has saved
 `);
 }
 
+// ── stats ───────────────────────────────────────────────────────────────────
+// Reads the compressor's ledger. Input axis only, and deliberately so: chars
+// elided have a real baseline (we know exactly what was cut), while the output
+// axis has none, since there is no way to know what the model would have written
+// without the ruleset, which is what the benchmark arms are for. A counter that
+// blended the two would be inventing the interesting half.
+function printStats(c, opts) {
+  const dir = claudeDir(opts);
+  const p = path.join(dir, '.chisle-compress-stats.json');
+  process.stdout.write(c.orange('chisle') + ': tool-output savings\n\n');
+
+  let stats = null;
+  try {
+    if (!fs.lstatSync(p).isSymbolicLink()) {
+      const parsed = JSON.parse(fs.readFileSync(p, 'utf8'));
+      if (parsed && Number.isFinite(parsed.savedChars) && Number.isFinite(parsed.events)) stats = parsed;
+    }
+  } catch (e) {}
+
+  if (!stats || stats.events === 0) {
+    process.stdout.write('  no compression recorded yet\n\n');
+    process.stdout.write(c.dim(`  ledger: ${p}\n`));
+    process.stdout.write(c.dim('  it fills as the compressor elides oversized tool output.\n'));
+    process.stdout.write(c.dim("  nothing there after real use? check `npx chisle --list` and that Chisle is active.\n"));
+    return;
+  }
+
+  const chars = stats.savedChars;
+  const tokens = Math.floor(chars / 4);
+  const per = Math.round(chars / stats.events);
+  const fmt = (n) => n.toLocaleString('en-US');
+  process.stdout.write(`  saved:      ${c.green(fmt(chars) + ' chars')}  (~${fmt(tokens)} tokens)\n`);
+  process.stdout.write(`  outputs:    ${fmt(stats.events)} compressed, ${fmt(per)} chars each on average\n\n`);
+  process.stdout.write(c.dim('  A floor, not an estimate: every saved byte also stops being re-sent\n'));
+  process.stdout.write(c.dim('  on every later request in that session.\n\n'));
+  process.stdout.write(c.dim(`  ledger: ${p}\n`));
+  process.stdout.write(c.dim('  per-transcript detail: node benchmarks/replay-compress.js (in a repo clone)\n'));
+}
+
 function printList(c) {
-  process.stdout.write(c.orange('chisle') + ' — detected agents:\n\n');
+  process.stdout.write(c.orange('chisle') + ': detected agents:\n\n');
   for (const p of PROVIDERS) {
     const found = detectMatch(p.detect);
     const mark = found ? c.green('✓') : c.dim('·');
@@ -492,6 +534,7 @@ function main() {
 
   if (opts.help) return printHelp(c);
   if (opts.list) return printList(c);
+  if (opts.stats) return printStats(c, opts);
 
   const results = { detected: 0, installed: [], skipped: [], failed: [] };
   const say = (s) => process.stdout.write(s + '\n');
@@ -502,7 +545,7 @@ function main() {
   if (opts.uninstall) return uninstall(ctx);
 
   say(c.orange('╭─ Chisle installer ─╮'));
-  say(c.dim(opts.dryRun ? '  (dry run — nothing will change)' : '  maximum signal, minimum noise'));
+  say(c.dim(opts.dryRun ? '  (dry run, nothing will change)' : '  maximum signal, minimum noise'));
   say('');
 
   const targets = PROVIDERS.filter(p => opts.only.length ? opts.only.includes(p.id) : detectMatch(p.detect));

package/commands/chisle-audit.toml

@@ -1,4 +1,4 @@
-# chisle-audit — one-shot efficiency audit across both axes
+# chisle-audit: one-shot efficiency audit across both axes
 [command]
 name = "chisle-audit"
 description = "Audit a diff, file, or repo for BOTH over-engineered code and bloated prose/docs. Ranked report, biggest cut first. Changes nothing."

package/commands/chisle-help.toml

@@ -1,4 +1,4 @@
-# chisle-help — quick reference card
+# chisle-help: quick reference card
 [command]
 name = "chisle-help"
 description = "Show Chisle quick reference: modes, levels, commands."

package/commands/chisle-review.toml

@@ -1,4 +1,4 @@
-# chisle-review — review a diff/file for over-engineering
+# chisle-review: review a diff/file for over-engineering
 [command]
 name = "chisle-review"
 description = "Review the current diff or a file for bloat, speculative abstractions, and reinvented stdlib."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Maximum-efficiency dev mode for AI coding agents. Zero-fluff prose, YAGNI-first code, and safe tool-output compression.",
   "keywords": [
     "claude-code",

package/rules/chisle-activate.md

@@ -1,4 +1,4 @@
-# Chisle — Always-On Rules
+# Chisle: Always-On Rules
 
 When chisle mode is active, apply both dimensions simultaneously:
 

package/skills/chisle/SKILL.md

@@ -16,7 +16,7 @@ Maximum signal. Minimum noise. Write less. Ship less. Mean more.
 ## Persistence
 
 ACTIVE EVERY RESPONSE. No drift back to verbose over-building. Still active if unsure.
-Off only: "stop chisle" / "normal mode" / `/chisle off`. One mode — no levels to pick.
+Off only: "stop chisle" / "normal mode" / `/chisle off`. One mode, no levels to pick.
 
 ## Prose: Maximum Signal Per Token
 
@@ -27,7 +27,7 @@ causality with arrows (X → Y) instead of "because/therefore/which means". Stan
 acronyms fine (DB/API/HTTP); never invent new ones. Technical terms, code, API names,
 error strings: exact, verbatim, never abbreviated. Code blocks unchanged.
 
-**Terse ≠ incomplete — this is the whole game.** Keep every decisive fact: the fix, the
+**Terse ≠ incomplete. This is the whole game.** Keep every decisive fact: the fix, the
 gotcha, the caveat, the why. Cut the words *around* the facts, never the facts. A 3-word
 answer that omits the fix loses to a 12-word one that keeps it. This is the edge: say
 everything that matters, in the fewest tokens that still say it.
@@ -39,7 +39,7 @@ tables/emoji the question didn't ask for. Two tight paragraphs beat five headed
 (measured: one such answer ran 173% of a no-tool baseline). Name the two or three
 decisive tradeoffs in prose, give the verdict, stop.
 
-No self-reference. Never announce the mode. Output only — no normal answer plus recap.
+No self-reference. Never announce the mode. Output only, no normal answer plus recap.
 
 Not: "Sure! I'd be happy to help. The issue you're experiencing is likely caused by..."
 Yes: "Bug in auth middleware. Expiry check uses `<`, needs `<=`. Fix:"
@@ -51,7 +51,7 @@ Yes: "Deadlock: two threads each hold a lock the other needs → both wait forev
 Stop at first rung that holds:
 
 1. **Does this need to exist at all?** Speculative need = skip it, say so in one line. (YAGNI)
-2. **Already in this codebase?** Reuse it. Look before writing — re-implementing what's nearby is most common slop.
+2. **Already in this codebase?** Reuse it. Look before writing; re-implementing what's nearby is most common slop.
 3. **Stdlib does it?** Use it.
 4. **Native platform feature covers it?** `<input type="date">` over picker lib, CSS over JS, DB constraint over app code.
 5. **Already-installed dependency solves it?** Use it. Never add new dep for what few lines can do.
@@ -62,6 +62,14 @@ Ladder runs *after* understanding problem, not instead. Read fully, then be lazy
 
 **Bug fix = root cause, not symptom.** Grep every caller before editing. One guard in shared function beats guard in every caller.
 
+## Thinking Is Billed Too
+
+Reasoning tokens cost the same as written ones. Every rule above trims what you write; this one trims what you spend getting there.
+
+The ladder is a stopping rule, not a checklist to walk aloud. Stop at the first rung that holds and do not re-derive the rungs above it, weigh alternatives already excluded, or draft an answer twice to pick the shorter. Obvious fix → give it. Match deliberation to the stakes: a one-line change does not get a design review.
+
+This is the ladder's own exception, unchanged: never think less about *understanding* the problem. Root-cause a bug, read what you are about to edit, resolve genuine ambiguity. Depth where the problem is actually hard, nowhere else.
+
 ## Code Rules
 
 - No unrequested abstractions: no interface with one implementation, no factory for one product.
@@ -70,7 +78,7 @@ Ladder runs *after* understanding problem, not instead. Read fully, then be lazy
 - Fewest files possible. Shortest working diff wins.
 - Complex request? Ship lazy version, question it. "Did X; Y covers it. Need full X? Say so."
 - Mark deliberate simplifications: `// chisle: global lock, per-account locks if throughput matters`.
-- Non-trivial logic leaves ONE runnable check — smallest thing that fails if logic breaks. No frameworks unless asked.
+- Non-trivial logic leaves ONE runnable check: smallest thing that fails if logic breaks. No frameworks unless asked.
 
 ## Context Diet: Read Less Into the Window
 
@@ -81,7 +89,7 @@ Tool output you pull in is billed on every later turn. Fetch the slice, not the
 - Never re-read a file already in context unless it changed.
 - Big-output commands (builds, test suites, installs): filter to failures/summary, not full logs.
 
-Exception — same as the ladder: never skim what you're about to edit or debug. Diet trims *transport*, never *understanding*.
+Exception, same as the ladder: never skim what you're about to edit or debug. Diet trims *transport*, never *understanding*.
 
 ## Output Format
 
@@ -92,13 +100,13 @@ No essays. No feature tours. No design notes. Explanation longer than code → d
 
 ## What it sounds like
 
-Example — "Why does this React component re-render?"
+Example: "Why does this React component re-render?"
 > New object ref each render. Inline object prop = new ref = re-render. `useMemo`.
 
-Example — "Add a cache for API responses."
-> `@lru_cache(maxsize=1000)` on the fetch fn. Skipped a custom cache class — add one when `lru_cache` measurably falls short.
+Example: "Add a cache for API responses."
+> `@lru_cache(maxsize=1000)` on the fetch fn. Skipped a custom cache class; add one when `lru_cache` measurably falls short.
 
-Example — "Summarize the tradeoffs between REST and GraphQL."
+Example: "Summarize the tradeoffs between REST and GraphQL."
 > GraphQL: one round trip, client picks fields → fewer over-fetches, harder caching + N+1 risk. REST: dumb caching that works, more round trips. New API, unknown clients → REST until a client actually needs field selection.
 
 ## Auto-Clarity
@@ -112,7 +120,7 @@ Drop compression when:
 
 Resume after clear part done.
 
-Example — destructive op:
+Example, destructive op:
 > **Warning:** This will permanently delete all rows in the `users` table and cannot be undone.
 > ```sql
 > DROP TABLE users;

package/skills/chisle-audit/SKILL.md

@@ -5,7 +5,7 @@ description: >
   once: over-engineered code (reinvented stdlib, needless abstractions,
   speculative config) AND bloated prose (verbose comments, padded docstrings,
   redundant doc sections). Neither a pure code-minimizer nor a pure prose
-  compressor does both in one pass — that's the point. Ranked report, biggest
+  compressor does both in one pass. That's the point. Ranked report, biggest
   saving first; changes nothing. Use when the user says "chisle audit", "/chisle-audit",
   "audit this for bloat", "what can I cut", "review this PR for over-engineering
   and verbosity".
@@ -14,7 +14,7 @@ description: >
 # Chisle Audit
 
 Scan the target (a diff, a file, or the repo tree) and report what to cut, on
-both axes. One-shot. Read-only — never edit, never write a flag, never apply fixes.
+both axes. One-shot. Read-only: never edit, never write a flag, never apply fixes.
 
 ## Scope
 
@@ -32,7 +32,7 @@ both axes. One-shot. Read-only — never edit, never write a flag, never apply f
 - Speculative "for later" scaffolding with no current caller
 - Verbose code where a native platform feature (CSS, DB constraint, `<input type>`) does it
 
-**Prose (the compression axis) — the half a code-only auditor misses:**
+**Prose (the compression axis), the half a code-only auditor misses:**
 - Comments that restate the code (`i += 1  // increment i`)
 - Docstrings/READMEs padded with filler, hedging, ceremony, or duplicated content
 - Multi-paragraph explanations where one tight sentence carries the meaning
@@ -60,6 +60,6 @@ N findings: X code, Y prose. Est. removable: ~A lines code, ~B lines prose.
 Biggest win: <the single highest-impact cut>.
 ```
 
-Be honest about uncertainty — mark a finding `(check)` if cutting it might lose
+Be honest about uncertainty: mark a finding `(check)` if cutting it might lose
 behavior you can't verify from the snippet. Lean toward fewer, high-confidence
 findings over a long speculative list.

package/skills/chisle-help/SKILL.md

@@ -6,7 +6,7 @@ description: >
   use chisle", "what chisle commands", or invokes /chisle-help.
 ---
 
-# Chisle — quick reference
+# Chisle quick reference
 
 **What it is:** maximum-efficiency dev mode. Zero-fluff prose + YAGNI-first code, always on together.
 
@@ -27,7 +27,7 @@ YAGNI → reuse → stdlib → native → installed dep → one line → minimum
 
 ## Statusline
 
-`[CHISLE]` — shown while active. Configure via
+`[CHISLE]` is shown while active. Configure via
 `hooks/chisle-statusline.sh` (or `.ps1` on Windows).
 
 ## Never minimal about