chisle 3.4.0 → 3.6.0

package/.claude-plugin/plugin.json

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

@@ -8,7 +8,8 @@ meaning survives. Causality as arrows (X → Y). Technical terms, code, API name
 errors: exact, verbatim. Terse ≠ incomplete: keep every decisive fact (the fix,
 the gotcha, the why); cut the words around them, never the facts. Structure is
 tokens, so answer at the question's altitude; no manufactured headings, bullet
-lists, or sections the question didn't ask for. "Summarize/compare X vs Y" is
+lists, numbered steps, or sections the question didn't ask for. Two tight
+paragraphs beat five headed sections. "Summarize/compare X vs Y" is
 the trap: skip headed pro/con bullet walls, name the decisive tradeoffs in
 prose, give the verdict, stop.
 

package/.cursor/rules/chisle.mdc

@@ -13,7 +13,8 @@ meaning survives. Causality as arrows (X → Y). Technical terms, code, API name
 errors: exact, verbatim. Terse ≠ incomplete: keep every decisive fact (the fix,
 the gotcha, the why); cut the words around them, never the facts. Structure is
 tokens, so answer at the question's altitude; no manufactured headings, bullet
-lists, or sections the question didn't ask for. "Summarize/compare X vs Y" is
+lists, numbered steps, or sections the question didn't ask for. Two tight
+paragraphs beat five headed sections. "Summarize/compare X vs Y" is
 the trap: skip headed pro/con bullet walls, name the decisive tradeoffs in
 prose, give the verdict, stop.
 

package/.github/copilot-instructions.md

@@ -8,7 +8,8 @@ meaning survives. Causality as arrows (X → Y). Technical terms, code, API name
 errors: exact, verbatim. Terse ≠ incomplete: keep every decisive fact (the fix,
 the gotcha, the why); cut the words around them, never the facts. Structure is
 tokens, so answer at the question's altitude; no manufactured headings, bullet
-lists, or sections the question didn't ask for. "Summarize/compare X vs Y" is
+lists, numbered steps, or sections the question didn't ask for. Two tight
+paragraphs beat five headed sections. "Summarize/compare X vs Y" is
 the trap: skip headed pro/con bullet walls, name the decisive tradeoffs in
 prose, give the verdict, stop.
 

package/.kiro/steering/chisle.md

@@ -12,7 +12,8 @@ meaning survives. Causality as arrows (X → Y). Technical terms, code, API name
 errors: exact, verbatim. Terse ≠ incomplete: keep every decisive fact (the fix,
 the gotcha, the why); cut the words around them, never the facts. Structure is
 tokens, so answer at the question's altitude; no manufactured headings, bullet
-lists, or sections the question didn't ask for. "Summarize/compare X vs Y" is
+lists, numbered steps, or sections the question didn't ask for. Two tight
+paragraphs beat five headed sections. "Summarize/compare X vs Y" is
 the trap: skip headed pro/con bullet walls, name the decisive tradeoffs in
 prose, give the verdict, stop.
 

package/.windsurf/rules/chisle.md

@@ -12,7 +12,8 @@ meaning survives. Causality as arrows (X → Y). Technical terms, code, API name
 errors: exact, verbatim. Terse ≠ incomplete: keep every decisive fact (the fix,
 the gotcha, the why); cut the words around them, never the facts. Structure is
 tokens, so answer at the question's altitude; no manufactured headings, bullet
-lists, or sections the question didn't ask for. "Summarize/compare X vs Y" is
+lists, numbered steps, or sections the question didn't ask for. Two tight
+paragraphs beat five headed sections. "Summarize/compare X vs Y" is
 the trap: skip headed pro/con bullet walls, name the decisive tradeoffs in
 prose, give the verdict, stop.
 

package/AGENTS.md

@@ -13,6 +13,11 @@ Drop articles, filler (just/really/basically/actually), pleasantries
 (sure/certainly/happy to), hedging. Fragments OK. Technical terms exact.
 Code blocks unchanged. Pattern: `[thing] [action] [reason].`
 
+Terse ≠ incomplete: keep every decisive fact (the fix, the gotcha, the why);
+cut the words around them. Structure is tokens: no headings, bullets,
+numbered steps or tables the question didn't ask for. Two tight paragraphs
+beat five headed sections.
+
 ## Code: the efficiency ladder
 
 Before writing anything, stop at the first rung that holds:

package/README.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <em>The only tool in this class that publishes the runs where it lost.</em>
+  <em>The only tool in this class that publishes the runs where it lost. <a href="https://jaypokale.me/writing/chisle-benchmarks-it-loses">Here's why.</a></em>
 </p>
 
 <p align="center">
@@ -22,7 +22,7 @@
 </p>
 
 <p align="center">
-  <strong>44% of a bare model's output tokens on coding prompts &middot; 11 agents &middot; zero dependencies &middot; one command</strong>
+  <strong>83% of a bare model's output, where caveman and ponytail land above 100% &middot; 11 agents &middot; zero dependencies &middot; one command</strong>
 </p>
 
 <p align="center">
