chisle 3.4.0 → 3.5.0

package/.claude-plugin/plugin.json

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

@@ -448,6 +448,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 and Pi only; Pi has no output-style mechanism, so nothing
+changes there.
+
+**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

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.
@@ -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,166 @@ 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',
+  'What it sounds like',
+];
+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 +353,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.5.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;