chisle 2.0.0 → 3.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "1.2.2",
+  "version": "3.0.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,13 +1,17 @@
 <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">
@@ -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">
@@ -77,6 +81,41 @@ Most efficiency tools compress one thing. Chisle compresses **three**:
 | **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 |
 
+Where each one attaches to a session:
+
+```mermaid
+flowchart LR
+    subgraph S["Session start"]
+        H1["SessionStart hook<br/>~1.6k tokens, new sessions only"]
+    end
+    subgraph T["Every turn"]
+        H2["UserPromptSubmit hook<br/>~50-token reminder"]
+    end
+    subgraph L["Every tool call"]
+        H3["PostToolUse hook<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 / WebFetch / mcp__*"]]
+    TOOL -->|raw output| H3
+    H3 -->|"compressed, rebuilt into<br/>the tool's own shape"| M
+
+    RE["Read / Edit"] -.->|"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` and `Edit` 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)
 
 ---
@@ -101,7 +140,25 @@ 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`.
 
-**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.
+**Requirements:** Node ≥18 (installer / `npx`) · Claude Code 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
+```
+
+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)
 
@@ -147,7 +204,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 +231,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 |
@@ -180,13 +293,13 @@ 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 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. Replay it on your own transcripts:
 
 ```bash
 node benchmarks/replay-compress.js        # what it would have saved you
 ```
 
