chisle 3.3.0 → 3.5.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "3.3.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/.opencode/plugins/chisle.mjs

@@ -0,0 +1,115 @@
+// 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
+// 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,
+// zero LLM, zero network. Read/Edit/Write output is never touched.
+//
+// OpenCode exposes two relevant plugin hooks. `tool.execute.after` receives a
+// completed tool result whose `output.output` is the plain text the model will
+// see; mutating it in place also persists onto the stored tool part, so every
+// later turn reuses the compressed form. `experimental.chat.messages.transform`
+// runs just before parts are converted to model messages, a request-time safety
+// net that re-compresses any full output the store still holds (e.g. recorded
+// 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
+// loads every file in that dir at startup.
+//
+// Tunables (shared with the Claude/Pi/Copilot compressor, see chisle-config):
+//   CHISLE_COMPRESS=0            kill switch
+//   CHISLE_DEFAULT_MODE=off      disable by default (env or ~/.config/chisle)
+//   CHISLE_COMPRESS_MAX_CHARS    outputs at/under this size are not elided
+//   CHISLE_COMPRESS_TOOLS=bash,… override the tool allowlist
+
+import { createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const require = createRequire(import.meta.url);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// The compressor core is CommonJS. When installed by `chisle --only opencode`
+// it sits in ./chisle-hooks/; running straight from the repo it's ../../hooks/.
+function loadFrom(names) {
+  for (const rel of names) {
+    try { return require(rel); }
+    catch (e) { if (e && e.code !== 'MODULE_NOT_FOUND' && e.code !== 'ERR_MODULE_NOT_FOUND') throw e; }
+  }
+  return null;
+}
+
+const core = loadFrom([
+  './chisle-hooks/chisle-compress-output.js',
+  '../../hooks/chisle-compress-output.js',
+]);
+const config = loadFrom([
+  './chisle-hooks/chisle-config.js',
+  '../../hooks/chisle-config.js',
+]) || { getDefaultMode: () => 'on' };
+
+const compressForOpencode = core && core.compressForOpencode;
+const getDefaultMode = config.getDefaultMode || (() => 'on');
+
+// Already compressed: our elision marker. Skip such text so a second pass
+// (messages.transform after tool.execute.after already ran) never nests a
+// marker or eats an earlier salvage block. Keeps compression idempotent.
+const CHISLE_MARK = '[chisle:';
+
+export default async () => {
+  return {
+    // Compress oversized read-only tool output before the model sees it.
+    // Never throws: a broken compressor must not break the tool pipeline.
+    //
+    // For outputs under OpenCode's on-disk store limits (~50 KB / 2000 lines)
+    // output.output is the FULL text and mutating it here persists onto the
+    // tool part's state.output — so every later turn sees the compressed form.
+    // Larger outputs reach this hook already replaced by OpenCode with a notice
+    // plus a retained tail; that tail still compresses here.
+    'tool.execute.after': async (input, output) => {
+      try {
+        if (!compressForOpencode) return;
+        // MCP tools can hand back a content[] array rather than a string;
+        // built-ins give a string. Only the string case is ours to touch.
+        if (!output || typeof output.output !== 'string') return;
+        if (output.output.includes(CHISLE_MARK)) return;
+        const updated = compressForOpencode(input && input.tool, output.output, { mode: getDefaultMode() });
+        if (updated != null && updated.length < output.output.length) {
+          output.output = updated;
+        }
+      } catch (e) { /* keep the original output */ }
+    },
+
+    // Request-time safety net over completed tool parts. Runs after MCP
+    // normalization and BEFORE OpenCode converts parts to model messages
+    // (and before compaction summarization), so it re-applies compression to
+    // any full output that reached the model store uncompressed — e.g. parts
+    // recorded before this plugin was installed. Skips parts already carrying
+    // our marker, so each part is compressed at most once; the elided original
+    // still spills to disk exactly as it does on the tool.execute.after path.
+    'experimental.chat.messages.transform': async (_input, output) => {
+      try {
+        if (!compressForOpencode) return;
+        if (!output || !Array.isArray(output.messages)) return;
+        const mode = getDefaultMode();
+        for (const msg of output.messages) {
+          const parts = msg && msg.parts;
+          if (!Array.isArray(parts)) continue;
+          for (const part of parts) {
+            if (!part || part.type !== 'tool') continue;
+            const st = part.state;
+            if (!st || st.status !== 'completed' || typeof st.output !== 'string') continue;
+            if (st.output.includes(CHISLE_MARK)) continue;
+            const updated = compressForOpencode(part.tool, st.output, { mode });
+            if (updated != null && updated.length < st.output.length) {
+              st.output = updated;
+            }
+          }
+        }
+      } catch (e) { /* leave messages untouched */ }
+    },
+  };
+};

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-9%20agents-d78a3c?style=flat-square" alt="Works with 9 agents">
+  <img src="https://img.shields.io/badge/works%20with-11%20agents-d78a3c?style=flat-square" alt="Works with 11 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,7 +22,7 @@
 </p>
 
 <p align="center">
-  <strong>44% of a bare model on coding work &middot; 41% on the long ones &middot; one command</strong>
+  <strong>44% of a bare model's output tokens on coding prompts &middot; 11 agents &middot; zero dependencies &middot; one command</strong>
 </p>
 
 <p align="center">
@@ -122,7 +122,7 @@ Every "be concise" tool has a worst day, the day it makes the model write *more*
 
 ## Install
 
-One command. Auto-detects your agents (Claude Code, Pi, Cursor, Windsurf, Cline, Kiro, Codex, Gemini, Copilot) and wires each one. `--uninstall` puts everything back.
+One command. Auto-detects your agents (Claude Code, Pi, Cursor, Windsurf, Cline, Kiro, Codex, Gemini, Copilot, OpenCode, Hermes) and wires each one. `--uninstall` puts everything back.
 
 ```bash
 npx chisle
@@ -226,6 +226,8 @@ Nothing here is estimated. Every figure below is recomputed from committed raw d
 
 ### Output axis: 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.
+
 **59+ live model runs** across two suites (June 4-arm matrix on Haiku + Sonnet sweep; July re-verification run). Arms differ only in the injected system prompt. Billed output tokens vs the no-tool baseline:
 
 | | total bill (all 20 tasks) | average task | worst case | backfires |
@@ -446,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
@@ -464,7 +501,7 @@ Chisle borrows the best published token-saving techniques and implements the one
 
 ## Multi-agent
 
-Ships to nine agents: Claude Code and Pi get both axes, live `/chisle` toggling, and a status badge; Cursor, Windsurf, Cline, Kiro, Codex, Gemini, and Copilot get the always-on ruleset. Per-agent static copies come from `scripts/build-rules.js`; Pi uses its package extension plus the Agent Skills standard. See [`docs/agent-portability.md`](./docs/agent-portability.md).
+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).
 
 ## FAQ
 

package/bin/install.js

@@ -7,6 +7,8 @@
 //   - Pi           → Pi package (extension + skill)
 //   - Gemini CLI   → gemini extensions install
 //   - Codex        → fenced ruleset appended to ~/.codex/AGENTS.md
+//   - OpenCode     → fenced ruleset in ~/.config/opencode/AGENTS.md + skills copy
+//   - Hermes       → skills copy in ~/.hermes/skills (Agent Skills standard)
 //   - Cursor/Windsurf/Cline/Kiro/Copilot → project rule file dropped into CWD
 //
 // Usage:
@@ -43,6 +45,8 @@ const PROVIDERS = [
   { id: 'pi',       label: 'Pi',            scope: 'global',  detect: 'cmd:pi' },
   { id: 'gemini',   label: 'Gemini CLI',    scope: 'global',  detect: 'cmd:gemini' },
   { id: 'codex',    label: 'Codex CLI',     scope: 'global',  detect: 'cmd:codex||dir:~/.codex' },
+  { id: 'opencode', label: 'OpenCode',        scope: 'global',  detect: 'cmd:opencode||dir:~/.config/opencode' },
+  { id: 'hermes',   label: 'Hermes Agent',    scope: 'global',  detect: 'cmd:hermes||dir:~/.hermes' },
   { id: 'cursor',   label: 'Cursor',        scope: 'project', detect: 'cmd:cursor||dir:~/.cursor',
     rule: '.cursor/rules/chisle.mdc' },
   { id: 'windsurf', label: 'Windsurf',      scope: 'project', detect: 'cmd:windsurf||dir:~/.windsurf||dir:~/.codeium/windsurf',
@@ -157,6 +161,14 @@ function run(cmd, args, dry) {
   process.stdout.write(`  $ ${cmd} ${args.join(' ')}\n`);
   return spawnX(cmd, args, { stdio: 'inherit' });
 }
+
+// spawnSync reports a missing binary as { status: null, error: ENOENT } and a
+// signal death as { status: null, signal }. `(r.status || 0) === 0` reads both
+// as success, so a machine without the CLI was told the install succeeded.
+// Only an explicit exit code of 0 counts.
+function ranOk(r) {
+  return !!r && !r.error && r.status === 0;
+}
 function capture(cmd, args) {
   try { return spawnX(cmd, args, { encoding: 'utf8' }); } catch (_) { return { status: 1, stdout: '', stderr: '' }; }
 }
@@ -168,6 +180,10 @@ function claudeDir(opts) {
   return path.join(os.homedir(), '.claude');
 }
 
+// Home dir for Chisle-managed global targets. CHISLE_HOME overrides it
+// (tests, containers); mirrors the CLAUDE_CONFIG_DIR precedent for Claude.
+function homeDir() { return process.env.CHISLE_HOME || os.homedir(); }
+
 // ── what is already installed ───────────────────────────────────────────────
 // Every install path skips when Chisle is already present, which is right for
 // `npx chisle` and useless for an upgrade: the run reports success and changes
@@ -200,9 +216,18 @@ function installedFor(id, opts) {
         return r.status === 0 && /chisle/i.test(r.stdout || '');
       }
       case 'codex': {
-        const md = path.join(os.homedir(), '.codex', 'AGENTS.md');
+        const md = path.join(homeDir(), '.codex', 'AGENTS.md');
         return fs.existsSync(md) && fs.readFileSync(md, 'utf8').includes(FENCE_BEGIN);
       }
+      case 'opencode': {
+        try {
+          const md = path.join(homeDir(), '.config', 'opencode', 'AGENTS.md');
+          if (fs.existsSync(md) && fs.readFileSync(md, 'utf8').includes(FENCE_BEGIN)) return true;
+        } catch (_) {}
+        return fs.existsSync(path.join(homeDir(), '.config', 'opencode', 'skills', 'chisle', 'SKILL.md'));
+      }
+      case 'hermes':
+        return fs.existsSync(path.join(homeDir(), '.hermes', 'skills', 'chisle', 'SKILL.md'));
       default: {
         const prov = PROVIDERS.find(x => x.id === id);
         return !!(prov && prov.rule && fs.existsSync(path.join(process.cwd(), prov.rule)));
@@ -231,7 +256,7 @@ function installClaude(ctx) {
     } else {
       const r1 = run('claude', ['plugin', 'marketplace', 'add', REPO], opts.dryRun);
       const r2 = run('claude', ['plugin', 'install', 'chisle@chisle'], opts.dryRun);
-      if ((r1.status || 0) === 0 && (r2.status || 0) === 0) { results.installed.push('claude'); pluginOK = true; }
+      if (ranOk(r1) && ranOk(r2)) { results.installed.push('claude'); pluginOK = true; }
       else warn('  claude plugin install failed, falling back to standalone hooks');
     }
   } else {
@@ -343,7 +368,7 @@ function installPi(ctx) {
     }
   }
   const r = run('pi', ['install', 'npm:chisle'], opts.dryRun);
-  if ((r.status || 0) === 0) results.installed.push('pi');
+  if (ranOk(r)) results.installed.push('pi');
   else results.failed.push(['pi', 'pi package install failed']);
   process.stdout.write('\n');
 }
@@ -361,11 +386,105 @@ function installGemini(ctx) {
     }
   }
   const r = run('gemini', ['extensions', 'install', `https://github.com/${REPO}`], opts.dryRun);
-  if ((r.status || 0) === 0) results.installed.push('gemini');
+  if (ranOk(r)) results.installed.push('gemini');
   else results.failed.push(['gemini', 'gemini extensions install failed']);
   process.stdout.write('\n');
 }
 
