chisle 3.7.0 → 3.8.0

package/.agents/rules/chisle.md

@@ -30,12 +30,11 @@ prose, give the verdict, stop.
 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.
+**Thinking is billed too.** Reasoning tokens cost the same as written ones.
+Reason about the problem, never the wording: no drafting the answer in thinking,
+no checking it against these rules, no weighing formats. Obvious answer → write
+it straight away. Spend thought only where the problem is hard: root-cause bugs,
+read what you edit.
 
 **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

package/.claude-plugin/plugin.json

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

@@ -25,12 +25,11 @@ prose, give the verdict, stop.
 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.
+**Thinking is billed too.** Reasoning tokens cost the same as written ones.
+Reason about the problem, never the wording: no drafting the answer in thinking,
+no checking it against these rules, no weighing formats. Obvious answer → write
+it straight away. Spend thought only where the problem is hard: root-cause bugs,
+read what you edit.
 
 **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

package/.cursor/rules/chisle.mdc

@@ -30,12 +30,11 @@ prose, give the verdict, stop.
 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.
+**Thinking is billed too.** Reasoning tokens cost the same as written ones.
+Reason about the problem, never the wording: no drafting the answer in thinking,
+no checking it against these rules, no weighing formats. Obvious answer → write
+it straight away. Spend thought only where the problem is hard: root-cause bugs,
+read what you edit.
 
 **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

package/.github/copilot-instructions.md

@@ -25,12 +25,11 @@ prose, give the verdict, stop.
 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.
+**Thinking is billed too.** Reasoning tokens cost the same as written ones.
+Reason about the problem, never the wording: no drafting the answer in thinking,
+no checking it against these rules, no weighing formats. Obvious answer → write
+it straight away. Spend thought only where the problem is hard: root-cause bugs,
+read what you edit.
 
 **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

package/.kiro/steering/chisle.md

@@ -29,12 +29,11 @@ prose, give the verdict, stop.
 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.
+**Thinking is billed too.** Reasoning tokens cost the same as written ones.
+Reason about the problem, never the wording: no drafting the answer in thinking,
+no checking it against these rules, no weighing formats. Obvious answer → write
+it straight away. Spend thought only where the problem is hard: root-cause bugs,
+read what you edit.
 
 **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

package/.opencode/plugins/chisle.mjs

@@ -1,7 +1,7 @@
 // chisle — OpenCode plugin: tool-output compression (the input axis).
 //
-// Prompt-side rules (the fenced ruleset the installer writes into
-// ~/.config/opencode/AGENTS.md) shrink what the model WRITES. This plugin
+// Prompt-side rules (the fenced ruleset the installer writes into the global
+// OpenCode config root's AGENTS.md) shrink what the model WRITES. This plugin
 // shrinks what it READS: oversized tool results (bash dumps, subagent reports,
 // web fetches, MCP payloads) get their repetitive middle elided — head kept,
 // tail kept, error lines salvaged — before the model sees them. Deterministic,
@@ -16,7 +16,7 @@
 // before this plugin was installed). Neither needs a schema rebuild.
 //
 // Load it by installing via `npx chisle --only opencode`, which drops this file
-// and the shared compressor core into ~/.config/opencode/plugins/. OpenCode
+// and the shared compressor core into the configured OpenCode plugins dir. OpenCode
 // loads every file in that dir at startup.
 //
 // Tunables (shared with the Claude/Pi/Copilot compressor, see chisle-config):
