chisle 2.0.0 → 3.1.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "1.2.2",
+  "version": "3.1.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

@@ -33,4 +33,4 @@ 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.
 
-Levels: lite / full (default) / ultra. Deactivate: "stop chisle" / "normal mode".
+Always on once installed. Deactivate: "stop chisle" / "normal mode".

package/.cursor/rules/chisle.mdc

@@ -38,4 +38,4 @@ 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.
 
-Levels: lite / full (default) / ultra. Deactivate: "stop chisle" / "normal mode".
+Always on once installed. Deactivate: "stop chisle" / "normal mode".

package/.github/copilot-instructions.md

@@ -33,4 +33,4 @@ 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.
 
-Levels: lite / full (default) / ultra. Deactivate: "stop chisle" / "normal mode".
+Always on once installed. Deactivate: "stop chisle" / "normal mode".

package/.kiro/steering/chisle.md

@@ -37,4 +37,4 @@ 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.
 
-Levels: lite / full (default) / ultra. Deactivate: "stop chisle" / "normal mode".
+Always on once installed. Deactivate: "stop chisle" / "normal mode".

package/.windsurf/rules/chisle.md

@@ -37,4 +37,4 @@ 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.
 
-Levels: lite / full (default) / ultra. Deactivate: "stop chisle" / "normal mode".
+Always on once installed. Deactivate: "stop chisle" / "normal mode".

package/AGENTS.md

@@ -41,6 +41,6 @@ edit — diet trims transport, not understanding.
 Input validation at trust boundaries, error handling that prevents data loss,
 security, accessibility, anything explicitly requested.
 
-## Levels
+## Switching off
 
-`lite` · `full` (default) · `ultra`. Deactivate: "stop chisle" / "normal mode".
+Always on once installed. Deactivate: "stop chisle" / "normal mode".

package/README.md

@@ -1,16 +1,20 @@
 <p align="center">
-  <img src="assets/logo.svg" width="120" alt="Chisle">
+  <img src="assets/logo.png" width="120" alt="Chisle">
 </p>
 
-<h1 align="center">🧨 Chisle</h1>
+<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>
 </p>
 
+<p align="center">
+  <em>The only tool in this class that publishes the runs where it lost.</em>
+</p>
+
 <p align="center">
   <a href="https://www.npmjs.com/package/chisle"><img src="https://img.shields.io/npm/v/chisle?style=flat-square&color=d78a3c" alt="npm version"></a>
-  <img src="https://img.shields.io/badge/works%20with-8%20agents-d78a3c?style=flat-square" alt="Works with 8 agents">
+  <img src="https://img.shields.io/badge/works%20with-9%20agents-d78a3c?style=flat-square" alt="Works with 9 agents">
   <a href="https://github.com/JayPokale/Chisle/actions/workflows/test.yml"><img src="https://img.shields.io/github/actions/workflow/status/JayPokale/Chisle/test.yml?style=flat-square&label=CI" alt="CI"></a>
   <img src="https://img.shields.io/badge/deps-0-2da44e?style=flat-square" alt="Zero deps">
   <img src="https://img.shields.io/badge/license-MIT-d78a3c?style=flat-square" alt="MIT">
@@ -18,7 +22,7 @@
 </p>
 
 <p align="center">
-  <strong>Half the output bill on 20 measured tasks &middot; compresses what the model writes AND reads &middot; one command</strong>
+  <strong>44% of a bare model on coding work &middot; 41% on the long ones &middot; one command</strong>
 </p>
 
 <p align="center">