-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 +309,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 +321,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 +335,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 +374,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`.
 
 ---
 
@@ -285,7 +409,9 @@ Primarily a Claude Code plugin, but ships to every agent with a rules/context fi
 ## 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.
+Yes — a ruleset at session start (~1.6k tokens) plus a ~50-token reminder per turn. Output is where it pays back: coding answers shrink 40–60% (benchmarks), and output bills several × higher than input.
+
+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 +436,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/commands/chisle.toml

@@ -1,8 +1,7 @@
 # chisle slash command
 # Maximum-efficiency dev mode
-# Usage: /chisle [lite|full|ultra]
+# Usage: /chisle  ·  /chisle off
 
 [command]
 name = "chisle"
-description = "Activate chisle mode: zero-fluff prose + YAGNI ladder code decisions. Levels: lite, full (default), ultra."
-argument-hint = "[lite|full|ultra]"
+description = "Activate chisle: zero-fluff prose + YAGNI ladder code decisions. /chisle off to stop."

package/hooks/chisle-activate.js

@@ -3,13 +3,13 @@
 //
 // 1. Writes flag at $CLAUDE_CONFIG_DIR/.chisle-active
 // 2. Resets session turn counter
-// 3. Emits chisle ruleset (filtered to active level) as system context
+// 3. Emits the chisle ruleset as system context
 // 4. Nudges user to configure statusline if missing
 // 5. Major-version update notice (majors only, cached, fail-silent)
 
 const fs = require('fs');
 const path = require('path');
-const { getDefaultMode, getClaudeDir, safeWriteFlag } = require('./chisle-config');
+const { getDefaultMode, getClaudeDir, safeWriteFlag, legacySetting } = require('./chisle-config');
 
 // ── Update-notice helpers (pure — tested directly) ─────────────────────────
 // Minor/patch releases stay quiet: a nudge per major is signal, more is spam.
@@ -55,8 +55,16 @@ async function latestVersion(cachePath) {
   } catch (e) { return null; }
 }
 
+// SessionStart fires on startup, resume, clear and compact. Only a genuinely
+// new session needs the whole ruleset: on the other three the conversation
+// already carries it, and the UserPromptSubmit reminder re-states the active
+// behaviour every turn anyway. Re-sending ~1.6k tokens each time was the bulk
+// of the plugin's own overhead and piled standing instructions on top of what
+// the user actually asked for. Measured and reported by @enc0ded (#2).
+const FULL_INJECT_SOURCES = new Set(['startup']);
+
 // ── Hook body ───────────────────────────────────────────────────────────────
-function run() {
+function run(source) {
   const claudeDir = getClaudeDir();
   const flagPath = path.join(claudeDir, '.chisle-active');
   const settingsPath = path.join(claudeDir, 'settings.json');
@@ -72,8 +80,17 @@ function run() {
   // 1. Write flag
   safeWriteFlag(flagPath, mode);
 
-  // 2. Read SKILL.md — single source of truth for behavior
-  const modeLabel = mode;
+  // 2. Resumed/cleared/compacted session: reactivate, don't re-teach.
+  if (!FULL_INJECT_SOURCES.has(source)) {
+    process.stdout.write(
+      'CHISLE ACTIVE (resumed). ' +
+      'Ruleset already in context; see the chisle skill if it is not.'
+    );
+    return;
+  }
+
+  // 3. Read SKILL.md — single source of truth for behaviour. No level
+  // filtering any more: there is one mode, so the whole body ships.
   let skillContent = '';
   try {
     skillContent = fs.readFileSync(
@@ -84,31 +101,14 @@ function run() {
   let output;
 
   if (skillContent) {
-    const body = skillContent.replace(/^---[\s\S]*?---\s*/, '');
-
-    const filtered = body.split('\n').reduce((acc, line) => {
-      const tableRowMatch = line.match(/^\|\s*\*\*(\S+?)\*\*\s*\|/);
-      if (tableRowMatch) {
-        if (tableRowMatch[1] === modeLabel) acc.push(line);
-        return acc;
-      }
-      const exampleMatch = line.match(/^- (\S+?):\s/);
-      if (exampleMatch) {
-        if (exampleMatch[1] === modeLabel) acc.push(line);
-        return acc;
-      }
-      acc.push(line);
-      return acc;
-    }, []);
-
-    output = 'CHISLE MODE ACTIVE — level: ' + modeLabel + '\n\n' + filtered.join('\n');
+    output = 'CHISLE ACTIVE\n\n' + skillContent.replace(/^---[\s\S]*?---\s*/, '');
   } else {
     // Fallback ruleset when SKILL.md not found
     output =
-      'CHISLE MODE ACTIVE — level: ' + modeLabel + '\n\n' +
+      'CHISLE ACTIVE\n\n' +
       'Chisle: maximum-efficiency dev mode. Zero-fluff prose. YAGNI-first code.\n\n' +
       '## Persistence\n\n' +
-      'ACTIVE EVERY RESPONSE. Off only: "stop chisle" / "normal mode". Switch: `/chisle lite|full|ultra`.\n\n' +
+      'ACTIVE EVERY RESPONSE. Off only: "stop chisle" / "normal mode".\n\n' +
       '## Prose\n\n' +
       'Drop articles/filler/pleasantries/hedging. Fragments OK. Technical terms exact.\n\n' +
       '## Code\n\n' +
@@ -131,14 +131,25 @@ function run() {
       const statusLineSnippet =
         '"statusLine": { "type": "command", "command": ' + JSON.stringify(command) + ' }';
       output += '\n\n' +
-        'STATUSLINE SETUP NEEDED: The chisle plugin includes a statusline badge showing active mode ' +
-        '(e.g. [CHISLE], [CHISLE:ULTRA]) with token savings. It is not configured yet. ' +
+        'STATUSLINE SETUP NEEDED: The chisle plugin includes a statusline badge ' +
+        '([CHISLE]) with token savings. It is not configured yet. ' +
         'To enable, add this to ' + settingsPath + ': ' +
         statusLineSnippet + ' ' +
         'Proactively offer to set this up for the user on first interaction.';
     }
   } catch (e) {}
 
+  // 3b. One-time courtesy for the 3.0.0 upgrade: a lite/full/ultra setting is
+  // no longer meaningful. Chisle still runs (the value falls through to the
+  // default), but silently ignoring a setting someone chose is worse than
+  // saying so once.
+  const legacy = legacySetting();
+  if (legacy) {
+    output += '\n\nCHISLE NOTE: `' + legacy.value + '` came from ' + legacy.source +
+      '. Intensity levels were removed in 3.0.0 — there is one mode now, and it is ' +
+      'active. Set it to `on` or `off`, or drop it entirely. Mention this once.';
+  }
+
   // 4. Update notice, then emit. CHISLE_UPDATE_CHECK=0 disables.
   (async () => {
     try {
@@ -155,6 +166,24 @@ function run() {
   })();
 }
 
-if (require.main === module) run();
+// Claude Code pipes the hook payload (including `source`) on stdin. If it is
+// absent or unparseable, fall back to a full inject — over-teaching once is a
+// far cheaper failure than a session that never receives the ruleset at all.
+function main() {
+  let input = '';
+  process.stdin.on('data', chunk => { input += chunk; });
+  process.stdin.on('end', () => {
+    let source = 'startup';
+    try {
+      const parsed = JSON.parse(input.replace(/^/, ''));
+      if (parsed && typeof parsed.source === 'string') source = parsed.source;
+    } catch (e) {}
+    run(source);
+  });
+  // stdin never opened (manual run): behave like a fresh session.
+  if (process.stdin.isTTY) run('startup');
+}
+
+if (require.main === module) main();
 
 module.exports = { majorOf, majorUpdateNotice };

package/hooks/chisle-compress-output.js

@@ -19,11 +19,11 @@
 //   scrub  (output > 1k)  — lossless: strip ANSI escapes, collapse blank-line
 //                           runs, collapse ≥4 identical consecutive lines to
 //                           one + "[repeated N×]". No information lost.
-//   elide  (output > mode threshold) — head + tail + error salvage, as above.
+//   elide  (output > threshold) — head + tail + error salvage, as above.
 // Plus dedup: a tool output byte-identical to that tool's immediately previous
 // output is replaced by a short marker — the content is already in context.
 //
-// Compression tracks the /chisle mode flag (off → untouched). Tunables via env:
+// Compression follows the /chisle flag (off → untouched). Tunables via env:
 //   CHISLE_COMPRESS=0                 — kill switch
 //   CHISLE_COMPRESS_SCRUB=0           — disable the lossless scrub tier
 //   CHISLE_COMPRESS_DEDUP=0           — disable duplicate-output markers
@@ -39,12 +39,10 @@ const path = require('path');
 const crypto = require('crypto');
 const { getClaudeDir, readFlag } = require('./chisle-config');
 
-// Mode → thresholds. Tighter mode, tighter budget. Env overrides all.
-const THRESHOLDS = {
-  lite:  { maxChars: 16000, headLines: 100, tailLines: 80 },
-  full:  { maxChars: 8000,  headLines: 60,  tailLines: 40 },
-  ultra: { maxChars: 5000,  headLines: 40,  tailLines: 30 },
-};
+// One threshold. Env overrides all.
+// These are the values the old 'full' level used — the default,
+// and the only one the published benchmarks ever ran at.
+const THRESHOLDS = { maxChars: 8000, headLines: 60, tailLines: 40 };
 
 // Tools whose output is safe to elide. Read/Edit/Write are absent on purpose:
 // their output feeds exact-match edits. mcp__* are read-only info tools.
@@ -66,8 +64,8 @@ function envInt(name, fallback) {
   return Number.isFinite(n) && n > 0 ? n : fallback;
 }
 
-function limitsFor(mode) {
-  const base = THRESHOLDS[mode] || THRESHOLDS.full;
+function limitsFor() {
+  const base = THRESHOLDS;
   return {
     maxChars: envInt('CHISLE_COMPRESS_MAX_CHARS', base.maxChars),
     headLines: envInt('CHISLE_COMPRESS_HEAD_LINES', base.headLines),
@@ -225,6 +223,32 @@ function transform(text, limits) {
   return text.length - t.length >= MIN_WIN ? t : null;
 }
 
+// Put the compressed text back into the ORIGINAL response shape.
+//
+// Claude Code validates updatedToolOutput against the tool's own output schema
+// before applying it. Bash results are objects ({stdout, stderr, ...}), so
+// handing back a bare string is rejected on every call — the hook appears to
+// work, logs savings, and the model still receives the full output. Returning
+// null (skip) is always safer than emitting a shape the harness will refuse.
+// Reported with the transcript evidence by @sovdchains (#3).
+function rebuildResponse(response, updated) {
+  if (response == null || typeof response === 'string') return updated;
+  if (typeof response === 'object' && !Array.isArray(response)) {
+    for (const key of ['stdout', 'output', 'content', 'text', 'result']) {
+      if (typeof response[key] === 'string') {
+        const out = { ...response, [key]: updated };
+        // extractText already folded stderr into the compressed text; leaving
+        // the original stderr in place would duplicate it.
+        if (key === 'stdout' && typeof response.stderr === 'string') out.stderr = '';
+        return out;
+      }
+    }
+  }
+  // Unrecognized shape (e.g. MCP content-block arrays). Skip rather than guess:
+  // a wrong shape is silently rejected, which is the bug this function fixes.
+  return null;
+}
+
 // Full pipeline on one hook payload → updated output string, or null to keep
 // the original. Pure given (payload, mode, env) except dedup state.
 function processPayload(payload, mode) {
@@ -237,7 +261,7 @@ function processPayload(payload, mode) {
   if (!text) return null;
   const dup = dedupCheck(payload.tool_name, text, payload.session_id);
   if (dup != null && dup.length < text.length) return dup;
-  return transform(text, limitsFor(mode));
+  return transform(text, limitsFor());
 }
 
 function main() {
@@ -249,12 +273,18 @@ function main() {
       const mode = readFlag(path.join(getClaudeDir(), '.chisle-active'));
       const updated = processPayload(payload, mode);
       if (updated == null) return;
-      const original = extractText(payload.tool_response != null ? payload.tool_response : payload.tool_output);
+      const response = payload.tool_response != null ? payload.tool_response : payload.tool_output;
+      const rebuilt = rebuildResponse(response, updated);
+      // Shape we can't safely rebuild — emit nothing and count nothing.
+      if (rebuilt == null) return;
+      const original = extractText(response);
+      // Only after we know a replacement is actually going out, so the stats
+      // file stops crediting savings the harness never applied.
       recordSavings(original.length - updated.length);
       process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
           hookEventName: 'PostToolUse',
-          updatedToolOutput: updated,
+          updatedToolOutput: rebuilt,
         },
       }));
     } catch (e) {} // silent — never break the tool pipeline
@@ -263,4 +293,4 @@ function main() {
 
 if (require.main === module) main();
 
-module.exports = { extractText, scrub, compress, transform, limitsFor, toolAllowed, processPayload, THRESHOLDS, SAFE_TOOLS };
+module.exports = { extractText, rebuildResponse, scrub, compress, transform, limitsFor, toolAllowed, processPayload, THRESHOLDS, SAFE_TOOLS };

package/hooks/chisle-config.js

@@ -4,13 +4,35 @@
 // Resolution order for default mode:
 //   1. CHISLE_DEFAULT_MODE environment variable
 //   2. User config: $XDG_CONFIG_HOME/chisle/config.json, ~/.config/chisle/config.json
-//   3. 'full'
+//   3. 'on'
 
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const VALID_MODES = ['off', 'lite', 'full', 'ultra'];
+// One mode. The intensity levels are gone: three dials on a tool whose whole
+// argument is "fewer knobs" was the joke writing itself, and the middle setting
+// was the only one ever benchmarked. 'on' or 'off'.
+const VALID_MODES = ['off', 'on'];
+
+// Values that meant something before 3.0.0. Kept only so the upgrade can say
+// "your setting no longer does anything" instead of ignoring it in silence.
+const LEGACY_MODES = ['lite', 'full', 'ultra'];
+
+// Returns the stale value and where it came from, or null. Never throws.
+function legacySetting() {
+  const env = process.env.CHISLE_DEFAULT_MODE;
+  if (env && LEGACY_MODES.includes(String(env).toLowerCase())) {
+    return { value: String(env).toLowerCase(), source: 'CHISLE_DEFAULT_MODE' };
+  }
+  try {
+    const p = path.join(getConfigDir(), 'config.json');
+    const c = JSON.parse(fs.readFileSync(p, 'utf8'));
+    const v = c && c.defaultMode ? String(c.defaultMode).toLowerCase() : null;
+    if (v && LEGACY_MODES.includes(v)) return { value: v, source: p };
+  } catch (e) {}
+  return null;
+}
 
 function getClaudeDir() {
   return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
@@ -48,7 +70,7 @@ function getDefaultMode() {
   }
   const userMode = readModeFromConfigFile(path.join(getConfigDir(), 'config.json'));
   if (userMode) return userMode;
-  return 'full';
+  return 'on';
 }
 
 // Symlink-safe, atomic flag write with 0600 perms.
@@ -149,4 +171,7 @@ function readFlag(flagPath) {
   }
 }
 
-module.exports = { getDefaultMode, getClaudeDir, VALID_MODES, safeWriteFlag, readFlag };
+module.exports = {
+  LEGACY_MODES, legacySetting, getDefaultMode, getClaudeDir,
+  VALID_MODES, safeWriteFlag, readFlag,
+};

package/hooks/chisle-mode-tracker.js

@@ -5,7 +5,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { getDefaultMode, getClaudeDir, VALID_MODES, safeWriteFlag, readFlag } = require('./chisle-config');
+const { getDefaultMode, getClaudeDir, safeWriteFlag, readFlag } = require('./chisle-config');
 
 const claudeDir = getClaudeDir();
 const flagPath = path.join(claudeDir, '.chisle-active');
@@ -28,28 +28,16 @@ process.stdin.on('end', () => {
       }
     }
 
-    // /chisle slash commands
+    // /chisle slash commands. No level argument any more: /chisle on,
+    // /chisle off, nothing else.
     if (/^\/chisle(\b|:chisle\b)/.test(promptLower)) {
       const parts = promptLower.split(/\s+/);
-      const cmd = parts[0];
       const arg = parts[1] || '';
-
-      let mode = null;
-
-      if (cmd === '/chisle' || cmd === '/chisle:chisle') {
-        if (!arg) {
-          mode = getDefaultMode();
-        } else if (arg === 'off' || arg === 'stop' || arg === 'disable') {
-          mode = 'off';
-        } else if (VALID_MODES.includes(arg)) {
-          mode = arg;
-        }
-      }
-
-      if (mode && mode !== 'off') {
-        safeWriteFlag(flagPath, mode);
-      } else if (mode === 'off') {
+      if (arg === 'off' || arg === 'stop' || arg === 'disable') {
         try { fs.unlinkSync(flagPath); } catch (e) {}
+      } else {
+        const mode = getDefaultMode();
+        if (mode !== 'off') safeWriteFlag(flagPath, mode);
       }
     }
 
@@ -67,17 +55,13 @@ process.stdin.on('end', () => {
     const activeMode = readFlag(flagPath);
     if (activeMode && activeMode !== 'off') {
       // Inject compact reminder — keeps chisle visible across context compression
-      const ladderHint = activeMode === 'ultra'
-        ? 'YAGNI extremist: delete before add, challenge req in same breath.'
-        : 'Code: YAGNI ladder first (stdlib → native → dep → one line → min code).';
-
       process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
           hookEventName: 'UserPromptSubmit',
           additionalContext:
-            'CHISLE MODE ACTIVE (' + activeMode + '). ' +
+            'CHISLE ACTIVE. ' +
             'Prose: drop articles/filler/pleasantries/hedging. Fragments OK. ' +
-            ladderHint + ' ' +
+            'Code: YAGNI ladder first (reuse → stdlib → native → dep → one line → min code). ' +
             'Code/commits/security: write normal.'
         }
       }));

package/hooks/chisle-statusline.ps1

@@ -21,10 +21,8 @@ $mode = $raw.Substring(0, [Math]::Min(64, $raw.Length)).ToLower()
 $mode = ($mode -replace '[^a-z0-9-]', '')
 
 switch ($mode) {
-  'off'   { }
-  'lite'  { }
-  'full'  { }
-  'ultra' { }
+  'off' { }
+  'on'  { }
   default { exit 0 }
 }
 
@@ -47,8 +45,5 @@ if ($sitem -and -not ($sitem.Attributes -band [IO.FileAttributes]::ReparsePoint)
   }
 }
 
-if ([string]::IsNullOrEmpty($mode) -or $mode -eq 'full') {
-  Write-Host -NoNewline "$orange[CHISLE]$reset$suffix"
-} else {
-  Write-Host -NoNewline ("{0}[CHISLE:{1}]{2}{3}" -f $orange, $mode.ToUpper(), $reset, $suffix)
-}
+# One mode, one badge.
+Write-Host -NoNewline "$orange[CHISLE]$reset$suffix"

package/hooks/chisle-statusline.sh

@@ -21,7 +21,7 @@ MODE=$(printf '%s' "$MODE" | tr -cd 'a-z0-9-')
 
 # Whitelist — render nothing for unknown values rather than echo attacker bytes.
 case "$MODE" in
-  off|lite|full|ultra) ;;
+  off|on) ;;
   *) exit 0 ;;
 esac
 
@@ -85,10 +85,5 @@ if [ -f "$STATS" ] && [ ! -L "$STATS" ]; then
   fi
 fi
 
-# Orange badge + loading bars trailing outside the bracket
-if [ -z "$MODE" ] || [ "$MODE" = "full" ]; then
-  printf '\033[38;5;172m[CHISLE]\033[0m%s' "$LIMITS"
-else
-  SUFFIX=$(printf '%s' "$MODE" | tr '[:lower:]' '[:upper:]')
-  printf '\033[38;5;172m[CHISLE:%s]\033[0m%s' "$SUFFIX" "$LIMITS"
-fi
+# Orange badge + loading bars trailing outside the bracket. One mode, one badge.
+printf '\033[38;5;172m[CHISLE]\033[0m%s' "$LIMITS"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Maximum-efficiency dev mode for Claude Code. Zero-fluff prose + YAGNI-first code decisions. One plugin that does both.",
   "keywords": [
     "claude-code",
@@ -48,7 +48,9 @@
     "check:rules": "node scripts/build-rules.js --check",
     "build:chart": "node scripts/build-chart.js",
     "check:chart": "node scripts/build-chart.js --check",
-    "bench": "bash benchmarks/run-live.sh"
+    "bench": "bash benchmarks/run-live.sh",
+    "build:samples": "node scripts/build-samples.js",
+    "check:samples": "node scripts/build-samples.js --check"
   },
   "files": [
     "bin/",

package/rules/chisle-activate.md

@@ -10,4 +10,4 @@ YAGNI → reuse existing → stdlib → native platform → installed dep → on
 No unrequested abstractions. Deletion over addition. Shortest diff wins.
 
 **Deactivate:** "stop chisle" / "normal mode"
-**Switch level:** `/chisle lite` · `/chisle full` · `/chisle ultra`
+**Off:** `/chisle off` · "stop chisle" · "normal mode"

package/skills/chisle/SKILL.md

@@ -3,11 +3,10 @@ name: chisle
 description: >
   Maximum-efficiency dev mode. Terse, precise prose with zero fluff combined with
   YAGNI/ladder-first code decisions. One persona: the senior dev who deletes code
-  for fun and bills by the syllable. Supports intensity levels: lite, full (default),
-  ultra. Trigger: /chisle. Deactivate: "stop chisle" / "normal mode".
+  for fun and bills by the syllable. Trigger: /chisle.
+  Deactivate: "stop chisle" / "normal mode".
   Use when user says "chisle mode", "activate chisle", "chislify", "be efficient", "be minimal",
   "no fluff", "yagni", or invokes /chisle.
-argument-hint: "[lite|full|ultra]"
 ---
 
 # Chisle
@@ -17,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". Default: **full**. Switch: `/chisle lite|full|ultra`.
+Off only: "stop chisle" / "normal mode" / `/chisle off`. One mode — no levels to pick.
 
 ## Prose: Maximum Signal Per Token
 
@@ -91,23 +90,16 @@ Pattern: `[code] → skipped: [X], add when [Y].`
 
 No essays. No feature tours. No design notes. Explanation longer than code → delete explanation.
 
-## Intensity
+## What it sounds like
 
-| Level | What change |
-|-------|------------|
-| **lite** | No filler/hedging, keep articles + full sentences. Flag the more minimal approach in one line. User picks. |
-| **full** | Drop articles, fragments OK, short synonyms. Ladder enforced. Stdlib and native first. Shortest diff, shortest explanation. |
-| **ultra** | Abbreviate prose words (DB/auth/config/req/res/fn). Strip conjunctions, arrows for causality (X → Y). YAGNI extremist: deletion before addition, challenge the requirement in same breath. Code symbols/function names/API names: never abbreviate. |
-
-Example — "Why React component re-render?"
-- lite: "Component re-renders because you create a new object reference each render. Wrap it in `useMemo`. FYI: `useCallback` on handlers for same reason."
-- full: "New object ref each render. Inline object prop = new ref = re-render. `useMemo`."
-- ultra: "Inline obj prop → new ref → re-render. `useMemo`. Why inline object at all?"
+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."
-- lite: "Cache added. FYI: `functools.lru_cache` covers this in one line if you'd rather not own a class."
-- full: "`@lru_cache(maxsize=1000)` on fetch fn. Skipped custom cache class, add when lru_cache measurably falls short."
-- ultra: "No cache until profiler says so. When it does: `@lru_cache`. Hand-rolled TTL cache = bug farm with hit rate."
+> `@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."
+> 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
 

