chisle 3.2.1 → 3.4.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "3.2.1",
+  "version": "3.4.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 |
@@ -340,7 +342,7 @@ node benchmarks/replay-compress.js       # Claude Code
 node benchmarks/replay-compress.js pi    # Pi
 ```
 
-Outputs over 8k chars are elided. `stop chisle`, `CHISLE_COMPRESS=0`, `CHISLE_COMPRESS_SCRUB=0`, `CHISLE_COMPRESS_DEDUP=0`. Every tier has an off switch.
+Outputs over 8k chars are elided, and the elided original spills to `<config>/chisle-spill/` so the dropped middle stays reachable. The marker carries the path, so recovering one line is a targeted grep rather than a re-run of the command, which matters most when the command is not idempotent: a test run, a build, a `git log` at a moment in time. The newest 40 spills are kept, owner-readable only. `stop chisle`, `CHISLE_COMPRESS=0`, `CHISLE_COMPRESS_SCRUB=0`, `CHISLE_COMPRESS_DEDUP=0`, `CHISLE_COMPRESS_SPILL=0`. Every tier has an off switch.
 
 ### Pi arm: where the output axis lost
 
@@ -464,7 +466,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;
@@ -458,8 +654,10 @@ function uninstall(ctx) {
         touched++;
       }
     }
-    const hooksDst = path.join(cfg, 'chisle-hooks');
-    if (fs.existsSync(hooksDst)) { if (!opts.dryRun) fs.rmSync(hooksDst, { recursive: true, force: true }); note(`  removed ${hooksDst}`); touched++; }
+    for (const d of ['chisle-hooks', 'chisle-spill']) {
+      const dst = path.join(cfg, d);
+      if (fs.existsSync(dst)) { if (!opts.dryRun) fs.rmSync(dst, { recursive: true, force: true }); note(`  removed ${dst}`); touched++; }
+    }
 
     for (const f of ['.chisle-active', '.chisle-session-turns', '.chisle-statusline-suffix',
                      '.chisle-compress-stats.json', '.chisle-compress-last.json', '.chisle-update-check.json']) {
@@ -471,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)) {
@@ -487,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)');
@@ -616,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-compress-output.js

@@ -5,8 +5,20 @@
 // Oversized tool results (Bash dumps, subagent reports, web fetches) get their
 // repetitive middle elided — head kept (command context), tail kept (results/
 // errors), error-looking lines salvaged from the cut — and the trimmed version
-// replaces what the model sees via `updatedToolOutput`. Deterministic, zero
-// LLM, zero network. Small outputs pass through untouched.
+// replaces what the model sees. Deterministic, zero LLM, zero network. Small
+// outputs pass through untouched.
+//
+// Two harnesses call into this same core:
+//   - Claude Code / Pi: `updatedToolOutput`, snake_case payload
+//     (tool_name, tool_response, session_id, tool_use_id), gated behind the
+//     /chisle on/off flag file (see chisle-config.js: getDefaultMode/readFlag).
+//   - GitHub Copilot CLI: `modifiedResult.textResultForLlm`, camelCase flat
+//     payload (toolName, toolResult.textResultForLlm, sessionId). Copilot has
+//     no /chisle-equivalent mode toggle (no UserPromptSubmit-driven flag), so
+//     compression is always-on for Copilot once the hook is installed —
+//     exactly like the static ruleset Copilot already gets unconditionally
+//     (see README: "the always-on ruleset still ships to every other agent").
+//     CHISLE_COMPRESS=0 is still honored as the one kill switch for both.
 //
 // Correctness guardrails (why this never touches Read/Edit/Write):
 //   - Read output feeds later Edit old_string matching — eliding it makes the
@@ -23,21 +35,27 @@
 // Plus dedup: a tool output byte-identical to that tool's immediately previous
 // output is replaced by a short marker — the content is already in context.
 //
-// Compression follows the /chisle flag (off → untouched). Tunables via env:
+// Compression follows the /chisle flag for Claude/Pi (off → untouched); it is
+// unconditional for Copilot (see above). Tunables via env, shared across all
+// three harnesses:
 //   CHISLE_COMPRESS=0                 — kill switch
 //   CHISLE_COMPRESS_SCRUB=0           — disable the lossless scrub tier
 //   CHISLE_COMPRESS_DEDUP=0           — disable duplicate-output markers
 //   CHISLE_COMPRESS_MAX_CHARS         — outputs at/under this size are not elided
 //   CHISLE_COMPRESS_HEAD_LINES        — lines kept from the top
 //   CHISLE_COMPRESS_TAIL_LINES        — lines kept from the bottom
-//   CHISLE_COMPRESS_TOOLS=Bash,Grep   — override the tool allowlist
+//   CHISLE_COMPRESS_TOOLS=Bash,Grep   — override the tool allowlist (both harnesses)
+//   CHISLE_COMPRESS_SPILL=0           — elide without writing the recovery copy
 //
-// Savings accrue in <claudeDir>/.chisle-compress-stats.json for the statusline.
+// Savings accrue in <stateDir>/.chisle-compress-stats.json for the statusline
+// (Claude/Pi: <claudeDir>; Copilot: <copilotDir>, see chisle-config.js).
+// Elided originals spill to <stateDir>/chisle-spill/ so the dropped middle can
+// be grepped back instead of re-running the command; the newest 40 are kept.
 
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const { getClaudeDir, readFlag } = require('./chisle-config');
+const { getClaudeDir, getCopilotDir, getOpencodeDir, readFlag } = require('./chisle-config');
 
 // One threshold. Env overrides all.
 // These are the values the old 'full' level used — the default,
@@ -47,18 +65,105 @@ const THRESHOLDS = { maxChars: 8000, headLines: 60, tailLines: 40 };
 // Tools whose output is safe to elide. Read/Edit/Write are absent on purpose:
 // their output feeds exact-match edits. mcp__* are read-only info tools.
 const SAFE_TOOLS = ['Bash', 'Agent', 'WebFetch', 'WebSearch', 'Grep', 'Glob'];
+
+// The correctness invariant, enforced rather than merely defaulted: these tools'
+// output feeds later exact-match edits, so eliding it makes the model edit text
+// it never saw. CHISLE_COMPRESS_TOOLS is an override for the *allowlist*, not a
+// way to switch this off — the Pi extension (NEVER_COMPRESS) and the OpenCode
+// path (UNSAFE_TOOLS_OPENCODE) have always checked it first, and this is the
+// same guard for the Claude/Pi hook payloads.
+const NEVER_COMPRESS = ['read', 'edit', 'write', 'multiedit', 'notebookedit', 'notebookread'];
+
+// Copilot CLI's own runtime tool names (lowercase, no mcp__ prefix scheme).
+// Same allowlist rule as SAFE_TOOLS: Copilot's Read/Edit/Write equivalents
+// are `view`/`create`/`edit` and are deliberately absent here too. Verified
+// against Copilot CLI's real tool set, not guessed — see the accompanying PR
+// description for the live-verification evidence (Beyin chisle-port project).
+const SAFE_TOOLS_COPILOT = ['bash', 'powershell', 'grep', 'glob', 'web_fetch', 'web_search', 'task'];
+// Copilot's Read/Edit/Write family, hard-blocked for the same reason as
+// NEVER_COMPRESS above — not merely absent from the allowlist.
+const NEVER_COMPRESS_COPILOT = ['view', 'create', 'edit', 'str_replace', 'insert'];
+
 const SALVAGE_RE = /\b(error|err!|fail(ed|ure|ing)?|exception|traceback|panic|fatal|denied|refused|timed?[ _-]?out|assert(ion)?|segfault|npe|undefined reference|cannot find|not found|warning)\b/i;
 const MAX_SALVAGED = 12;      // error lines rescued from the elided middle
 const MAX_SALVAGE_LINE = 300; // per-line char cap on salvaged lines
 
 function toolAllowed(name) {
   if (!name || typeof name !== 'string') return false;
+  if (NEVER_COMPRESS.includes(name.toLowerCase())) return false;
   const list = process.env.CHISLE_COMPRESS_TOOLS
     ? process.env.CHISLE_COMPRESS_TOOLS.split(',').map(s => s.trim()).filter(Boolean)
     : SAFE_TOOLS;
   return list.includes(name) || (!process.env.CHISLE_COMPRESS_TOOLS && name.startsWith('mcp__'));
 }
 
+// Same override semantics as toolAllowed, against Copilot's tool-name scheme.
+function copilotToolAllowed(name) {
+  if (!name || typeof name !== 'string') return false;
+  if (NEVER_COMPRESS_COPILOT.includes(name.toLowerCase())) return false;
+  const list = process.env.CHISLE_COMPRESS_TOOLS
+    ? process.env.CHISLE_COMPRESS_TOOLS.split(',').map(s => s.trim()).filter(Boolean)
+    : SAFE_TOOLS_COPILOT;
+  return list.includes(name);
+}
+
+// OpenCode runtime tool names are lowercase (bash, grep, glob, webfetch, ...)
+// and MCP tools are `server_tool` (an underscore), not Claude's mcp__ prefix.
+// read/edit/write/patch are excluded on purpose: their output feeds exact-match
+// edits, exactly as SAFE_TOOLS omits Read/Edit/Write.
+const SAFE_TOOLS_OPENCODE = ['bash', 'grep', 'glob', 'webfetch', 'websearch', 'task', 'list'];
+const UNSAFE_TOOLS_OPENCODE = ['read', 'edit', 'write', 'patch', 'todowrite', 'todoread'];
+
+function opencodeToolAllowed(name) {
+  if (!name || typeof name !== 'string') return false;
+  const lower = name.toLowerCase();
+  // read/edit/write/patch are never compressed, even via CHISLE_COMPRESS_TOOLS:
+  // their output feeds exact-match edits (the invariant INSTALL.md promises).
+  if (UNSAFE_TOOLS_OPENCODE.includes(lower)) return false;
+  if (process.env.CHISLE_COMPRESS_TOOLS) {
+    return process.env.CHISLE_COMPRESS_TOOLS
+      .split(',').map(s => s.trim()).filter(Boolean).includes(name);
+  }
+  if (SAFE_TOOLS_OPENCODE.includes(lower)) return true;
+  // Heuristic: underscore = MCP `server_tool`, treated as read-only info tool
+  // like SAFE_TOOLS' mcp__ clause. Set CHISLE_COMPRESS_TOOLS to override if a
+  // custom underscore-named tool ever needs protecting.
+  return name.includes('_');
+}
+
+// One OpenCode tool_result → replacement string, or null to keep the original.
+// The plugin passes output.output (already a plain string), so no extractText/
+// rebuild dance is needed — just gate on mode/kill-switch/allowlist and reuse
+// the shared scrub+elide core. stateDir keeps spill/recovery beside OpenCode's
+// config (CHISLE_STATE_DIR overrides, used by tests).
+//
+// Fires for the common case: outputs under OpenCode's own on-disk store limits
+// (~50 KB / 2000 lines) arrive here FULL, both in tool.execute.after (whose
+// mutation persists to the tool part's state.output) and again, request-time,
+// in experimental.chat.messages.transform. Larger outputs arrive as OpenCode's
+// notice plus a retained tail; the tail still compresses here.
+function compressForOpencode(toolName, text, opts) {
+  opts = opts || {};
+  if (opts.mode === 'off') return null;
+  if (process.env.CHISLE_COMPRESS === '0') return null;
+  if (!opencodeToolAllowed(toolName)) return null;
+  if (typeof text !== 'string' || !text) return null;
+  const stateDir = opts.stateDir || process.env.CHISLE_STATE_DIR || getOpencodeDir();
+  return transform(text, limitsFor(), toolName, stateDir);
+}
+
+// Copilot CLI's postToolUse payload is flat and camelCase:
+//   { sessionId, timestamp, cwd, toolName, toolArgs,
+//     toolResult: { resultType: "success", textResultForLlm: string } }
+// Detected structurally (no explicit "harness" field exists on either
+// payload shape), by the presence of toolResult.textResultForLlm together
+// with the camelCase toolName — Claude/Pi payloads use tool_name/tool_response
+// and never carry this shape.
+function isCopilotPayload(payload) {
+  return !!(payload && typeof payload.toolName === 'string' &&
+    payload.toolResult && typeof payload.toolResult.textResultForLlm === 'string');
+}
+
 function envInt(name, fallback) {
   const n = parseInt(process.env[name], 10);
   return Number.isFinite(n) && n > 0 ? n : fallback;
@@ -74,6 +179,7 @@ function limitsFor() {
 }
 
 // Pull a plain-text payload out of tool_response, whatever its shape.
+// Also handles Copilot's already-flat textResultForLlm string unchanged.
 function extractText(response) {
   if (response == null) return null;
   if (typeof response === 'string') return response;
@@ -140,12 +246,16 @@ function duplicateMarker(toolName, text, reference = 'previous') {
     ' lines, unchanged. First lines:]\n' + preview.join('\n');
 }
 
-function dedupCheck(toolName, text, sessionId, toolUseId) {
+// `stateDir` defaults to getClaudeDir() so every existing Claude/Pi call site
+// and test (none of which pass a third argument) keeps its exact prior
+// behaviour. Copilot's caller (processPayload, below) passes getCopilotDir().
+function dedupCheck(toolName, text, sessionId, toolUseId, stateDir) {
   if (process.env.CHISLE_COMPRESS_DEDUP === '0') return null;
   if (!sessionId || typeof sessionId !== 'string') return null;
   if (text.length < DEDUP_MIN) return null;
   try {
-    const p = path.join(getClaudeDir(), '.chisle-compress-last.json');
+    const dir = stateDir || getClaudeDir();
+    const p = path.join(dir, '.chisle-compress-last.json');
     try { if (fs.lstatSync(p).isSymbolicLink()) return null; } catch (e) { if (e.code !== 'ENOENT') return null; }
     let state = {};
     try { state = JSON.parse(fs.readFileSync(p, 'utf8')) || {}; } catch (e) {}
@@ -164,6 +274,7 @@ function dedupCheck(toolName, text, sessionId, toolUseId) {
     const sameCall = !!(toolUseId && rec.id && rec.id === toolUseId);
     const dup = rec.hash === hash && !sameCall;
     state.tools[toolName] = { hash, id: toolUseId || rec.id || null };
+    fs.mkdirSync(dir, { recursive: true });
     const tmp = p + '.' + process.pid + '.tmp';
     fs.writeFileSync(tmp, JSON.stringify(state), { mode: 0o600 });
     fs.renameSync(tmp, p);
@@ -174,17 +285,59 @@ function dedupCheck(toolName, text, sessionId, toolUseId) {
 // ── Tier 2: elision ──────────────────────────────────────────────────────────
 // Keep head + tail; salvage error-looking lines from the elided middle so the
 // one line that mattered in a 3000-line build log survives the cut.
-function compress(text, limits) {
+// ── recoverable elision ─────────────────────────────────────────────────────
+// Elision used to destroy the middle. If the agent then needed a line from it,
+// its only recourse was re-running the command: more expensive than the elision
+// saved, and wrong outright when the command is not idempotent (a test run, a
+// build, `git log` at a moment in time). So the full text spills to disk first
+// and the marker carries the path. Recovery becomes a targeted grep instead of
+// a re-run. Best-effort throughout: if the spill fails, the elision still
+// happens, it just loses the escape hatch.
+const SPILL_DIR = 'chisle-spill';
+const SPILL_KEEP = 40;
+
+function spillDir(stateDir) {
+  return path.join(stateDir || getClaudeDir(), SPILL_DIR);
+}
+
+// Keep the directory bounded. Oldest-first by mtime; cheap enough at this size
+// and it runs at most once per elided output.
+function pruneSpill(dir) {
+  try {
+    const files = fs.readdirSync(dir)
+      .filter(f => f.endsWith('.txt'))
+      .map(f => { const p = path.join(dir, f); return { p, t: fs.statSync(p).mtimeMs }; })
+      .sort((a, b) => b.t - a.t);
+    for (const f of files.slice(SPILL_KEEP)) { try { fs.unlinkSync(f.p); } catch (e) {} }
+  } catch (e) {}
+}
+
+function spill(text, toolName, stateDir) {
+  if (process.env.CHISLE_COMPRESS_SPILL === '0') return null;
+  try {
+    const dir = spillDir(stateDir);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const hash = crypto.createHash('sha256').update(text).digest('hex').slice(0, 12);
+    const safeTool = String(toolName || 'tool').replace(/[^A-Za-z0-9_-]/g, '') || 'tool';
+    const file = path.join(dir, `${safeTool}-${hash}.txt`);
+    if (!fs.existsSync(file)) fs.writeFileSync(file, text, { mode: 0o600 });
+    pruneSpill(dir);
+    return file;
+  } catch (e) { return null; }
+}
+
+function compress(text, limits, spillPath) {
   const { maxChars, headLines, tailLines } = limits;
   const lines = text.split('\n');
+  const recover = spillPath ? ' Full output: ' + spillPath + ' (grep it, do not re-run)' : '';
 
   if (lines.length <= headLines + tailLines) {
-    // Big in bytes, few lines (one giant line) — hard char cut.
+    // Big in bytes, few lines (one giant line): hard char cut.
     const keep = Math.floor(maxChars / 2);
     const elided = text.length - 2 * keep;
     if (elided <= 0) return null;
     return text.slice(0, keep) +
-      '\n... [chisle: elided ' + elided.toLocaleString('en-US') + ' chars from the middle] ...\n' +
+      '\n... [chisle: elided ' + elided.toLocaleString('en-US') + ' chars from the middle.' + recover + '] ...\n' +
       text.slice(-keep);
   }
 
@@ -199,8 +352,9 @@ function compress(text, limits) {
   }
 
   const marker = '... [chisle: elided ' + middle.length.toLocaleString('en-US') +
-    ' lines — kept first ' + headLines + ', last ' + tailLines +
-    (salvaged.length ? ', and ' + salvaged.length + ' error-like line(s) below' : '') + '] ...';
+    ' lines, kept first ' + headLines + ', last ' + tailLines +
+    (salvaged.length ? ', and ' + salvaged.length + ' error-like line(s) below' : '') +
+    '.' + recover + '] ...';
 
   const out = head.concat([marker], salvaged, tail).join('\n');
   return out.length < text.length ? out : null;
@@ -208,9 +362,10 @@ function compress(text, limits) {
 
 // Best-effort savings ledger. Races between parallel tool calls can drop a
 // count — stats only, never worth a lock file.
-function recordSavings(saved) {
+function recordSavings(saved, stateDir) {
   try {
-    const p = path.join(getClaudeDir(), '.chisle-compress-stats.json');
+    const dir = stateDir || getClaudeDir();
+    const p = path.join(dir, '.chisle-compress-stats.json');
     try { if (fs.lstatSync(p).isSymbolicLink()) return; } catch (e) { if (e.code !== 'ENOENT') return; }
     let stats = { savedChars: 0, events: 0 };
     try {
@@ -219,6 +374,7 @@ function recordSavings(saved) {
     } catch (e) {}
     stats.savedChars += saved;
     stats.events += 1;
+    fs.mkdirSync(dir, { recursive: true });
     const tmp = p + '.' + process.pid + '.tmp';
     fs.writeFileSync(tmp, JSON.stringify(stats), { mode: 0o600 });
     fs.renameSync(tmp, p);
@@ -226,12 +382,13 @@ function recordSavings(saved) {
 }
 
 // Scrub + elide on plain text → transformed text, or null if no meaningful
-// win. Stateless — this is what the replay benchmark measures.
-function transform(text, limits) {
+// win. Stateless (aside from the spill side-effect) — this is what the
+// replay benchmark measures for Claude/Pi.
+function transform(text, limits, toolName, stateDir) {
   if (!text || text.length <= SCRUB_MIN) return null;
   let t = process.env.CHISLE_COMPRESS_SCRUB === '0' ? text : scrub(text);
   if (t.length > limits.maxChars) {
-    const elided = compress(t, limits);
+    const elided = compress(t, limits, toolName ? spill(t, toolName, stateDir) : null);
     if (elided != null) t = elided;
   }
   return text.length - t.length >= MIN_WIN ? t : null;
@@ -245,6 +402,10 @@ function transform(text, limits) {
 // work, logs savings, and the model still receives the full output. Returning
 // null (skip) is always safer than emitting a shape the harness will refuse.
 // Reported with the transcript evidence by @sovdchains (#3).
+//
+// Not used for Copilot: its toolResult.textResultForLlm is already a flat
+// string, so main() builds { modifiedResult: { textResultForLlm } } directly
+// and never calls this function for a Copilot-shaped payload.
 function rebuildResponse(response, updated) {
   if (response == null || typeof response === 'string') return updated;
   if (typeof response === 'object' && !Array.isArray(response)) {
@@ -264,18 +425,35 @@ function rebuildResponse(response, updated) {
 }
 
 // Full pipeline on one hook payload → updated output string, or null to keep
-// the original. Pure given (payload, mode, env) except dedup state.
+// the original. Pure given (payload, mode, env) except dedup/spill/stats state.
+//
+// `mode` keeps meaning "off disables everything" for Claude/Pi, exactly as
+// before. For a Copilot-shaped payload the caller (main()) always passes
+// 'on' — Copilot has no /chisle toggle to read a flag file for — so this
+// function's Copilot branch below never actually sees 'off' in practice, but
+// still honors it if a future caller passes it explicitly.
 function processPayload(payload, mode) {
   if (!payload || typeof payload !== 'object') return null;
   if (!mode || mode === 'off') return null;
   if (process.env.CHISLE_COMPRESS === '0') return null;
-  if (!toolAllowed(payload.tool_name)) return null;
 
+  if (isCopilotPayload(payload)) {
+    const toolName = payload.toolName;
+    if (!copilotToolAllowed(toolName)) return null;
+    const text = payload.toolResult.textResultForLlm;
+    if (!text) return null;
+    const stateDir = getCopilotDir();
+    const dup = dedupCheck(toolName, text, payload.sessionId, null, stateDir);
+    if (dup != null && dup.length < text.length) return dup;
+    return transform(text, limitsFor(), toolName, stateDir);
+  }
+
+  if (!toolAllowed(payload.tool_name)) return null;
   const text = extractText(payload.tool_response != null ? payload.tool_response : payload.tool_output);
   if (!text) return null;
-  const dup = dedupCheck(payload.tool_name, text, payload.session_id, payload.tool_use_id);
+  const dup = dedupCheck(payload.tool_name, text, payload.session_id, payload.tool_use_id, getClaudeDir());
   if (dup != null && dup.length < text.length) return dup;
-  return transform(text, limitsFor());
+  return transform(text, limitsFor(), payload.tool_name, getClaudeDir());
 }
 
 function main() {
@@ -284,9 +462,30 @@ function main() {
   process.stdin.on('end', () => {
     try {
       const payload = JSON.parse(input.replace(/^/, ''));
-      const mode = readFlag(path.join(getClaudeDir(), '.chisle-active'));
+      const copilot = isCopilotPayload(payload);
+
+      // Copilot has no /chisle mode-toggle mechanism (no UserPromptSubmit
+      // hook wired for it yet, so there is nothing to flip a flag file with):
+      // treat it as always-on, matching the always-on ruleset it already
+      // gets. Claude/Pi keep reading the real flag file exactly as before.
+      const mode = copilot ? 'on' : readFlag(path.join(getClaudeDir(), '.chisle-active'));
+
       const updated = processPayload(payload, mode);
       if (updated == null) return;
+
+      if (copilot) {
+        const original = payload.toolResult.textResultForLlm;
+        recordSavings(original.length - updated.length, getCopilotDir());
+        // Echo back the result type we were handed. Hard-coding 'success'
+        // would relabel a failed tool call as a successful one on its way to
+        // the model — the compressor only ever rewrites text, never status.
+        const resultType = payload.toolResult.resultType || 'success';
+        process.stdout.write(JSON.stringify({
+          modifiedResult: { resultType, textResultForLlm: updated },
+        }));
+        return;
+      }
+
       const response = payload.tool_response != null ? payload.tool_response : payload.tool_output;
       const rebuilt = rebuildResponse(response, updated);
       // Shape we can't safely rebuild — emit nothing and count nothing.
@@ -294,7 +493,7 @@ function main() {
       const original = extractText(response);
       // Only after we know a replacement is actually going out, so the stats
       // file stops crediting savings the harness never applied.
-      recordSavings(original.length - updated.length);
+      recordSavings(original.length - updated.length, getClaudeDir());
       process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
           hookEventName: 'PostToolUse',
@@ -307,4 +506,12 @@ function main() {
 
 if (require.main === module) main();
 
-module.exports = { extractText, rebuildResponse, scrub, compress, transform, limitsFor, toolAllowed, processPayload, duplicateMarker, THRESHOLDS, SAFE_TOOLS };
+module.exports = {
+  extractText, rebuildResponse, scrub, compress, transform, limitsFor, toolAllowed, processPayload,
+  duplicateMarker, THRESHOLDS, SAFE_TOOLS, NEVER_COMPRESS,
+  // Copilot-specific additions (see PR description for rationale):
+  isCopilotPayload, copilotToolAllowed, SAFE_TOOLS_COPILOT, NEVER_COMPRESS_COPILOT,
+  // OpenCode-specific additions (plugin uses tool.execute.after +
+  // experimental.chat.messages.transform):
+  opencodeToolAllowed, compressForOpencode, SAFE_TOOLS_OPENCODE,
+};

package/hooks/chisle-config.js

@@ -38,6 +38,25 @@ function getClaudeDir() {
   return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
 }
 
+// OpenCode's global config dir. The compressor plugin keeps its spill/dedup/
+// stats here (as Copilot uses getCopilotDir), so recovery files sit beside
+// OpenCode's own config instead of leaking into ~/.claude.
+function getOpencodeDir() {
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(process.env.XDG_CONFIG_HOME, 'opencode');
+  }
+  return path.join(os.homedir(), '.config', 'opencode');
+}
+
+// GitHub Copilot CLI's own user-level state directory (mirrors the
+// CLAUDE_CONFIG_DIR precedent above). Copilot CLI already reads/writes hook
+// config under this same directory (~/.copilot/hooks/), so chisle's
+// dedup/spill/stats state lives alongside it rather than under ~/.claude,
+// which would be misleading for a machine that never runs Claude Code.
+function getCopilotDir() {
+  return process.env.COPILOT_HOME || path.join(os.homedir(), '.copilot');
+}
+
 function getConfigDir() {
   if (process.env.XDG_CONFIG_HOME) {
     return path.join(process.env.XDG_CONFIG_HOME, 'chisle');
@@ -172,6 +191,6 @@ function readFlag(flagPath) {
 }
 
 module.exports = {
-  LEGACY_MODES, legacySetting, getDefaultMode, getClaudeDir,
+  LEGACY_MODES, legacySetting, getDefaultMode, getClaudeDir, getCopilotDir, getOpencodeDir,
   VALID_MODES, safeWriteFlag, readFlag,
 };

package/package.json

@@ -1,12 +1,27 @@
 {
   "name": "chisle",
-  "version": "3.2.1",
+  "version": "3.4.0",
   "description": "Maximum-efficiency dev mode for AI coding agents. Zero-fluff prose, YAGNI-first code, and safe tool-output compression.",
   "keywords": [
     "claude-code",
     "claude-code-plugin",
     "pi-package",
     "pi-coding-agent",
+    "token-optimization",
+    "token-reduction",
+    "context-compression",
+    "llm",
+    "ai",
+    "anthropic",
+    "cost-optimization",
+    "cursor",
+    "codex",
+    "copilot",
+    "opencode",
+    "hermes-agent",
+    "hermes",
+    "gemini",
+    "agents",
     "productivity",
     "yagni",
     "minimal"
@@ -40,6 +55,14 @@
   "engines": {
     "node": ">=18"
   },
+  "omp": {
+    "extensions": [
+      "./pi-extension/index.cjs"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
   "pi": {
     "extensions": [
       "./pi-extension/index.js"
@@ -72,6 +95,7 @@
     ".kiro/",
     ".github/copilot-instructions.md",
     ".claude-plugin/",
+    ".opencode/",
     "README.md",
     "LICENSE"
   ],

package/pi-extension/index.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+// OMP entry point. OMP only maps `module.exports` onto `default` for modules it
+// classifies as graph-owned CommonJS, and its classifier excludes the entry file
+// itself unless the filename ends in `.cjs` (see isGraphOwnedCommonJsModule in
+// oh-my-pi's legacy-pi-compat.ts). A CommonJS entry named `.js` is imported as
+// ESM, so `default` is undefined and the factory lookup fails with
+// "Extension does not export a valid factory function".
+//
+// Requiring index.js from here makes it a graph-owned dependency, which the
+// classifier does handle, so both runtimes get the same factory. Pi keeps
+// loading index.js directly via the `pi` manifest block below.
+module.exports = require('./index.js');

package/pi-extension/index.js

@@ -166,7 +166,7 @@ function chisleExtension(pi) {
           lastByToolBlock.set(key, hash);
           if (previous === hash) updated = duplicateMarker(event.toolName, text, 'earlier');
         }
-        if (updated == null) updated = transform(text, limitsFor());
+        if (updated == null) updated = transform(text, limitsFor(), event.toolName);
         if (updated == null || updated.length >= text.length) return block;
         changed = true;
         savedChars += text.length - updated.length;