@@ -75,7 +79,42 @@ 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 | `PostToolUse` hook — 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:
+
+```mermaid
+flowchart LR
+    subgraph S["Session start"]
+        H1["Ruleset injection<br/>once per active session"]
+    end
+    subgraph T["Every turn"]
+        H2["Mode tracking<br/>Claude + Pi"]
+    end
+    subgraph L["Every tool call"]
+        H3["PostToolUse / tool_result<br/>scrub → elide → dedup"]
+    end
+
+    H1 --> M(["Model"])
+    H2 --> M
+    M -->|writes| O["Output:<br/>terser prose,<br/>YAGNI-first code"]
+    M -->|calls a tool| TOOL[["Bash / grep / web / extension tools"]]
+    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
+
+    style M fill:#1f2937,stroke:#d78a3c,color:#e6edf3
+    style O fill:#14532d,stroke:#2da44e,color:#e6edf3
+    style H3 fill:#1f2937,stroke:#2da44e,color:#e6edf3
+    style RE fill:#3f1d1d,stroke:#cf3b3b,color:#e6edf3
+```
+
+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).">
+</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)
 
@@ -83,7 +122,7 @@ Every "be concise" tool has a worst day — the day it makes the model write *mo
 
 ## Install
 
-One command. Auto-detects your agents (Claude Code, Cursor, Windsurf, Cline, Kiro, Codex, Gemini, Copilot) and wires each one. `--uninstall` puts everything back.
+One command. Auto-detects your agents (Claude Code, Pi, Cursor, Windsurf, Cline, Kiro, Codex, Gemini, Copilot) and wires each one. `--uninstall` puts everything back.
 
 ```bash
 npx chisle
@@ -99,9 +138,27 @@ curl -fsSL https://raw.githubusercontent.com/JayPokale/Chisle/main/install.sh |
 irm https://raw.githubusercontent.com/JayPokale/Chisle/main/install.ps1 | iex
 ```
 
-Preview first with `npx chisle --dry-run`, scope with `--only claude`, see everything with `npx chisle --help`. Remove with `npx chisle --uninstall`.
+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.
+
+### Upgrading
+
+Same command as installing — it is idempotent and overwrites the previous copy:
+
+```bash
+npx chisle              # npm / standalone install
+claude plugin update chisle@chisle   # Claude Code plugin install
+```
 
-**Requirements:** Node ≥18 (installer / `npx`) · Claude Code for live `/chisle` switching and input-side compression — the always-on ruleset still ships to every other agent.
+Chisle checks npm on session start and mentions it once when a **major** version
+is out (cached 3 days, `CHISLE_UPDATE_CHECK=0` to silence). Minor and patch
+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.
 
 ### Claude Code plugin (marketplace)
 
@@ -110,17 +167,26 @@ claude plugin marketplace add JayPokale/Chisle   # register the marketplace
 claude plugin install chisle@chisle              # enable the plugin
 ```
 
+### Pi package
+
+```bash
+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.
+
 ### See what it would do, before it does it
 
 ```bash
 npx chisle --dry-run    # prints every file it would touch, changes nothing
 ```
 