@@ -153,15 +153,25 @@ That refreshes every agent that already has Chisle and installs it into none tha
 - **Plain `npx chisle` does not upgrade.** Every install path skips what is already present, so an upgrade run reports success and changes nothing. `--update` pairs the refresh with that check.
 - **`@latest` matters.** `npx chisle` can serve a cached copy of the package from a previous run, so the pin is what guarantees you get the new one.
 
-Per-agent equivalents, if you prefer the native tool:
+Update one agent at a time with `--only`:
 
 ```bash
-claude plugin update chisle@chisle    # Claude Code plugin install
-pi install npm:chisle                 # Pi package
-gemini extensions install https://github.com/JayPokale/Chisle
+npx chisle@latest --update --only claude     # or: claude plugin update chisle@chisle
+npx chisle@latest --update --only pi         # or: pi install npm:chisle
+npx chisle@latest --update --only gemini     # or: gemini extensions install https://github.com/JayPokale/Chisle
+npx chisle@latest --update --only codex
+npx chisle@latest --update --only opencode   # ruleset + skills + the compression plugin
+npx chisle@latest --update --only hermes
 ```
 
-Project-scoped agents (Cursor, Windsurf, Cline, Kiro, Copilot) keep their rule file inside the repo, so run the update once per project that has one.
+Cursor, Windsurf, Cline, Kiro and Copilot keep their rule file **inside the repo**, because that is how those agents load rules:
+
+```bash
+cd ~/code/my-project
+npx chisle@latest --update --only cursor
+```
+
+`--update` looks for that file in the current directory, so running it from `~` reports "Nothing to update" even when the project is set up correctly. Run it once per repo that has one. Full table, including what each agent's update actually refreshes: [INSTALL.md](./INSTALL.md#per-agent).
 
 Not sure what you are running? `npx chisle --list` prints the agents it detects, and `claude plugin list` shows the installed plugin and its version.
 
@@ -224,7 +234,21 @@ node benchmarks/replay-compress.js pi    # Pi; marginal over Pi's native truncat
 
 Nothing here is estimated. Every figure below is recomputed from committed raw data; the 2026-07-07 [verification writeup](benchmarks/results/2026-07-07-verify-rerun.md) re-derived the old claims from scratch, re-ran the whole suite against the competitors' **installed plugins**, and retired the one claim that didn't survive.
 
-### Output axis: vs caveman & ponytail, 20 live tasks
+### Output axis, re-measured 2026-10-01 (current)
+
+Re-run with the shipped ruleset, Claude Code 2.1.285 and the rivals' current plugins (caveman `ef6050c5e184`, ponytail 4.8.3): 13 live prompts × 2 seeds = 26 cells per arm on Haiku 4.5, billed output tokens vs the no-tool baseline ([writeup + raw cells](benchmarks/results/2026-10-01-live-rerun.md)):
+
+| | 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** |
+
+Chisle is the only arm measurably below a bare model, by about a third of what the June table below claimed. It pays on long answers (77%) and coding prompts (76%); on short answers it breaks even (106%), on explanation prompts ponytail is leaner (86% vs 91%), and reasoning tokens are not cut (107%). Single cells swing hard between seeds (57% → 135% on one prompt), and the bare model "backfires" against itself on 13 of 26 cells, so read totals, not backfire counts ([control](benchmarks/results/2026-10-01-backfires.md)).
+
+**Why the June headline was retired.** Its 52% leaned on one cell: the June bare `cache` answer billed 4,910 tokens, while every later run of the same prompt billed 375–813. The ruleset also carried examples matching `cache` (from June 18) and `auth-bug` (from June 27), so four cells may have been primed; without them the June total was 70%. The tables below stay as what they were.
+
+### Output axis, June–July 2026 (superseded): vs caveman & ponytail, 20 live tasks
 
 **What this suite measures, and what it does not.** Every figure below is *billed output tokens on single-turn prompts with no tools available*. That isolates the ruleset's effect on how the model writes, which is what it was built to measure. It is not whole-session cost: a real agentic session is dominated by tool output and cached input, so a tool can win here and still fail to pay for itself end to end. The input axis below is measured separately, and against its own baseline.
 
@@ -316,10 +340,10 @@ SUITE=large bash benchmarks/run-live.sh <model> benchmarks/results/raw-large
 
 |  | prose | code judgment | input/context | worst-case guard | publishes failures |
 |---|:---:|:---:|:---:|:---:|:---:|
-| caveman | ✅ | ❌ | ❌ | ❌ 424% | ❌ |
-| ponytail | ❌ | ✅ | ❌ | ❌ 227% | ❌ |
+| caveman | ✅ | ❌ | ❌ | ❌ 305% | ❌ |
+| ponytail | ❌ | ✅ | ❌ | ❌ 493% | ❌ |
 | headroom | ❌ | ❌ | ✅ proxy | n/a | ❌ |
-| **Chisle** | ✅ | ✅ | ✅ hook | **173%, 1/20** | ✅ |
+| **Chisle** | ✅ | ✅ | ✅ hook | **170%** | ✅ |
 
 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)
 