+// Skills-root helpers for Agent-Skills hosts (OpenCode, Hermes). Both load
+// one dir per skill through the host's native `skill` tool, so the bundled
+// skills/ tree copies over verbatim: no conversion, no second system
+// message, existing user instructions untouched.
+function ownedSkillNames() {
+  var srcRoot = path.join(REPO_ROOT, 'skills');
+  try {
+    return fs.readdirSync(srcRoot).filter(function (n) {
+      try {
+        return fs.statSync(path.join(srcRoot, n)).isDirectory()
+          && fs.existsSync(path.join(srcRoot, n, 'SKILL.md'));
+      } catch (_) { return false; }
+    });
+  } catch (_) { return []; }
+}
+
+// Overwrites stale files, keeps foreign siblings, never touches files
+// outside the named skill dirs. Returns files written.
+function copySkills(dstRoot, opts) {
+  var names = ownedSkillNames();
+  var written = 0;
+  for (var i = 0; i < names.length; i++) {
+    var src = path.join(REPO_ROOT, 'skills', names[i]);
+    var dst = path.join(dstRoot, names[i]);
+    var files = fs.readdirSync(src);
+    if (!opts.dryRun) fs.mkdirSync(dst, { recursive: true });
+    for (var j = 0; j < files.length; j++) {
+      var st = null;
+      try { st = fs.statSync(path.join(src, files[j])); } catch (_) { continue; }
+      if (!st.isFile()) continue;
+      if (opts.dryRun) { written++; continue; }
+      fs.copyFileSync(path.join(src, files[j]), path.join(dst, files[j]));
+      written++;
+    }
+  }
+  return written;
+}
+
+// Removes only the skill dirs Chisle owns; foreign skills stay put.
+function pruneSkills(dstRoot) {
+  var removed = 0;
+  var names = ownedSkillNames();
+  for (var i = 0; i < names.length; i++) {
+    var dst = path.join(dstRoot, names[i]);
+    if (fs.existsSync(dst)) {
+      fs.rmSync(dst, { recursive: true, force: true });
+      removed++;
+    }
+  }
+  return removed;
+}
+
+// Fenced AGENTS.md append/refresh for Codex-style targets. Appends after
+// existing content (never prepends, never clobbers), refreshes one fenced
+// block in place under --force. Returns 'installed', 'refreshed', 'skipped'.
+function writeFencedRuleset(target, opts, note) {
+  var raw = fs.readFileSync(path.join(REPO_ROOT, 'AGENTS.md'), 'utf8');
+  var block = FENCE_BEGIN + '\n' + raw.trimEnd() + '\n' + FENCE_END + '\n';
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  var existing = '';
+  try { existing = fs.readFileSync(target, 'utf8'); } catch (_) {}
+  if (existing.indexOf(FENCE_BEGIN) !== -1) {
+    if (!opts.force) {
+      note('  ' + target + ' already contains chisle ruleset (--force to refresh)');
+      return 'skipped';
+    }
+    var b = existing.indexOf(FENCE_BEGIN);
+    var e = existing.indexOf(FENCE_END, b);
+    // A begin marker with no end marker means the file was hand-edited or a
+    // write was cut short. Everything after the begin marker is then user
+    // content of unknown extent, so refuse rather than guess: rewriting would
+    // delete the rest of their global instructions.
+    if (e === -1) {
+      note('  ' + target + ' has a chisle-begin marker with no chisle-end; leaving it alone');
+      note('  remove the stray marker by hand, then re-run');
+      return 'skipped';
+    }
+    var tail = existing.slice(e + FENCE_END.length);
+    if (tail.charAt(0) === '\n') tail = tail.slice(1);
+    fs.writeFileSync(target, existing.slice(0, b) + block + tail, { mode: 0o644 });
+    process.stdout.write('  refreshed ruleset in ' + target + '\n');
+    return 'refreshed';
+  }
+  var sep = '';
+  if (existing) {
+    if (existing.slice(-2) === '\n\n') sep = '';
+    else if (existing.slice(-1) === '\n') sep = '\n';
+    else sep = '\n\n';
+  }
+  fs.writeFileSync(target, existing + sep + block, { mode: 0o644 });
+  process.stdout.write('  installed: ' + target + '\n');
+  return 'installed';
+}
+
 // ── Codex (fenced ruleset in ~/.codex/AGENTS.md) ────────────────────────────
 const FENCE_BEGIN = '<!-- chisle-begin -->';
 const FENCE_END = '<!-- chisle-end -->';