-Want the savings measured on your own work rather than ours? Clone the repo and replay the compressor over your existing Claude Code transcripts — it reads them locally, writes nothing, and reports the tokens the input-side 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
-node benchmarks/replay-compress.js
+node benchmarks/replay-compress.js       # Claude Code
+node benchmarks/replay-compress.js pi    # Pi; marginal over Pi's native truncation
 ```
 
 ---
@@ -147,7 +213,22 @@ Chisle wins all four columns: it cut the total 20-task bill **nearly in half** w
 
 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.
 
-On coding tasks Chisle is leanest (June: 22% of baseline vs caveman 46%, ponytail 29%; July: 64% vs 84% and 160%). On pure prose caveman is a hair leaner on a good day — credit where due. And in the July run all 24 answers, every arm, **graded correct**: nobody here buys token savings with wrong answers.
+In the July run all 24 answers, every arm, **graded correct**: nobody here buys token savings with wrong answers.
+
+#### Code vs. explanation
+
+Across all 20 cells, split by what the prompt actually asks for:
+
+| | n | caveman | ponytail | **Chisle** |
+|---|--:|--:|--:|--:|
+| **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.
+
+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
 
@@ -159,6 +240,47 @@ Averages hide the interesting part, so here is every cell of the June suite —
 
 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.
 
+#### 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:
+
+<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.
+
+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.
+
+#### Size or kind? Both, and they're tangled
+
+Coding prompts average ~1129 baseline tokens against ~393 for explanation prompts, so "long" and "code" largely describe the same cells. Crossing the two separates them as far as 20 tasks allow:
+
+| | n | caveman | ponytail | **Chisle** |
+|---|--:|--:|--:|--:|
+| coding · short | 5 | **62%** | 116% | 70% |
+| coding · long | 7 | 76% | 52% | **41%** |
+| non-coding · short | 5 | 104% | 98% | **96%** |
+| non-coding · long | 3 | 103% | 111% | **77%** |
+
+<p align="center">
+  <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.
+
+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).
+
+These prompts were never designed to test this, which is the real caveat. To probe it directly:
+
+```bash
+SUITE=large bash benchmarks/run-live.sh <model> benchmarks/results/raw-large
+```
+
 #### Where each tool actually helps
 
 |  | prose | code judgment | input/context | worst-case guard | publishes failures |
@@ -170,7 +292,7 @@ Chisle is leanest on **5 of 6**. caveman takes `cache` (8% vs our 12%) — it wi
 
 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)
+### 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:
 
@@ -180,13 +302,16 @@ Measured over 171 real sessions ([receipts](benchmarks/results/2026-07-07-input-
 | **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 |
 
-Replayed over the same 171 sessions: **~61k tokens** (full) / **~103k** (ultra) 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. Replay it on your own transcripts:
+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.
+
+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.
 
 ```bash
-node benchmarks/replay-compress.js        # what it would have saved you
+node benchmarks/replay-compress.js       # Claude Code
+node benchmarks/replay-compress.js pi    # Pi
 ```
 
-Thresholds track the `/chisle` level (lite 16k / full 8k / ultra 5k chars). `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.
 
 ### Prevention — the context diet
 