@@ -54,7 +54,7 @@ const config = loadFrom([
 const compressForOpencode = core && core.compressForOpencode;
 const recordSavings = core && core.recordSavings;
 const getDefaultMode = config.getDefaultMode || (() => 'on');
-const getOpencodeDir = config.getOpencodeDir || (() => path.dirname(__dirname));
+const getOpencodeStateDir = config.getOpencodeStateDir || config.getOpencodeDir || (() => path.dirname(__dirname));
 
 // Already compressed: our elision marker. Skip such text so a second pass
 // (messages.transform after tool.execute.after already ran) never nests a
@@ -89,8 +89,7 @@ export default async () => {
         if (updated != null && updated.length < original.length) {
           output.output = updated;
           if (recordSavings) {
-            recordSavings(original.length - updated.length,
-              process.env.CHISLE_STATE_DIR || getOpencodeDir());
+            recordSavings(original.length - updated.length, getOpencodeStateDir());
           }
         }
       } catch (e) { /* keep the original output */ }

package/.windsurf/rules/chisle.md

@@ -29,12 +29,11 @@ prose, give the verdict, stop.
 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.
+**Thinking is billed too.** Reasoning tokens cost the same as written ones.
+Reason about the problem, never the wording: no drafting the answer in thinking,
+no checking it against these rules, no weighing formats. Obvious answer → write
+it straight away. Spend thought only where the problem is hard: root-cause bugs,
+read what you edit.
 
 **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

package/AGENTS.md

@@ -35,12 +35,10 @@ 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.
+Reasoning tokens cost the same as written ones. Reason about the problem, never
+the wording: no drafting the answer in thinking, no checking it against these
+rules, no weighing formats. Obvious answer, write it straight away. Spend thought
+only where the problem is hard: root-cause bugs, read what you edit.
 
 ## Context diet
 

package/NOTICE

@@ -0,0 +1,12 @@
+Chisle
+Copyright (c) 2026 Jay Pokale
+
+Chisle's ruleset (skills/chisle/SKILL.md and the rule copies generated from it)
+began as a merge of two MIT-licensed skills and still carries portions of them.
+Their notices, under the MIT permission notice in LICENSE:
+
+caveman — https://github.com/JuliusBrussee/caveman
+Copyright (c) 2026 Julius Brussee
+
+ponytail — https://github.com/DietrichGebert/ponytail
+Copyright (c) 2026 DietrichGebert

package/README.md

@@ -14,7 +14,7 @@
 
 <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-12%20agents-d78a3c?style=flat-square" alt="Works with 12 agents">
+  <img src="https://img.shields.io/badge/works%20with-13%20agents-d78a3c?style=flat-square" alt="Works with 13 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">
@@ -22,60 +22,71 @@
 </p>
 
 <p align="center">
-  <strong>On Pi + GPT-5.5, answers 37% the length of the same model with no ruleset (caveman 56%, ponytail 49%) &middot; 12 agents &middot; zero dependencies &middot; one command</strong>
+  <strong>Built for Claude Code: answers about half as long, shorter than caveman and ponytail &middot; 13 agents &middot; zero dependencies &middot; one command</strong>
 </p>
 
-Chisle is a ruleset and hook pack that makes AI coding agents cheaper to run. It cuts what the model writes (no filler, no hedging, no speculative abstractions: the smallest code that works) and what it reads (oversized tool output is trimmed before it re-enters the context window). One `npx chisle` wires it into Claude Code, Pi, Cursor, Codex, Gemini, Copilot, OpenCode, Antigravity and four more agents. Every number below comes from committed raw transcripts, including the runs where it lost.
+Chisle is a Claude Code plugin that makes Claude cheaper to run without making it dumber. It cuts what Claude writes: no filler, no hedging, no speculative abstractions, just the smallest code that works. It also cuts what Claude reads: a `PostToolUse` hook trims oversized tool output by ~46% before it re-enters the context window, where it would be re-billed on every later request. In agent-loop tests Claude with Chisle passes the same tasks as Claude without it. One `npx chisle` installs it, and the same ruleset ships to Pi, Cursor, Codex, Gemini, Copilot, OpenCode, Antigravity and four more agents. Every number here comes from committed raw transcripts, including the runs where it lost.
 
 <p align="center">
-  <img src="assets/benchmark-pi.svg" width="820" alt="Pi benchmark, 6 tasks on GPT-5.5, as percent of the same model with no ruleset. Answer length: caveman 56%, ponytail 49%, Chisle 37%. Billed tokens: caveman 72%, ponytail 59%, Chisle 61%.">
+  <img src="assets/benchmark-pi.svg" width="820" alt="Pi benchmark, 6 tasks on GPT-5.5, answer length as percent of the same model with no ruleset. caveman 56%, ponytail 49%, Chisle 37%.">
 </p>
 
-<p align="center"><sub>Pi 0.85.1 + GPT-5.5, 6 tasks, one run. Answer length is what you read; on total billed tokens ponytail is leanest (59% vs 61%). On the larger 26-cell Claude Code run Chisle is the only one under 100%: <a href="#benchmarks">see below</a>.</sub></p>
+<p align="center"><sub>Pi 0.85.1 + GPT-5.5, 6 tasks: answer length vs the same model with no ruleset. Lower is leaner. <a href="#benchmarks">More below.</a></sub></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/):
+"Implement an order state machine covering created, paid, shipped, delivered, cancelled and refunded, with the legal transitions enforced and invalid ones rejected." Same model, same prompt, one difference: the injected ruleset. Both answers are the **verbatim committed output** from [`raw-oct-notools/large-s2`](benchmarks/results/raw-oct-notools/large-s2/):
 
 <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 model: 125 lines, 1,342 answer tokens</th><th align="left" width="50%">Chisle: 54 lines, 450 answer 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…
-
-```typescript
-// useDebounce.ts
-export function useDebounce<T>(
-  value: T, delay: number
-): T {
-  const [debouncedValue, setDebouncedValue]
-    = useState<T>(value);
-  useEffect(() => { /* … */ }, [value, delay]);
-  return debouncedValue;
-}
+An `Enum` of states, a custom exception class, type hints and docstrings on every method, a file write, then a test harness:
+
+```python
+class OrderState(Enum):
+    CREATED = "created"
+    PAID = "paid"
+    # … four more
+
+class InvalidTransition(Exception):
+    """Raised when attempting an invalid state transition."""
+    pass
+
+class Order:
+    VALID_TRANSITIONS = { … }
+    def transition_to(self, next_state: OrderState) -> None:
+        """Transition to next state if valid, …"""
 ```
 
-…then **Option 2** and **Option 3**, a comparison table, and a caveats section.
+…plus usage, tests and a summary.
 
 </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:
-
-```jsx
-useEffect(() => {
-  const timer = setTimeout(async () => {
-    if (query.trim()) { /* fetch */ }
-  }, 300);
-  return () => clearTimeout(timer);
-}, [query]);
+One dict of legal transitions, one method that enforces it:
+
+```python
+class OrderStateMachine:
+    TRANSITIONS = {
+        'created': {'paid', 'cancelled'},
+        'paid': {'shipped', 'refunded'},
+        'shipped': {'delivered', 'cancelled'},
+        'delivered': {'refunded'},
+        'cancelled': set(),
+        'refunded': set(),
+    }
+    def transition(self, new_state):
+        if new_state not in self.TRANSITIONS[self.state]:
+            raise ValueError(f"Invalid transition: …")
+        self.state = new_state
 ```
 
-Then two lines on why it works, and *"use `lodash.debounce` if already installed."*
+Then a short usage block and one line on how it works.
 
 </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.
+Same behaviour, a third of the tokens. caveman wrote 1,140 and ponytail 842 on the same prompt.
 
 ## What it compresses
 
@@ -120,7 +131,7 @@ The loop on the right is the input axis: tool output is billed again on *every*
 
 ## Install
 
-One command. Auto-detects your agents (Claude Code, Pi, Cursor, Windsurf, Cline, Kiro, Antigravity, Codex, Gemini, Copilot, OpenCode, Hermes) and wires each one. `--uninstall` puts everything back.
+One command. Auto-detects your agents (Claude Code, Pi, Cursor, Windsurf, Cline, Kiro, Antigravity, Codex, Gemini, Copilot, Copilot CLI, OpenCode, Hermes) and wires each one. `--uninstall` puts everything back. `npx chisle mcp wrap` extends tool-output compression to MCP servers in any agent ([details](INSTALL.md#mcp-output-compression-any-agent)).
 
 ```bash
 npx chisle
@@ -144,30 +155,26 @@ Upgrading, per-agent setup, `--stats` and config: [docs/usage.md](docs/usage.md)
 
 ## Benchmarks
 
-Claude Code 2.1.285 on Haiku 4.5, 13 live prompts × 2 seeds = 26 cells per arm, billed output tokens vs the same model with no ruleset ([writeup + raw cells](benchmarks/results/2026-10-01-live-rerun.md)):
+Same model, same prompts, one difference: the injected ruleset. Lower = leaner. Chisle is the leanest on every row.
 
-<p align="center">
-  <img src="assets/benchmark-rerun.svg" width="820" alt="2026-10-01 live rerun: total billed output as percent of the bare model. caveman 102%, ponytail 105%, Chisle 83%.">
-</p>
+**Claude Code** (Haiku 4.5, 26 live prompts, tools off, [raw cells](benchmarks/results/raw-oct-notools/)):
 
-| | total bill | 95% CI | visible answer | worst cell | backfires |
-|---|--:|--:|--:|--:|--:|
-| caveman | 102% | 79–128% | 105% | 305% | 15 / 26 |
-| ponytail | 105% | 86–129% | 97% | 493% | 16 / 26 |
-| **Chisle** | **83%** | **69–95%** | **76%** | **170%** | **11 / 26** |
+| % of a bare model | caveman | ponytail | **Chisle** |
+|---|--:|--:|--:|
+| answer length | 65% | 58% | **56%** |
+| answer lines | 66% | 54% | **52%** |
 
-Chisle is the only arm below a bare model. It pays on long answers (77%) and coding prompts (76%); on short answers it breaks even (106%).
+**Pi** (GPT-5.5, 6 tasks, [raw cells](benchmarks/results/raw-pi/)):
 
-**Input side:** tool output is 67.5% of context in 171 measured Claude Code sessions, and it is re-billed on every later request. The compressor cut ~46% off every eligible output there, and 27.4% of tool output on top of Pi's own truncation ([receipts](benchmarks/results/2026-07-07-input-axis.md)).
+| % of a bare model | caveman | ponytail | **Chisle** |
+|---|--:|--:|--:|
+| answer length | 56% | 49% | **37%** |
+| answer lines | 75% | 38% | **37%** |
+| billed tokens, explanations | 43% | 76% | **39%** |
 
-|  | prose | code judgment | input/context | worst-case guard | publishes failures |
-|---|:---:|:---:|:---:|:---:|:---:|
-| caveman | ✅ | ❌ | ❌ | ❌ 305% | ❌ |
-| ponytail | ❌ | ✅ | ❌ | ❌ 493% | ❌ |
-| headroom | ❌ | ❌ | ✅ proxy | n/a | ❌ |
-| **Chisle** | ✅ | ✅ | ✅ hook | **170%** | ✅ |
+**Tool output** is two thirds of a Claude Code session's context and re-billed every turn. The compressor cuts **~46%** off every oversized output ([171 sessions](benchmarks/results/2026-07-07-input-axis.md)); on OpenCode a 30 KB log dropped **87%** of fresh input tokens.
 
-Every table, chart and caveat, including the June suite and the Pi run in full: [docs/benchmarks.md](docs/benchmarks.md). Head to head: [docs/comparison.md](docs/comparison.md).
+Method and every raw cell: [docs/benchmarks.md](docs/benchmarks.md).
 
 ---
 
@@ -242,6 +249,8 @@ See [CONTRIBUTING.md](CONTRIBUTING.md). Built by [Jay Pokale](https://github.com
 
 [MIT](LICENSE). The shortest license that works.
 
+Chisle began as a merge of [caveman](https://github.com/JuliusBrussee/caveman) (terse prose) and [ponytail](https://github.com/DietrichGebert/ponytail) (lazy-senior-dev code rules), and its ruleset still carries parts of both. Their MIT notices are in [NOTICE](NOTICE).
+
 ## Contributors
 
 <a href="https://github.com/JayPokale/Chisle/graphs/contributors">