@@ -373,34 +492,111 @@ const FENCE_END = '<!-- chisle-end -->';
 function installCodex(ctx) {
   const { say, note, opts, results } = ctx;
   results.detected++;
-  say('→ Codex detected');
-  const target = path.join(os.homedir(), '.codex', 'AGENTS.md');
-  const body = fs.readFileSync(path.join(REPO_ROOT, 'AGENTS.md'), 'utf8').trimEnd() + '\n';
-  const block = `${FENCE_BEGIN}\n${body}${FENCE_END}\n`;
+  say('\u2192 Codex detected');
+  const target = path.join(homeDir(), '.codex', 'AGENTS.md');
 
-  if (opts.dryRun) { note(`  would write chisle ruleset → ${target}`); results.installed.push('codex'); process.stdout.write('\n'); return; }
+  if (opts.dryRun) { note('  would write chisle ruleset to ' + target); results.installed.push('codex'); process.stdout.write('\n'); return; }
 
   try {
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-    let existing = '';
-    try { existing = fs.readFileSync(target, 'utf8'); } catch (_) {}
-    if (existing.includes(FENCE_BEGIN)) {
-      if (opts.force) {
-        const rewritten = existing.replace(new RegExp(`${FENCE_BEGIN}[\\s\\S]*?${FENCE_END}\\n?`), block);
-        fs.writeFileSync(target, rewritten, { mode: 0o644 });
-        process.stdout.write(`  refreshed ruleset in ${target}\n`);
-      } else { note(`  ${target} already contains chisle ruleset (--force to refresh)`); }
-      results.skipped.push(['codex', 'already present']);
-    } else {
-      const sep = existing && !existing.endsWith('\n\n') ? (existing.endsWith('\n') ? '\n' : '\n\n') : '';
-      fs.writeFileSync(target, existing + sep + block, { mode: 0o644 });
-      process.stdout.write(`  installed: ${target}\n`);
-      results.installed.push('codex');
-    }
+    const st = writeFencedRuleset(target, opts, note);
+    if (st === 'installed') results.installed.push('codex');
+    else results.skipped.push(['codex', 'already present']);
   } catch (e) { results.failed.push(['codex', (e && e.message) || 'write failed']); }
   process.stdout.write('\n');
 }
 