@@ -196,14 +321,11 @@ The biggest context whale (whole-file `Read`s — 5.6M chars in the measured cor
 
 ## What the output sounds like
 
-**"Why React component re-render?"** (full)
+**"Why does this React component re-render?"**
 > New object ref each render. Inline object prop = new ref = re-render. `useMemo`.
 
-**"Why React component re-render?"** (ultra)
-> Inline obj prop → new ref → re-render. `useMemo`. Why inline object at all?
-
-**"Add a cache for API responses."** (ultra)
-> No cache until profiler says so. When it does: `@lru_cache`. Hand-rolled TTL cache = bug farm with hit rate.
+**"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.
 
 ---
 
@@ -211,15 +333,13 @@ The biggest context whale (whole-file `Read`s — 5.6M chars in the measured cor
 
 | Command | Effect |
 |---------|--------|
-| *(nothing)* | On automatically at `full` every session after install |
-| `/chisle` | Re-activate at default level if you'd stopped it |
-| `/chisle lite` | Tighter prose, flags the minimal alternative |
-| `/chisle full` | Full compression + YAGNI ladder enforced |
-| `/chisle ultra` | Extremist — abbreviate prose, delete before add, challenge requirements |
+| *(nothing)* | On automatically every session after install |
+| `/chisle` | Re-activate if you'd stopped it |
+| `/chisle off` | Deactivate |
 | `stop chisle` | Deactivate (ruleset *and* input-side compression) |
 | `normal mode` | Deactivate |
 
-Natural language works too: "activate chisle", "chisle mode", "chislify this". Across every level, 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 — only the noise around them compresses.
 
 ---
 
@@ -227,15 +347,31 @@ Natural language works too: "activate chisle", "chisle mode", "chislify this". A
 
 Before writing code, the agent stops at the first rung that holds:
 
+```mermaid
+flowchart TD
+    A[Request for code] --> R[Read the problem fully]
+    R --> Q1{Does this need<br/>to exist at all?}
+    Q1 -->|no| S1[Skip it. Say so in one line]
+    Q1 -->|yes| Q2{Already in<br/>this codebase?}
+    Q2 -->|yes| S2[Reuse it. Don't rewrite]
+    Q2 -->|no| Q3{Stdlib<br/>does it?}
+    Q3 -->|yes| S3[Use the stdlib]
+    Q3 -->|no| Q4{Native platform<br/>feature covers it?}
+    Q4 -->|yes| S4["CSS over JS, DB constraint<br/>over app code"]
+    Q4 -->|no| Q5{Already-installed<br/>dependency?}
+    Q5 -->|yes| S5[Use it. Never add a new dep<br/>for what a few lines do]
+    Q5 -->|no| Q6{Can it be<br/>one line?}
+    Q6 -->|yes| S6[One line]
+    Q6 -->|no| S7[The minimum code that works]
+
+    S1 & S2 & S3 & S4 & S5 & S6 & S7 --> OUT[Ship it + note what was skipped<br/>and when to add it]
+
+    style Q1 fill:#1f2937,stroke:#d78a3c,color:#e6edf3
+    style OUT fill:#14532d,stroke:#2da44e,color:#e6edf3
+    style R fill:#1f2937,stroke:#8b949e,color:#e6edf3
 ```
-1. Does this need to exist?   → no: skip it (YAGNI)
-2. Already in this codebase?  → reuse it, don't rewrite
-3. Stdlib does it?            → use it
-4. Native platform feature?   → use it
-5. Installed dependency?      → use it
-6. One line?                  → one line
-7. Only then: the minimum that works
-```
+
+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.
 
@@ -250,17 +386,17 @@ Mark deliberate simplifications so "later" doesn't quietly become "never":
 
 ## Config
 
-**On by default.** After install, CHISLE activates automatically at `full` every session — no `/chisle` needed. Change the default level, or set `off` to stay dormant until you type `/chisle`:
+**On by default.** After install, Chisle activates automatically every session — no `/chisle` needed. Set `off` to stay dormant until you type `/chisle`:
 
 ```bash
 # env var (highest priority)
-export CHISLE_DEFAULT_MODE=ultra
+export CHISLE_DEFAULT_MODE=off
 
 # config file (persists across shells)
-~/.config/chisle/config.json → { "defaultMode": "ultra" }
+~/.config/chisle/config.json → { "defaultMode": "off" }
 ```
 
-Resolution: env var → config file → `full`. Valid: `off`, `lite`, `full`, `ultra`.
+Resolution: env var → config file → `on`. Valid: `off`, `on`.
 
 ---
 
@@ -280,12 +416,14 @@ Chisle borrows the best published token-saving techniques and implements the one
 
 ## Multi-agent
 
-Primarily a Claude Code plugin, but ships to every agent with a rules/context file — Cursor, Windsurf, Cline, Kiro, Codex, Gemini, Copilot. Per-agent copies generated by `scripts/build-rules.js` (a condensed mirror of the skill — edit both, CI checks sync). See [`docs/agent-portability.md`](./docs/agent-portability.md). Input-side compression is Claude Code-only for now: no other agent exposes a post-tool output rewrite hook.
+Ships to nine agents: Claude Code and Pi get both axes, live `/chisle` toggling, and a status badge; Cursor, Windsurf, Cline, Kiro, Codex, Gemini, and Copilot get the always-on ruleset. Per-agent static copies come from `scripts/build-rules.js`; Pi uses its package extension plus the Agent Skills standard. See [`docs/agent-portability.md`](./docs/agent-portability.md).
 
 ## FAQ
 
 **Doesn't injecting a persona every turn cost tokens?**
-Yes — a one-time ruleset at session start (~1.8k tokens) plus a ~40-token reminder per turn. Output is where it pays back: coding answers shrink 40–60% (benchmarks), and output bills several × higher than input, so net is positive after the first couple of turns. On a one-line throwaway prompt the overhead can exceed the saving. The input-side hook has no such tradeoff — it only ever removes 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.
 
 **Will it golf my code into clever one-liners?**
 No. Boring over clever. Deletion beats addition; obfuscation isn't deletion.
@@ -310,7 +448,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md). Edit the skill (`skills/chisle/SKILL.md`
 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    # 59 tests: flag safety, tracker, settings merge, installer, compressor
+npm test    # 67 tests: flag safety, tracker, settings merge, installer, compressor
 ```
 
 ## License

package/bin/install.js

@@ -4,6 +4,7 @@
 // Detects the AI coding agents on this machine and installs Chisle for each:
 //   - Claude Code  → plugin (marketplace add + install), fallback to standalone
 //                    hooks + settings.json merge + statusline badge
+//   - Pi           → Pi package (extension + skill)
 //   - Gemini CLI   → gemini extensions install
 //   - Codex        → fenced ruleset appended to ~/.codex/AGENTS.md
 //   - Cursor/Windsurf/Cline/Kiro/Copilot → project rule file dropped into CWD
@@ -39,6 +40,7 @@ const REPO_ROOT = path.resolve(__dirname, '..');
 //        (that's how Cursor/Cline/Copilot rules actually work).
 const PROVIDERS = [
   { id: 'claude',   label: 'Claude Code',   scope: 'global',  detect: 'cmd:claude' },
+  { id: 'pi',       label: 'Pi',            scope: 'global',  detect: 'cmd:pi' },
   { id: 'gemini',   label: 'Gemini CLI',    scope: 'global',  detect: 'cmd:gemini' },
   { id: 'codex',    label: 'Codex CLI',     scope: 'global',  detect: 'cmd:codex||dir:~/.codex' },
   { id: 'cursor',   label: 'Cursor',        scope: 'project', detect: 'cmd:cursor||dir:~/.cursor',
@@ -196,6 +198,18 @@ 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
+    // 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');
+    const settings = SETTINGS.readSettings(settingsPath);
+    if (settings && SETTINGS.removeHooks(settings, 'chisle-') > 0) {
+      if (!opts.dryRun) {
+        SETTINGS.validateHookFields(settings);
+        SETTINGS.writeSettings(settingsPath, settings);
+      }
+      note('  removed superseded standalone hook entries from settings.json');
+    }
   }
   process.stdout.write('\n');
 }
@@ -209,7 +223,7 @@ function installClaudeHooks(ctx) {
   const hooksDst = path.join(cfg, 'chisle-hooks');
   const settingsPath = path.join(cfg, 'settings.json');
   const HOOK_FILES = ['package.json', 'chisle-config.js', 'chisle-activate.js',
-                      'chisle-mode-tracker.js', 'chisle-compress-output.js',
+                      'chisle-mode.js', 'chisle-mode-tracker.js', 'chisle-compress-output.js',
                       'chisle-statusline.sh', 'chisle-statusline.ps1'];
 
   if (opts.dryRun) {
@@ -263,6 +277,30 @@ function installClaudeHooks(ctx) {
   return 'ok';
 }
 
+// ── Pi ──────────────────────────────────────────────────────────────────────
+function piSources(output) {
+  return String(output || '').split('\n').map(line => line.trim())
+    .filter(line => /^npm:chisle(?:@|$)/i.test(line) || /^git:.*github\.com\/JayPokale\/Chisle(?:@|$)/i.test(line))
+    .map(source => source.replace(/@[^/@]+$/, ''));
+}
+
+function installPi(ctx) {
+  const { say, note, opts, results } = ctx;
+  results.detected++;
+  say('→ Pi detected');
+  if (!opts.force) {
+    const installed = piSources(capture('pi', ['list']).stdout);
+    if (installed.length) {
+      note('  chisle package already installed (use --force)');
+      results.skipped.push(['pi', 'already installed']); process.stdout.write('\n'); return;
+    }
+  }
+  const r = run('pi', ['install', 'npm:chisle'], opts.dryRun);
+  if ((r.status || 0) === 0) results.installed.push('pi');
+  else results.failed.push(['pi', 'pi package install failed']);
+  process.stdout.write('\n');
+}
+
 // ── Gemini ──────────────────────────────────────────────────────────────────
 function installGemini(ctx) {
   const { say, note, opts, results } = ctx;
@@ -347,53 +385,66 @@ function uninstall(ctx) {
   say(c.orange('Chisle uninstall'));
   let touched = 0;
 
-  // Claude plugin
-  if (hasCmd('claude') && !opts.dryRun) {
-    const r = capture('claude', ['plugin', 'list']);
-    if (r.status === 0 && /chisle/i.test(r.stdout || '')) {
-      run('claude', ['plugin', 'uninstall', 'chisle@chisle'], opts.dryRun); touched++;
+  const wants = id => !opts.only.length || opts.only.includes(id);
+
+  if (wants('claude')) {
+    // Claude plugin
+    if (hasCmd('claude') && !opts.dryRun) {
+      const r = capture('claude', ['plugin', 'list']);
+      if (r.status === 0 && /chisle/i.test(r.stdout || '')) {
+        run('claude', ['plugin', 'uninstall', 'chisle@chisle'], opts.dryRun); touched++;
+      }
     }
-  }
 
-  // Claude standalone hooks + statusline
-  const cfg = claudeDir(opts);
-  const settingsPath = path.join(cfg, 'settings.json');
-  const settings = SETTINGS.readSettings(settingsPath);
-  if (settings) {
-    const removed = SETTINGS.removeHooks(settings, 'chisle-');
-    let slRemoved = false;
-    if (settings.statusLine && typeof settings.statusLine.command === 'string'
-        && settings.statusLine.command.includes('chisle-statusline')) { delete settings.statusLine; slRemoved = true; }
-    if (removed > 0 || slRemoved) {
-      if (!opts.dryRun) { SETTINGS.validateHookFields(settings); SETTINGS.writeSettings(settingsPath, settings); }
-      note(`  removed ${removed} hook entr${removed === 1 ? 'y' : 'ies'}${slRemoved ? ' + statusline' : ''} from settings.json`);
-      touched++;
+    // Claude standalone hooks + statusline
+    const cfg = claudeDir(opts);
+    const settingsPath = path.join(cfg, 'settings.json');
+    const settings = SETTINGS.readSettings(settingsPath);
+    if (settings) {
+      const removed = SETTINGS.removeHooks(settings, 'chisle-');
+      let slRemoved = false;
+      if (settings.statusLine && typeof settings.statusLine.command === 'string'
+          && settings.statusLine.command.includes('chisle-statusline')) { delete settings.statusLine; slRemoved = true; }
+      if (removed > 0 || slRemoved) {
+        if (!opts.dryRun) { SETTINGS.validateHookFields(settings); SETTINGS.writeSettings(settingsPath, settings); }
+        note(`  removed ${removed} hook entr${removed === 1 ? 'y' : 'ies'}${slRemoved ? ' + statusline' : ''} from settings.json`);
+        touched++;
+      }
+    }
+    const hooksDst = path.join(cfg, 'chisle-hooks');
+    if (fs.existsSync(hooksDst)) { if (!opts.dryRun) fs.rmSync(hooksDst, { recursive: true, force: true }); note(`  removed ${hooksDst}`); touched++; }
+
+    for (const f of ['.chisle-active', '.chisle-session-turns', '.chisle-statusline-suffix',
+                     '.chisle-compress-stats.json', '.chisle-compress-last.json', '.chisle-update-check.json']) {
+      const p = path.join(cfg, f);
+      if (fs.existsSync(p)) { if (!opts.dryRun) { try { fs.unlinkSync(p); } catch (_) {} } note(`  removed ${p}`); touched++; }
     }
   }
-  const hooksDst = path.join(cfg, 'chisle-hooks');
-  if (fs.existsSync(hooksDst)) { if (!opts.dryRun) fs.rmSync(hooksDst, { recursive: true, force: true }); note(`  removed ${hooksDst}`); touched++; }
 
-  // Flag files
-  for (const f of ['.chisle-active', '.chisle-session-turns', '.chisle-statusline-suffix',
-                   '.chisle-compress-stats.json', '.chisle-compress-last.json', '.chisle-update-check.json']) {
-    const p = path.join(cfg, f);
-    if (fs.existsSync(p)) { if (!opts.dryRun) { try { fs.unlinkSync(p); } catch (_) {} } note(`  removed ${p}`); touched++; }
+  if (wants('pi') && hasCmd('pi')) {
+    const sources = piSources(capture('pi', ['list']).stdout);
+    for (const source of sources) {
+      if ((run('pi', ['remove', source], opts.dryRun).status || 0) === 0) touched++;
+    }
   }
 
-  // Codex fenced block
-  const codexMd = path.join(os.homedir(), '.codex', 'AGENTS.md');
-  if (fs.existsSync(codexMd)) {
-    const txt = fs.readFileSync(codexMd, 'utf8');
-    if (txt.includes(FENCE_BEGIN)) {
-      const stripped = txt.replace(new RegExp(`\\n?${FENCE_BEGIN}[\\s\\S]*?${FENCE_END}\\n?`), '\n').replace(/\n{3,}/g, '\n\n');
-      if (!opts.dryRun) fs.writeFileSync(codexMd, stripped, { mode: 0o644 });
-      note(`  removed chisle block from ${codexMd}`); touched++;
+  if (wants('codex')) {
+    const codexMd = path.join(os.homedir(), '.codex', 'AGENTS.md');
+    if (fs.existsSync(codexMd)) {
+      const txt = fs.readFileSync(codexMd, 'utf8');
+      if (txt.includes(FENCE_BEGIN)) {
+        const stripped = txt.replace(new RegExp(`\\n?${FENCE_BEGIN}[\\s\\S]*?${FENCE_END}\\n?`), '\n').replace(/\n{3,}/g, '\n\n');
+        if (!opts.dryRun) fs.writeFileSync(codexMd, stripped, { mode: 0o644 });
+        note(`  removed chisle block from ${codexMd}`); touched++;
+      }
     }
   }
 
-  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.');
+  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.');
+  }
   say(touched ? c.green(`\nUninstalled. ${touched} item(s) cleaned.`) : c.yellow('\nNothing to uninstall.'));
 }
 
@@ -406,7 +457,7 @@ Usage:
 
 Flags:
   --list           Detect agents and print them; install nothing
-  --only <id>      Install only for one agent (repeatable)
+  --only <id>      Limit install/uninstall to one agent (repeatable)
   --dry-run        Print actions, change nothing
   --force          Reinstall / overwrite even if already present
   --uninstall, -u  Remove what chisle installed
@@ -463,6 +514,7 @@ function main() {
 
   for (const p of targets) {
     if (p.id === 'claude') installClaude(ctx);
+    else if (p.id === 'pi') installPi(ctx);
     else if (p.id === 'gemini') installGemini(ctx);
     else if (p.id === 'codex') installCodex(ctx);
     else installProjectRule(ctx, p);
@@ -476,7 +528,7 @@ function main() {
   if (results.failed.length)    say(c.red(`  failed:    ${results.failed.map(s => s[0] + ' (' + s[1] + ')').join(', ')}`));
   say('');
   if (!opts.dryRun && results.installed.length) {
-    say(c.orange('Done.') + ' Restart your agent. Type ' + c.orange('/chisle') + ' (Claude Code) or just start coding.');
+    say(c.orange('Done.') + ' Restart your agent. Type ' + c.orange('/chisle') + ' in Claude Code or Pi, or just start coding.');
     note('If Chisle earns its keep, a star helps others find it: https://github.com/JayPokale/Chisle');
   }
   process.exit(results.failed.length ? 1 : 0);