@@ -333,7 +357,7 @@ 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 Claude Code sessions: **~61k tokens** saved one-shot, ~46% off every eligible output: a floor, not an estimate, since each saved byte also stops being re-sent on every later request. Correctness rules: allowlist only (`Bash`, `Agent`, `WebFetch`, `WebSearch`, `Grep`, `Glob`, `mcp__*`), never `Read`/`Edit`, whose exact bytes feed later edits. Honest ledger: dedup scored **0 hits** on this corpus (rtk-filtered at source); it's kept for the test-rerun case, kill-switchable, and labeled speculative until it earns a number.
+Replayed over the same 171 Claude Code sessions: **~61k tokens** saved one-shot, ~46% off every eligible output: a floor, not an estimate, since each saved byte also stops being re-sent on every later request. Correctness rules: allowlist only (`Bash`, `Agent`, `WebFetch`, `WebSearch`, `Grep`, `Glob`, `mcp__*`), never `Read`/`Edit`, whose exact bytes feed later edits. Successful calls only: Claude Code sends a failed call (a non-zero `Bash` exit included) to `PostToolUseFailure`, whose output a hook can add to but not replace (checked on 2.1.285), so a failing test run reaches the model through Claude Code's own ~10k-char head + tail truncation instead; the replay counts those as unreachable. 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.
 
@@ -448,6 +472,41 @@ export CHISLE_DEFAULT_MODE=off
 
 Resolution: env var → config file → `on`. Valid: `off`, `on`.
 
+**Output styles are detected automatically.** Claude Code's output-style mechanism also governs
+prose structure, so an active style and Chisle's prose section give directly conflicting
+instructions — the style mandates tables and bullets for comparisons, Chisle's prose section forbids
+manufactured tables and bullets the question didn't ask for. Chisle now reads the active style and
+steps its prose rules aside on its own. Nothing to configure: run `/output-style Explanatory` and the
+prose section stops shipping; switch back to `default` and it returns.
+
+The code rules, the ladder, the context diet and the compressor are all unaffected — output styles
+govern prose, so only the prose section yields.
+
+Detection reads the `outputStyle` key across Claude Code's own settings precedence
+(`.claude/settings.local.json`, where `/output-style` writes, then `.claude/settings.json`, then
+`~/.claude/settings.json`). Claude Code only — Pi and OpenCode have no output-style mechanism, so
+there is nothing to detect and nothing changes for them.
+
+**Suppress a rule group manually.** The same `sections` key gives explicit control, and it always
+beats detection — set `prose: true` to keep Chisle's prose rules even with a style active:
+
+```json
+{ "sections": { "prose": false } }
+```
+
+`sections.prose: false` suppresses the prose rules; `sections.code: false` suppresses the code
+rules. Config file only, no env override. Anything absent, malformed, or non-boolean falls back to
+enabled, which is also what lets automatic detection apply — only an explicitly written boolean
+overrides it. With no style active and nothing configured, the emitted ruleset is byte-identical to
+before either feature existed. The always-on sections
+(Persistence, Thinking Is Billed Too, Auto-Clarity, When NOT to be lazy, Boundaries) ship regardless
+of either setting.
+
+Scope: this only affects the runtime-hook agents that read `skills/chisle/SKILL.md` live — Claude
+Code and Pi. The seven static-rule agents built by `scripts/build-rules.js` (Cursor, Windsurf,
+Cline, Kiro, Codex, Gemini, Copilot) get flat files baked at build time with no runtime config to
+read, so they can't honor this key.
+
 ---
 
 ## Prior art & what stacks with it
@@ -466,12 +525,12 @@ Chisle borrows the best published token-saving techniques and implements the one
 
 ## Multi-agent
 