package/skills/chisle-help/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: chisle-help
 description: >
-  Quick-reference card for Chisle modes, levels, and commands. One-shot
+  Quick-reference card for Chisle commands. One-shot
   display, not a persistent mode. Use when the user says "chisle help", "how do I
   use chisle", "what chisle commands", or invokes /chisle-help.
 ---
@@ -14,29 +14,20 @@ description: >
 
 | Command | Effect |
 |---------|--------|
-| `/chisle` | Activate at default level (full) |
-| `/chisle lite` | Tighter prose, flags the minimal alternative |
-| `/chisle full` | Full compression + YAGNI ladder |
-| `/chisle ultra` | Extremist: abbreviate prose, delete before add |
+| `/chisle` | Activate |
 | `/chisle-audit [path]` | Audit a diff/file/repo for both code bloat AND prose verbosity |
 | `/chisle-review` | Review the current diff for over-engineering |
 | `stop chisle` / `normal mode` | Deactivate |
 
 Natural language works: "activate chisle", "chisle mode", "chislify this".
 
-## Levels at a glance
-
-- **lite** — keeps full sentences; names the lazier code option, you pick.
-- **full** — drops articles, fragments OK, ladder enforced. Default.
-- **ultra** — abbreviates prose words, challenges the requirement itself.
-
 ## The code ladder
 
 YAGNI → reuse → stdlib → native → installed dep → one line → minimum code.
 
 ## Statusline
 
-`[CHISLE]` / `[CHISLE:ULTRA]` — shows the active level. Configure via
+`[CHISLE]` — shown while active. Configure via
 `hooks/chisle-statusline.sh` (or `.ps1` on Windows).
 
 ## Never minimal about