+// ── OpenCode ─────────────────────────────────────────────────────────────
+// Global ruleset (~/.config/opencode/AGENTS.md) carries the always-on output
+// axis next to existing user instructions; the bundled skills copy into
+// ~/.config/opencode/skills for on-demand loading via the native skill tool
+// (the global skills dir is scanned by default, so skills.paths needs no
+// edit and no second system message is added).
+// Copies the OpenCode compression plugin and the shared compressor core it
+// requires into ~/.config/opencode/plugins/. OpenCode auto-discovers any *.js
+// or *.ts file in that dir at startup (not *.mjs), and its config dir is
+// type:module, so the ESM source ships as chisle.js. Returns the number of
+// files written. Never called on a dry run (installOpencode returns early),
+// so no dry-run branch.
+//
+// chisle-hooks/package.json pins the core as CommonJS. Without it the config
+// dir's own "type": "module" propagates down to these .js files, and the core
+// dies on its first `require` with a ReferenceError that takes the whole
+// plugin with it (loadFrom only swallows MODULE_NOT_FOUND). Bun is lenient
+// enough not to care; Node is not, so pin it rather than rely on the runtime.
+function copyOpencodePlugin() {
+  const pluginDir = path.join(homeDir(), '.config', 'opencode', 'plugins');
+  const hooksDir = path.join(pluginDir, 'chisle-hooks');
+  const files = [
+    ['.opencode/plugins/chisle.mjs', path.join(pluginDir, 'chisle.js')],
+    ['hooks/chisle-compress-output.js', path.join(hooksDir, 'chisle-compress-output.js')],
+    ['hooks/chisle-config.js', path.join(hooksDir, 'chisle-config.js')],
+  ];
+  fs.mkdirSync(hooksDir, { recursive: true });
+  var n = 0;
+  for (var i = 0; i < files.length; i++) {
+    fs.copyFileSync(path.join(REPO_ROOT, files[i][0]), files[i][1]);
+    n++;
+  }
+  fs.writeFileSync(path.join(hooksDir, 'package.json'), '{ "type": "commonjs" }\n');
+  n++;
+  return n;
+}
+
+function installOpencode(ctx) {
+  const { say, note, opts, results } = ctx;
+  results.detected++;
+  say('\u2192 OpenCode detected');
+  const target = path.join(homeDir(), '.config', 'opencode', 'AGENTS.md');
+  const skillsDst = path.join(homeDir(), '.config', 'opencode', 'skills');
+  const pluginDst = path.join(homeDir(), '.config', 'opencode', 'plugins');
+
+  if (opts.dryRun) {
+    note('  would write chisle ruleset to ' + target);
+    note('  would copy skills to ' + skillsDst);
+    note('  would copy compression plugin to ' + pluginDst);
+    results.installed.push('opencode');
+    process.stdout.write('\n');
+    return;
+  }
+
+  try {
+    const st = writeFencedRuleset(target, opts, note);
+    const n = copySkills(skillsDst, opts);
+    process.stdout.write('  installed: ' + n + ' skill file(s) to ' + skillsDst + '\n');
+    const p = copyOpencodePlugin();
+    process.stdout.write('  installed: ' + p + ' plugin file(s) to ' + pluginDst + '\n');
+    if (st === 'installed') results.installed.push('opencode');
+    else results.skipped.push(['opencode', 'ruleset already present; skills + plugin refreshed']);
+  } catch (e) { results.failed.push(['opencode', (e && e.message) || 'write failed']); }
+  process.stdout.write('\n');
+}
+
+// ── Hermes ──────────────────────────────────────────────────────────
+// Agent-Skills host: bundled skills land verbatim in ~/.hermes/skills, where
+// Hermes discovers them as /chisle slash commands. No ruleset is injected:
+// Hermes already reads project AGENTS.md, which carries the always-on axis
+// when the repo ships it. Portable: honors CHISLE_HOME, no hardcoded paths.
+function installHermes(ctx) {
+  const { say, opts, results } = ctx;
+  results.detected++;
+  say('\u2192 Hermes Agent detected');
+  const skillsDst = path.join(homeDir(), '.hermes', 'skills');
+
+  if (opts.dryRun) {
+    process.stdout.write('  would copy skills to ' + skillsDst + '\n');
+    results.installed.push('hermes');
+    process.stdout.write('\n');
+    return;
+  }
+
+  try {
+    const n = copySkills(skillsDst, opts);
+    process.stdout.write('  installed: ' + n + ' skill file(s) to ' + skillsDst + '\n');
+    results.installed.push('hermes');
+  } catch (e) { results.failed.push(['hermes', (e && e.message) || 'copy failed']); }
+  process.stdout.write('\n');
+}
+
 // ── Project-scoped rule agents (Cursor/Windsurf/Cline/Kiro/Copilot) ─────────
 function installProjectRule(ctx, prov) {
   const { say, note, warn, opts, results } = ctx;
@@ -473,12 +669,12 @@ function uninstall(ctx) {
   if (wants('pi') && hasCmd('pi')) {
     const sources = piSources(capture('pi', ['list']).stdout);
     for (const source of sources) {
-      if ((run('pi', ['remove', source], opts.dryRun).status || 0) === 0) touched++;
+      if (ranOk(run('pi', ['remove', source], opts.dryRun))) touched++;
     }
   }
 
   if (wants('codex')) {
-    const codexMd = path.join(os.homedir(), '.codex', 'AGENTS.md');
+    const codexMd = path.join(homeDir(), '.codex', 'AGENTS.md');
     if (fs.existsSync(codexMd)) {
       const txt = fs.readFileSync(codexMd, 'utf8');
       if (txt.includes(FENCE_BEGIN)) {
@@ -489,6 +685,42 @@ function uninstall(ctx) {
     }
   }
 
+  if (wants('opencode')) {
+    const ocMd = path.join(homeDir(), '.config', 'opencode', 'AGENTS.md');
+    if (fs.existsSync(ocMd)) {
+      const txt = fs.readFileSync(ocMd, 'utf8');
+      const b = txt.indexOf(FENCE_BEGIN);
+      const e = b === -1 ? -1 : txt.indexOf(FENCE_END, b);
+      if (b !== -1 && e === -1) {
+        note('  ' + ocMd + ' has a chisle-begin marker with no chisle-end; leaving it alone');
+      } else if (b !== -1) {
+        const tail = txt.slice(e + FENCE_END.length).replace(/^\n/, '');
+        const stripped = (txt.slice(0, b) + tail).replace(/\n{3,}/g, '\n\n');
+        if (!opts.dryRun) fs.writeFileSync(ocMd, stripped, { mode: 0o644 });
+        note('  removed chisle block from ' + ocMd); touched++;
+      }
+    }
+    const ocSkills = path.join(homeDir(), '.config', 'opencode', 'skills');
+    const ocGone = opts.dryRun ? ownedSkillNames().filter(function (nm) { return fs.existsSync(path.join(ocSkills, nm)); }).length : pruneSkills(ocSkills);
+    if (ocGone > 0) { note('  removed ' + ocGone + ' chisle skill dir(s) from ' + ocSkills); touched++; }
+
+    const ocPlugins = path.join(homeDir(), '.config', 'opencode', 'plugins');
+    for (const rel of ['chisle.js', 'chisle-hooks']) {
+      const dst = path.join(ocPlugins, rel);
+      if (fs.existsSync(dst)) { if (!opts.dryRun) fs.rmSync(dst, { recursive: true, force: true }); note('  removed ' + dst); touched++; }
+    }
+    for (const f of ['chisle-spill', '.chisle-compress-stats.json', '.chisle-compress-last.json']) {
+      const p = path.join(homeDir(), '.config', 'opencode', f);
+      if (fs.existsSync(p)) { if (!opts.dryRun) fs.rmSync(p, { recursive: true, force: true }); note('  removed ' + p); touched++; }
+    }
+  }
+
+  if (wants('hermes')) {
+    const hSkills = path.join(homeDir(), '.hermes', 'skills');
+    const hGone = opts.dryRun ? ownedSkillNames().filter(function (nm) { return fs.existsSync(path.join(hSkills, nm)); }).length : pruneSkills(hSkills);
+    if (hGone > 0) { note('  removed ' + hGone + ' chisle skill dir(s) from ' + hSkills); touched++; }
+  }
+
   if (!opts.only.length || opts.only.some(id => PROVIDERS.find(p => p.id === id).scope === 'project')) {
     note('');
     note('Project-scoped rule files (.cursor/, .windsurf/, .clinerules/, .kiro/, .github/copilot-instructions.md)');
@@ -618,6 +850,8 @@ function main() {
     else if (p.id === 'pi') installPi(ctx);
     else if (p.id === 'gemini') installGemini(ctx);
     else if (p.id === 'codex') installCodex(ctx);
+    else if (p.id === 'opencode') installOpencode(ctx);
+    else if (p.id === 'hermes') installHermes(ctx);
     else installProjectRule(ctx, p);
   }
 

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