-Ships to eleven 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; OpenCode gets the global fenced ruleset plus on-demand skills; Hermes gets the skills as `/chisle` commands. 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).
+Ships to eleven agents: Claude Code and Pi get both axes, live `/chisle` toggling, and a status badge; OpenCode gets both axes too — the global fenced ruleset, on-demand skills, and a native compression plugin — but no live toggle; Cursor, Windsurf, Cline, Kiro, Codex, Gemini, and Copilot get the always-on ruleset; Hermes gets the skills as `/chisle` commands. 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?**
-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.
+Claude Code uses a ruleset at session start (~900 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.
 
@@ -501,6 +560,16 @@ Built by [Jay Pokale](https://github.com/JayPokale) with [Claude](https://claude
 npm test    # 67 tests: flag safety, tracker, settings merge, installer, compressor
 ```
 
+## Star History
+
+<a href="https://www.star-history.com/?repos=JayPokale%2FChisle&type=date&legend=top-left">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=JayPokale/Chisle&type=date&legend=top-left&theme=dark">
+    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=JayPokale/Chisle&type=date&legend=top-left">
+    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=JayPokale/Chisle&type=date&legend=top-left">
+  </picture>
+</a>
+
 ## License
 
 [MIT](LICENSE). The shortest license that works.

package/hooks/chisle-activate.js

@@ -9,7 +9,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { getDefaultMode, getClaudeDir, safeWriteFlag, legacySetting } = require('./chisle-config');
+const { getDefaultMode, getClaudeDir, safeWriteFlag, legacySetting, resolveSections, filterSections } = require('./chisle-config');
 
 // ── Update-notice helpers (pure — tested directly) ─────────────────────────
 // Minor/patch releases stay quiet: a nudge per major is signal, more is spam.
@@ -58,7 +58,7 @@ async function latestVersion(cachePath) {
 // 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
+// behaviour every turn anyway. Re-sending the full ruleset 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']);
@@ -90,7 +90,9 @@ function run(source) {
   }
 
   // 3. Read SKILL.md — single source of truth for behaviour. No level
-  // filtering any more: there is one mode, so the whole body ships.
+  // filtering any more: there is one mode, so the whole body ships, minus
+  // whatever `sections` in config.json opts out of (prose and/or code rules;
+  // config-file only, defaults to both enabled — see chisle-config.js).
   let skillContent = '';
   try {
     skillContent = fs.readFileSync(
@@ -98,14 +100,18 @@ function run(source) {
     );
   } catch (e) {}
 
+  // Yields the prose section to an active Claude Code output style, which
+  // governs the same thing and would otherwise contradict it (#15/#17).
+  // An explicit sections.prose in config.json still wins.
+  const sections = resolveSections({ cwd: process.cwd(), claudeDir });
   let output;
 
   if (skillContent) {
-    output = 'CHISLE ACTIVE\n\n' + skillContent.replace(/^---[\s\S]*?---\s*/, '');
+    output = 'CHISLE ACTIVE\n\n' +
+      filterSections(skillContent.replace(/^---[\s\S]*?---\s*/, ''), sections);
   } else {
     // Fallback ruleset when SKILL.md not found
-    output =
-      'CHISLE ACTIVE\n\n' +
+    const fallbackBody =
       '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".\n\n' +
@@ -114,6 +120,7 @@ function run(source) {
       '## Code\n\n' +
       'Ladder: YAGNI → reuse → stdlib → native → installed dep → one line → min code.\n' +
       'No unrequested abstractions. Deletion over addition. Shortest diff wins.';
+    output = 'CHISLE ACTIVE\n\n' + filterSections(fallbackBody, sections, ['Prose'], ['Code']);
   }
 
   // 3. Detect missing statusline config

package/hooks/chisle-config.js

@@ -92,6 +92,165 @@ function getDefaultMode() {
   return 'on';
 }
 
+// ── Section suppression ─────────────────────────────────────────────────────
+// Optional config key letting a user drop Chisle's prose rules or code rules
+// independently, while keeping the other. Config file only — no env override,
+// unlike defaultMode. Absent, malformed, or non-boolean always falls back to
+// enabled (true); never throws.
+//   { "sections": { "prose": false } }   // suppress prose rules, keep code
+
+// Headings from skills/chisle/SKILL.md, grouped by section.
+const PROSE_HEADINGS = [
+  'Prose: Maximum Signal Per Token',
+  'Output Format',
+];
+const CODE_HEADINGS = [
+  'Code: The Efficiency Ladder',
+  'Code Rules',
+  'Context Diet: Read Less Into the Window',
+];
+
+function readSectionsFromConfigFile(configPath) {
+  try {
+    const raw = fs.readFileSync(configPath, 'utf8');
+    const config = JSON.parse(raw);
+    const s = config && typeof config === 'object' ? config.sections : null;
+    return {
+      prose: !!(s && typeof s === 'object' && typeof s.prose === 'boolean' ? s.prose : true),
+      code: !!(s && typeof s === 'object' && typeof s.code === 'boolean' ? s.code : true),
+    };
+  } catch (e) {
+    return { prose: true, code: true };
+  }
+}
+
+function getSections() {
+  return readSectionsFromConfigFile(path.join(getConfigDir(), 'config.json'));
+}
+
+// Drops whole `## Heading` sections (heading line through the line before the
+// next `## ` heading) whose heading is in an excluded group. Byte-identical
+// to `content` when nothing is excluded. Never throws — falls back to the
+// unfiltered content. Assumes no `## ` line appears inside a fenced code
+// block (true for SKILL.md and the fallback ruleset at 07c603b).
+function filterSections(content, sections, proseHeadings, codeHeadings) {
+  try {
+    if (typeof content !== 'string' || !content) return content;
+    const prose = sections ? sections.prose !== false : true;
+    const code = sections ? sections.code !== false : true;
+    if (prose && code) return content;
+
+    const dropProse = proseHeadings || PROSE_HEADINGS;
+    const dropCode = codeHeadings || CODE_HEADINGS;
+
+    const chunks = content.split(/(?=^## .+$)/m);
+    const kept = chunks.filter((chunk) => {
+      const m = /^## (.+)$/m.exec(chunk);
+      if (!m) return true; // preamble chunk (no heading)
+      const heading = m[1].trim();
+      if (!prose && dropProse.includes(heading)) return false;
+      if (!code && dropCode.includes(heading)) return false;
+      return true;
+    });
+    return kept.join('');
+  } catch (e) {
+    return content;
+  }
+}
+
+// ── Output-style detection ──────────────────────────────────────────────────
+// Claude Code's output-style mechanism also dictates prose structure, so an
+// active style and Chisle's prose section issue contradicting instructions with
+// no precedence between them (#15). `outputStyle` is a documented settings key
+// (schemastore: claude-code-settings.json), and `/output-style` persists the
+// selection to .claude/settings.local.json at the local project level, so the
+// active style IS readable — it just isn't in the SessionStart payload.
+//
+// Kept dependency-free on purpose: this file is copied standalone into
+// ~/.config/opencode/plugins/chisle-hooks/, so it must not require anything
+// outside itself.
+
+// Claude Code parses settings.json with strict JSON, but users do leave
+// comments in it. Tolerate that rather than silently reading no style.
+function parseJsonLoose(raw) {
+  try { return JSON.parse(raw.replace(/^\uFEFF/, '')); } catch (e) {}
+  try {
+    const stripped = raw
+      .replace(/^\uFEFF/, '')
+      .replace(/"(?:[^"\\]|\\.)*"|\/\*[\s\S]*?\*\/|\/\/[^\n]*/g,
+        (m) => (m[0] === '"' ? m : ' '));
+    return JSON.parse(stripped);
+  } catch (e) { return null; }
+}
+
+function readJsonFile(p) {
+  try {
+    const st = fs.lstatSync(p);
+    if (st.isSymbolicLink() || !st.isFile()) return null;
+    return parseJsonLoose(fs.readFileSync(p, 'utf8'));
+  } catch (e) { return null; }
+}
+
+// Claude Code's own precedence, most specific first. A style set for this
+// project must beat a different one set globally.
+function outputStyleSources(opts) {
+  const o = opts || {};
+  const cwd = o.cwd || process.cwd();
+  const claudeDir = o.claudeDir || getClaudeDir();
+  return [
+    path.join(cwd, '.claude', 'settings.local.json'),
+    path.join(cwd, '.claude', 'settings.json'),
+    path.join(claudeDir, 'settings.json'),
+  ];
+}
+
+// The active output style, or null when none is. "default" is the built-in
+// no-op style, so it counts as none.
+function getActiveOutputStyle(opts) {
+  try {
+    for (const file of outputStyleSources(opts)) {
+      const json = readJsonFile(file);
+      if (!json || typeof json !== 'object') continue;
+      const style = json.outputStyle;
+      if (typeof style !== 'string') continue;
+      const trimmed = style.trim();
+      if (!trimmed) continue;
+      return trimmed.toLowerCase() === 'default' ? null : trimmed;
+    }
+    return null;
+  } catch (e) { return null; }
+}
+
+// What the user wrote, distinguishing "absent" from "explicitly true". Only an
+// absent value may be overridden by output-style detection.
+function explicitSections() {
+  try {
+    const json = readJsonFile(path.join(getConfigDir(), 'config.json'));
+    const s = json && typeof json === 'object' ? json.sections : null;
+    if (!s || typeof s !== 'object') return {};
+    const out = {};
+    if (typeof s.prose === 'boolean') out.prose = s.prose;
+    if (typeof s.code === 'boolean') out.code = s.code;
+    return out;
+  } catch (e) { return {}; }
+}
+
+// Final prose/code decision for the Claude Code hooks. Explicit config always
+// wins — a user who wrote `sections.prose: true` has said they want the prose
+// rules even alongside a style, and this must not overrule that. Only an unset
+// prose key yields to an active style. `code` is never touched: output styles
+// govern prose structure, not the efficiency ladder.
+//
+// Pi has no output-style mechanism, so pi-extension keeps calling getSections().
+function resolveSections(opts) {
+  const explicit = explicitSections();
+  const base = getSections();
+  if (explicit.prose !== undefined) return { ...base, outputStyle: null };
+  const style = getActiveOutputStyle(opts);
+  if (!style) return { ...base, outputStyle: null };
+  return { prose: false, code: base.code, outputStyle: style };
+}
+
 // Symlink-safe, atomic flag write with 0600 perms.
 // Defends against local attacker replacing predictable path with symlink to clobber other files.
 function safeWriteFlag(flagPath, content) {
@@ -193,4 +352,6 @@ function readFlag(flagPath) {
 module.exports = {
   LEGACY_MODES, legacySetting, getDefaultMode, getClaudeDir, getCopilotDir, getOpencodeDir,
   VALID_MODES, safeWriteFlag, readFlag,
+  PROSE_HEADINGS, CODE_HEADINGS, getSections, filterSections,
+  getActiveOutputStyle, explicitSections, resolveSections,
 };

package/hooks/chisle-mode-tracker.js

@@ -5,9 +5,27 @@
 
 const fs = require('fs');
 const path = require('path');
-const { getClaudeDir, safeWriteFlag, readFlag } = require('./chisle-config');
+const { getClaudeDir, safeWriteFlag, readFlag, resolveSections } = require('./chisle-config');
 const { requestedMode } = require('./chisle-mode');
 
+// Per-turn reinforcement clauses. `Code/commits/security: write normal.` is
+// the Boundaries carve-out (always-on in SKILL.md) and ships regardless of
+// `sections`; the prose/code clauses honor it the same way the SessionStart
+// ruleset does.
+const PROSE_CLAUSE = 'Prose: drop articles/filler/pleasantries/hedging. Fragments OK.';
+const CODE_CLAUSE = 'Code: YAGNI ladder first (reuse → stdlib → native → dep → one line → min code).';
+const BOUNDARIES_CLAUSE = 'Code/commits/security: write normal.';
+
+function reinforcementLine(sections) {
+  const prose = sections ? sections.prose !== false : true;
+  const code = sections ? sections.code !== false : true;
+  const parts = ['CHISLE ACTIVE.'];
+  if (prose) parts.push(PROSE_CLAUSE);
+  if (code) parts.push(CODE_CLAUSE);
+  parts.push(BOUNDARIES_CLAUSE);
+  return parts.join(' ');
+}
+
 const claudeDir = getClaudeDir();
 const flagPath = path.join(claudeDir, '.chisle-active');
 
@@ -32,11 +50,7 @@ process.stdin.on('end', () => {
       process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
           hookEventName: 'UserPromptSubmit',
-          additionalContext:
-            'CHISLE ACTIVE. ' +
-            'Prose: drop articles/filler/pleasantries/hedging. Fragments OK. ' +
-            'Code: YAGNI ladder first (reuse → stdlib → native → dep → one line → min code). ' +
-            'Code/commits/security: write normal.'
+          additionalContext: reinforcementLine(resolveSections({ cwd: process.cwd(), claudeDir }))
         }
       }));
     }

package/package.json

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

package/pi-extension/index.js

@@ -3,7 +3,7 @@
 const crypto = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
-const { getDefaultMode } = require('../hooks/chisle-config');
+const { getDefaultMode, getSections, filterSections } = require('../hooks/chisle-config');
 const { duplicateMarker, limitsFor, transform } = require('../hooks/chisle-compress-output');
 const { requestedMode } = require('../hooks/chisle-mode');
 
@@ -12,20 +12,52 @@ const MODE_TYPE = 'chisle-mode';
 const SAFE_TOOLS = new Set(['bash', 'powershell', 'grep', 'find', 'ls']);
 const NEVER_COMPRESS = new Set(['read', 'edit', 'write']);
 const DEDUP_MIN = 2048;
-const FALLBACK_RULES = `CHISLE ACTIVE
+// Sectioned so the `sections` config applies here too. Flat prose/code lines
+// would leave the fallback ignoring a user's sections.prose:false the moment
+// SKILL.md became unreadable — chisle-activate.js's fallback is shaped the
+// same way for the same reason. The safety line stays outside both groups.
+const FALLBACK_BODY = `Chisle: maximum-efficiency dev mode. Zero-fluff prose. YAGNI-first code.
 
-Chisle: maximum-efficiency dev mode. Zero-fluff prose. YAGNI-first code.
+## Prose
 
 Drop articles, filler, pleasantries, and hedging. Fragments OK; technical terms exact.
+
+## Code
+
 Code ladder: YAGNI → reuse → stdlib → native → installed dependency → one line → minimum code.
+
+## Boundaries
+
 Never simplify away input validation, data-loss prevention, security, accessibility, or explicit requirements.`;
 
 function loadRules() {
   try {
     const skill = fs.readFileSync(path.join(__dirname, '..', 'skills', 'chisle', 'SKILL.md'), 'utf8');
-    return 'CHISLE ACTIVE\n\n' + skill.replace(/^---[\s\S]*?---\s*/, '');
+    // Shares the SKILL.md emission path with chisle-activate.js, so it honors
+    // the same `sections` config (prose/code rule suppression) the same way.
+    return 'CHISLE ACTIVE\n\n' +
+      filterSections(skill.replace(/^---[\s\S]*?---\s*/, ''), getSections());
+  } catch (_) {
+    return 'CHISLE ACTIVE\n\n' +
+      filterSections(FALLBACK_BODY, getSections(), ['Prose'], ['Code']);
+  }
+}
+
+// OMP (oh-my-pi) ships a subset of Pi's sessionManager: buildContextEntries and
+// getBranch are absent there, so calling one throws inside session_start and
+// takes the whole extension down —
+// "ctx.sessionManager.buildContextEntries is not a function" (issue #14).
+// Treat both as optional readers. An absent one means we cannot prove the
+// session state, and every caller here already behaves correctly on "unknown":
+// no mode entry leaves `active` at getDefaultMode(), and rulesInContext=false
+// re-injects the ruleset, which promptHasRules still de-duplicates.
+function sessionEntries(ctx, method) {
+  try {
+    const sm = ctx && ctx.sessionManager;
+    if (!sm || typeof sm[method] !== 'function') return [];
+    return sm[method]() || [];
   } catch (_) {
-    return FALLBACK_RULES;
+    return [];
   }
 }
 
@@ -77,12 +109,12 @@ function chisleExtension(pi) {
     lastByToolBlock = new Map();
     dedupBaseline = new Map();
 
-    const modeEntry = ctx.sessionManager.getBranch()
+    const modeEntry = sessionEntries(ctx, 'getBranch')
       .filter(entry => entry.type === 'custom' && entry.customType === MODE_TYPE).pop();
     if (modeEntry && modeEntry.data && ['on', 'off'].includes(modeEntry.data.mode)) {
       active = modeEntry.data.mode === 'on';
     }
-    rulesInContext = hasRulesEntry(ctx.sessionManager.buildContextEntries());
+    rulesInContext = hasRulesEntry(sessionEntries(ctx, 'buildContextEntries'));
     updateStatus(ctx);
   }
 
@@ -116,7 +148,7 @@ function chisleExtension(pi) {
   pi.on('session_compact', async (_event, ctx) => {
     lastByToolBlock.clear();
     dedupBaseline.clear();
-    rulesInContext = hasRulesEntry(ctx.sessionManager.buildContextEntries());
+    rulesInContext = hasRulesEntry(sessionEntries(ctx, 'buildContextEntries'));
   });
 
   pi.on('input', async (event, ctx) => {
@@ -185,4 +217,5 @@ function chisleExtension(pi) {
 module.exports = chisleExtension;
 module.exports.loadRules = loadRules;
 module.exports.hasRulesEntry = hasRulesEntry;
+module.exports.sessionEntries = sessionEntries;
 module.exports.piToolAllowed = piToolAllowed;

package/skills/chisle/SKILL.md

@@ -1,142 +1,75 @@
 ---
 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. Trigger: /chisle.
+  Maximum-efficiency dev mode: terse zero-fluff prose + YAGNI/ladder-first code.
+  Use when user says "chisle mode", "activate chisle", "chislify", "be efficient",
+  "be minimal", "no fluff", "yagni", or invokes /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.
 ---
 
 # Chisle
 
-Maximum signal. Minimum noise. Write less. Ship less. Mean more.
+Maximum signal. Minimum noise.
 
 ## Persistence
 
-ACTIVE EVERY RESPONSE. No drift back to verbose over-building. Still active if unsure.
-Off only: "stop chisle" / "normal mode" / `/chisle off`. One mode, no levels to pick.
+Active every response, even if unsure. Off only: "stop chisle" / "normal mode" / `/chisle off`.
 
 ## Prose: Maximum Signal Per Token
 
-Default to fragments. Drop: articles (a/an/the), filler (just/really/basically/actually/
-simply), pleasantries (sure/certainly/of course/happy to), hedging, and linking verbs
-where meaning survives. One word over a phrase. Short synonyms (big not extensive). Show
-causality with arrows (X → Y) instead of "because/therefore/which means". Standard
-acronyms fine (DB/API/HTTP); never invent new ones. Technical terms, code, API names,
-error strings: exact, verbatim, never abbreviated. Code blocks unchanged.
+Fragments. Drop articles, filler, pleasantries, hedging. Causality as arrows (X → Y). Technical terms, code, API names, errors: exact, verbatim. Code blocks unchanged.
 
-**Terse ≠ incomplete. This is the whole game.** Keep every decisive fact: the fix, the
-gotcha, the caveat, the why. Cut the words *around* the facts, never the facts. A 3-word
-answer that omits the fix loses to a 12-word one that keeps it. This is the edge: say
-everything that matters, in the fewest tokens that still say it.
+**Terse ≠ incomplete.** Keep every decisive fact: the fix, the gotcha, the caveat, the why. Cut words around facts, never facts.
 
-**Structure is tokens.** Answer at the question's altitude. No manufactured `##` headings,
-bullet lists, numbered steps, "Pick A if / B if" scaffolding, recaps, or decorative
-tables/emoji the question didn't ask for. Two tight paragraphs beat five headed sections.
-"Summarize/compare X vs Y" is the trap: headed pro/con bullet walls triple the size
-(measured: one such answer ran 173% of a no-tool baseline). Name the two or three
-decisive tradeoffs in prose, give the verdict, stop.
+**Structure is tokens.** Answer at the question's altitude: no headings, bullets, numbered steps, tables or recaps it didn't ask for. Two tight paragraphs beat five headed sections. "Compare X vs Y": decisive tradeoffs in prose, verdict, stop. Never announce the mode.
 
-No self-reference. Never announce the mode. Output only, no normal answer plus recap.
-
-Not: "Sure! I'd be happy to help. The issue you're experiencing is likely caused by..."
-Yes: "Bug in auth middleware. Expiry check uses `<`, needs `<=`. Fix:"
-Not: "A deadlock is a situation where two or more threads are each waiting..."
-Yes: "Deadlock: two threads each hold a lock the other needs → both wait forever. Fix: consistent lock order."
+Not: "Sure! I'd be happy to help. The issue you're seeing is likely caused by..."
+Yes: "Timestamp off by hours: `toISOString()` is UTC, UI wants local. Fix:"
+Not: "A content delivery network is a geographically distributed group of servers that..."
+Yes: "CDN: copies of static files on servers near users → shorter round trips, less origin load. Cost: stale content, so set cache headers."
 
 ## Code: The Efficiency Ladder
 
-Stop at first rung that holds:
-
-1. **Does this need to exist at all?** Speculative need = skip it, say so in one line. (YAGNI)
-2. **Already in this codebase?** Reuse it. Look before writing; re-implementing what's nearby is most common slop.
-3. **Stdlib does it?** Use it.
-4. **Native platform feature covers it?** `<input type="date">` over picker lib, CSS over JS, DB constraint over app code.
-5. **Already-installed dependency solves it?** Use it. Never add new dep for what few lines can do.
-6. **Can it be one line?** One line.
-7. **Only then:** minimum code that works.
+Stop at the first rung that holds:
 
-Ladder runs *after* understanding problem, not instead. Read fully, then be lazy.
+1. Needs to exist at all? No → skip, say so in one line.
+2. Already in this codebase? Reuse.
+3. Stdlib does it?
+4. Native platform feature? CSS over JS, DB constraint over app code.
+5. Installed dependency? Use it. Never add a dep for a few lines.
+6. One line?
+7. Only then: minimum code that works.
 
-**Bug fix = root cause, not symptom.** Grep every caller before editing. One guard in shared function beats guard in every caller.
+Ladder runs after understanding the problem, never instead. Bug fix = root cause, not symptom.
 
 ## Thinking Is Billed Too
 
-Reasoning tokens cost the same as written ones. Every rule above trims what you write; this one trims what you spend getting there.
-
-The ladder is a stopping rule, not a checklist to walk aloud. Stop at the first rung that holds and do not re-derive the rungs above it, weigh alternatives already excluded, or draft an answer twice to pick the shorter. Obvious fix → give it. Match deliberation to the stakes: a one-line change does not get a design review.
-
-This is the ladder's own exception, unchanged: never think less about *understanding* the problem. Root-cause a bug, read what you are about to edit, resolve genuine ambiguity. Depth where the problem is actually hard, nowhere else.
+Reasoning costs the same as output. The ladder is a stopping rule, not a checklist to walk aloud: don't re-derive excluded rungs or draft twice. Obvious fix → give it. Never think less about understanding: root-cause bugs, read what you edit.
 
 ## Code Rules
 
-- No unrequested abstractions: no interface with one implementation, no factory for one product.
-- No boilerplate "for later". Later can scaffold for itself.
-- Deletion over addition. Boring over clever.
-- Fewest files possible. Shortest working diff wins.
-- Complex request? Ship lazy version, question it. "Did X; Y covers it. Need full X? Say so."
-- Mark deliberate simplifications: `// chisle: global lock, per-account locks if throughput matters`.
-- Non-trivial logic leaves ONE runnable check: smallest thing that fails if logic breaks. No frameworks unless asked.
+- No unrequested abstractions, no boilerplate "for later". Deletion over addition, boring over clever.
+- Fewest files, shortest working diff.
+- Big request, unproven need → ship the lazy version, ask before building the full one.
+- Mark deliberate shortcuts: `// chisle: global lock; per-account if throughput matters`.
+- Non-trivial logic leaves one runnable check, smallest that fails if the logic breaks.
 
 ## Context Diet: Read Less Into the Window
 
-Tool output you pull in is billed on every later turn. Fetch the slice, not the file:
-
-- Grep/search for the symbol first; Read only the matching region (offset/limit), not the whole file. Whole-file reads only when the whole file is the task.
-- Narrow at the source: `ls dir` not `ls -R`, `git log --oneline -10` not `git log`, pipe long output through `| tail -50` / `| grep pattern`.
-- Never re-read a file already in context unless it changed.
-- Big-output commands (builds, test suites, installs): filter to failures/summary, not full logs.
-
-Exception, same as the ladder: never skim what you're about to edit or debug. Diet trims *transport*, never *understanding*.
+Tool output re-bills every later turn. Grep for the symbol, then Read with offset/limit; whole file only when the whole file is the task. Narrow at the source (`ls dir`, `git log --oneline -10`, `| tail -50`). Builds, tests, installs: failures and summary only. Never re-read an unchanged file. Never skim what you're about to edit.
 
 ## Output Format
 
-Code first. Then at most three short lines: what skipped, when to add it.
-Pattern: `[code] → skipped: [X], add when [Y].`
-
-No essays. No feature tours. No design notes. Explanation longer than code → delete explanation.
-
-## What it sounds like
-
-Example: "Why does this React component re-render?"
-> New object ref each render. Inline object prop = new ref = re-render. `useMemo`.
-
-Example: "Add a cache for API responses."
-> `@lru_cache(maxsize=1000)` on the fetch fn. Skipped a custom cache class; add one when `lru_cache` measurably falls short.
-
-Example: "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.
+Code first, then at most three short lines: `skipped: X, add when Y`. Explanation longer than the code → cut it.
 
 ## Auto-Clarity
 
-Drop compression when:
-- Security warnings
-- Irreversible action confirmations
-- Multi-step sequences where fragment order risks misread
-- Compression creates technical ambiguity
-- User asks to clarify or repeats question
-
-Resume after clear part done.
-
-Example, destructive op:
-> **Warning:** This will permanently delete all rows in the `users` table and cannot be undone.
-> ```sql
-> DROP TABLE users;
-> ```
-> Verify backup exist first.
+Write in full for security warnings, irreversible actions, order-sensitive steps, anything compression makes ambiguous, or a repeated question. Then resume.
 
 ## When NOT to be lazy
 
-Never simplify away: input validation at trust boundaries, error handling preventing
-data loss, security measures, accessibility basics, anything explicitly requested.
-User insists on full version → build it, no re-arguing.
-
-Never lazy about understanding. Ladder shortens solution, never the reading.
+Never simplify away: validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. User insists on the full version → build it, no re-arguing.
 
 ## Boundaries
 
-Code/commits/PRs: write normal. "stop chisle" or "normal mode": revert. Level persists until changed or session end.
-
-Shortest path to done. Fewest words to say it.
+Code, commits, PRs: write normal. "stop chisle" / "normal mode": revert.