chisle 3.6.1 → 3.8.0

package/bin/install.js

@@ -7,9 +7,10 @@
 //   - 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
+//   - Copilot CLI  → fenced ruleset + postToolUse compression hook in ~/.copilot
+//   - OpenCode     → fenced ruleset + skills + plugin in its global config root
 //   - Hermes       → skills copy in ~/.hermes/skills (Agent Skills standard)
-//   - Cursor/Windsurf/Cline/Kiro/Copilot → project rule file dropped into CWD
+//   - Cursor/Windsurf/Cline/Kiro/Copilot/Antigravity → project rule file dropped into CWD
 //
 // Usage:
 //   npx chisle                 auto-detect + install
@@ -17,6 +18,7 @@
 //   npx chisle --only claude   install for one agent
 //   npx chisle --dry-run       print actions, change nothing
 //   npx chisle --uninstall     remove what we installed
+//   npx chisle mcp wrap        route stdio MCP servers through the compressor
 //   npx chisle --help
 //
 // Pure stdlib, zero runtime deps.
@@ -29,6 +31,8 @@ const path = require('path');
 const cp = require('child_process');
 
 const SETTINGS = require('./lib/settings');
+const MCP = require('./lib/mcp');
+const { getOpencodeDir, getOpencodeStateDir } = require('../hooks/chisle-config');
 
 const REPO = 'JayPokale/Chisle';
 const IS_WIN = process.platform === 'win32';
@@ -45,7 +49,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: 'copilot-cli', label: 'Copilot CLI', scope: 'global',  detect: 'cmd:copilot' },
+  { id: 'opencode', label: 'OpenCode',        scope: 'global',  detect: 'cmd: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' },
@@ -57,6 +62,10 @@ const PROVIDERS = [
     rule: '.kiro/steering/chisle.md' },
   { id: 'copilot',  label: 'GitHub Copilot',scope: 'project', detect: 'vscode-ext:github.copilot||vscode-ext:github.copilot-chat',
     rule: '.github/copilot-instructions.md' },
+  // Antigravity IDE (`antigravity`) and its CLI (`agy`, antigravity-cli) both
+  // load workspace rules from .agents/rules/*.md.
+  { id: 'antigravity', label: 'Antigravity', scope: 'project', detect: 'cmd:antigravity||cmd:agy||dir:~/.antigravity',
+    rule: '.agents/rules/chisle.md' },
 ];
 
 // ── argv ────────────────────────────────────────────────────────────────────
@@ -146,6 +155,11 @@ function detectMatch(spec) {
   return false;
 }
 
+function providerDetected(provider) {
+  return detectMatch(provider.detect) ||
+    (provider.id === 'opencode' && safeStat(opencodeDir(), 'isDirectory'));
+}
+
 // ── spawn helpers ───────────────────────────────────────────────────────────
 function quoteWin(a) {
   if (!IS_WIN) return a;
@@ -184,6 +198,11 @@ function claudeDir(opts) {
 // (tests, containers); mirrors the CLAUDE_CONFIG_DIR precedent for Claude.
 function homeDir() { return process.env.CHISLE_HOME || os.homedir(); }
 
+function opencodeDir() { return getOpencodeDir({ home: homeDir() }); }
+// Copilot CLI reads hooks, instructions and MCP config under COPILOT_HOME.
+function copilotDir() { return process.env.COPILOT_HOME || path.join(homeDir(), '.copilot'); }
+function opencodeStateDir() { return getOpencodeStateDir({ home: 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
@@ -221,13 +240,15 @@ function installedFor(id, opts) {
       }
       case 'opencode': {
         try {
-          const md = path.join(homeDir(), '.config', 'opencode', 'AGENTS.md');
+          const md = path.join(opencodeDir(), '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'));
+        return fs.existsSync(path.join(opencodeDir(), 'skills', 'chisle', 'SKILL.md'));
       }
       case 'hermes':
         return fs.existsSync(path.join(homeDir(), '.hermes', 'skills', 'chisle', 'SKILL.md'));
+      case 'copilot-cli':
+        return fs.existsSync(path.join(copilotDir(), 'hooks', 'chisle.json'));
       default: {
         const prov = PROVIDERS.find(x => x.id === id);
         return !!(prov && prov.rule && fs.existsSync(path.join(process.cwd(), prov.rule)));
@@ -506,13 +527,13 @@ function installCodex(ctx) {
 }
 
 // ── 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
+// Global AGENTS.md carries the always-on output axis next to existing user
+// instructions; the bundled skills copy under the same OpenCode config root
+// 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
+// requires into the configured OpenCode plugins directory. It auto-discovers *.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),
@@ -523,8 +544,8 @@ function installCodex(ctx) {
 // 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');
+function copyOpencodePlugin(root) {
+  const pluginDir = path.join(root, 'plugins');
   const hooksDir = path.join(pluginDir, 'chisle-hooks');
   const files = [
     ['.opencode/plugins/chisle.mjs', path.join(pluginDir, 'chisle.js')],
@@ -546,9 +567,10 @@ 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');
+  const root = opencodeDir();
+  const target = path.join(root, 'AGENTS.md');
+  const skillsDst = path.join(root, 'skills');
+  const pluginDst = path.join(root, 'plugins');
 
   if (opts.dryRun) {
     note('  would write chisle ruleset to ' + target);
@@ -563,7 +585,7 @@ function installOpencode(ctx) {
     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();
+    const p = copyOpencodePlugin(root);
     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']);
@@ -571,6 +593,65 @@ function installOpencode(ctx) {
   process.stdout.write('\n');
 }
 
+// ── Copilot CLI ─────────────────────────────────────────────────────────────
+// Rules: fenced block in ~/.copilot/copilot-instructions.md, Copilot CLI's
+// user-level instructions file. Input axis: a user-level postToolUse hook
+// (~/.copilot/hooks/chisle.json, no workspace admission needed) running the
+// shared compressor, which already speaks Copilot's camelCase payload and
+// answers with modifiedResult. Verified live on Copilot CLI 1.0.95: a
+// 13.9k-char shell result reached the model at ~100 lines with the mid-log
+// error line and the `<shellId: 0 completed with exit code 0>` tail intact.
+function copilotHookConfig(hookPath) {
+  return JSON.stringify({
+    version: 1,
+    hooks: {
+      postToolUse: [{
+        type: 'command',
+        bash: 'node "' + hookPath + '"',
+        powershell: 'node "' + hookPath + '"',
+        timeoutSec: 10,
+      }],
+    },
+  }, null, 2) + '\n';
+}
+
+function installCopilotCli(ctx) {
+  const { say, note, opts, results } = ctx;
+  results.detected++;
+  say('\u2192 Copilot CLI detected');
+  const root = copilotDir();
+  const rules = path.join(root, 'copilot-instructions.md');
+  const hooksDir = path.join(root, 'chisle-hooks');
+  const hookFile = path.join(root, 'hooks', 'chisle.json');
+
+  if (opts.dryRun) {
+    note('  would write chisle ruleset to ' + rules);
+    note('  would copy compressor to ' + hooksDir);
+    note('  would write postToolUse hook ' + hookFile);
+    results.installed.push('copilot-cli');
+    process.stdout.write('\n');
+    return;
+  }
+
+  try {
+    const st = writeFencedRuleset(rules, opts, note);
+    fs.mkdirSync(hooksDir, { recursive: true });
+    for (const f of ['chisle-compress-output.js', 'chisle-config.js']) {
+      fs.copyFileSync(path.join(REPO_ROOT, 'hooks', f), path.join(hooksDir, f));
+    }
+    fs.writeFileSync(path.join(hooksDir, 'package.json'), '{ "type": "commonjs" }\n');
+    const hookExisted = fs.existsSync(hookFile);
+    if (!hookExisted || opts.force) {
+      fs.mkdirSync(path.dirname(hookFile), { recursive: true });
+      fs.writeFileSync(hookFile, copilotHookConfig(path.join(hooksDir, 'chisle-compress-output.js')), { mode: 0o644 });
+      process.stdout.write('  installed: ' + hookFile + '\n');
+    }
+    if (st === 'installed' || !hookExisted) results.installed.push('copilot-cli');
+    else results.skipped.push(['copilot-cli', 'already present; compressor refreshed']);
+  } catch (e) { results.failed.push(['copilot-cli', (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:
@@ -597,7 +678,7 @@ function installHermes(ctx) {
   process.stdout.write('\n');
 }
 
-// ── Project-scoped rule agents (Cursor/Windsurf/Cline/Kiro/Copilot) ─────────
+// ── Project-scoped rule agents (Cursor/Windsurf/Cline/Kiro/Copilot/Antigravity)
 function installProjectRule(ctx, prov) {
   const { say, note, warn, opts, results } = ctx;
   results.detected++;
@@ -686,7 +767,9 @@ function uninstall(ctx) {
   }
 
   if (wants('opencode')) {
-    const ocMd = path.join(homeDir(), '.config', 'opencode', 'AGENTS.md');
+    const ocRoot = opencodeDir();
+    const ocState = opencodeStateDir();
+    const ocMd = path.join(ocRoot, 'AGENTS.md');
     if (fs.existsSync(ocMd)) {
       const txt = fs.readFileSync(ocMd, 'utf8');
       const b = txt.indexOf(FENCE_BEGIN);
@@ -700,17 +783,17 @@ function uninstall(ctx) {
         note('  removed chisle block from ' + ocMd); touched++;
       }
     }
-    const ocSkills = path.join(homeDir(), '.config', 'opencode', 'skills');
+    const ocSkills = path.join(ocRoot, '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');
+    const ocPlugins = path.join(ocRoot, '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-dedup', '.chisle-compress-stats.json', '.chisle-compress-last.json']) {
-      const p = path.join(homeDir(), '.config', 'opencode', f);
+      const p = path.join(ocState, f);
       if (fs.existsSync(p)) { if (!opts.dryRun) fs.rmSync(p, { recursive: true, force: true }); note('  removed ' + p); touched++; }
     }
   }
@@ -721,9 +804,39 @@ function uninstall(ctx) {
     if (hGone > 0) { note('  removed ' + hGone + ' chisle skill dir(s) from ' + hSkills); touched++; }
   }
 
+  if (wants('copilot-cli')) {
+    const cpRoot = copilotDir();
+    const cpMd = path.join(cpRoot, 'copilot-instructions.md');
+    if (fs.existsSync(cpMd)) {
+      const txt = fs.readFileSync(cpMd, 'utf8');
+      const b = txt.indexOf(FENCE_BEGIN);
+      const e = b === -1 ? -1 : txt.indexOf(FENCE_END, b);
+      if (b !== -1 && e !== -1) {
+        const tail = txt.slice(e + FENCE_END.length).replace(/^\n/, '');
+        const stripped = (txt.slice(0, b) + tail).replace(/\n{3,}/g, '\n\n').replace(/\n{2,}$/, '\n');
+        if (!opts.dryRun) fs.writeFileSync(cpMd, stripped, { mode: 0o644 });
+        note('  removed chisle block from ' + cpMd); touched++;
+      }
+    }
+    for (const rel of [path.join('hooks', 'chisle.json'), 'chisle-hooks', 'chisle-spill', 'chisle-dedup',
+                       '.chisle-compress-stats.json']) {
+      const p = path.join(cpRoot, rel);
+      if (fs.existsSync(p)) { if (!opts.dryRun) fs.rmSync(p, { recursive: true, force: true }); note('  removed ' + p); touched++; }
+    }
+  }
+
+  // MCP servers routed through the proxy by `npx chisle mcp wrap`: restore
+  // their original commands before anything else could remove the proxy.
+  if (!opts.only.length) {
+    const r = MCP.run(['unwrap'].concat(opts.dryRun ? ['--dry-run'] : []), () => {});
+    if (r.changed) { note('  restored ' + r.changed + ' MCP server command(s) wrapped by `chisle mcp wrap`'); touched++; }
+    const pd = MCP.proxyDir();
+    if (fs.existsSync(pd)) { if (!opts.dryRun) fs.rmSync(pd, { recursive: true, force: true }); note('  removed ' + pd); 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)');
+    note('Project-scoped rule files (.cursor/, .windsurf/, .clinerules/, .kiro/, .agents/rules/, .github/copilot-instructions.md)');
     note('live in your project repos, so remove them per-project with git if you added them there.');
   }
   say(touched ? c.green(`\nUninstalled. ${touched} item(s) cleaned.`) : c.yellow('\nNothing to uninstall.'));
@@ -743,18 +856,26 @@ Flags:
   --only <id>      Limit install/uninstall to one agent (repeatable)
   --dry-run        Print actions, change nothing
   --force          Reinstall / overwrite even if already present
-  --uninstall, -u  Remove what chisle installed
+  --uninstall, -u  Remove what chisle installed (also restores wrapped MCP servers)
   --config-dir <p> Override Claude config dir (default: $CLAUDE_CONFIG_DIR or ~/.claude)
   --no-color       Disable ANSI color
   --help, -h       This help
 
 Agents: ${PROVIDERS.map(p => p.id).join(', ')}
 
+MCP output compression (opt-in, any agent that launches stdio MCP servers):
+  npx chisle mcp wrap   [--only <id>] [--file <mcp.json>] [--dry-run]
+  npx chisle mcp unwrap [--only <id>] [--file <mcp.json>] [--dry-run]
+  npx chisle mcp status
+  Targets: ${[...new Set(MCP.targets().map(t => t.id))].join(', ')}. Never Claude Code
+  (its own hook already compresses MCP output).
+
 Examples:
   npx chisle                  # auto-detect + install
   npx chisle --only claude    # just Claude Code
   npx chisle --dry-run        # preview
   npx chisle --stats          # what the compressor has saved
+  npx chisle mcp wrap         # compress MCP tool output in Cursor, Gemini, ...
   npx chisle@latest --update  # upgrade what is already installed
 `);
 }
@@ -766,7 +887,10 @@ Examples:
 // without the ruleset, which is what the benchmark arms are for. A counter that
 // blended the two would be inventing the interesting half.
 function printStats(c, opts) {
-  const dir = claudeDir(opts);
+  const only = opts.only.length === 1 ? opts.only[0] : null;
+  const dir = only === 'opencode' ? opencodeStateDir()
+    : only === 'copilot-cli' ? copilotDir()
+    : claudeDir(opts);
   const p = path.join(dir, '.chisle-compress-stats.json');
   process.stdout.write(c.orange('chisle') + ': tool-output savings\n\n');
 
@@ -801,7 +925,7 @@ function printStats(c, opts) {
 function printList(c) {
   process.stdout.write(c.orange('chisle') + ': detected agents:\n\n');
   for (const p of PROVIDERS) {
-    const found = detectMatch(p.detect);
+    const found = providerDetected(p);
     const mark = found ? c.green('✓') : c.dim('·');
     const scope = p.scope === 'project' ? c.dim(' (project-scoped)') : '';
     process.stdout.write(`  ${mark} ${p.label}${scope}\n`);
@@ -811,6 +935,7 @@ function printList(c) {
 
 // ── main ────────────────────────────────────────────────────────────────────
 function main() {
+  if (process.argv[2] === 'mcp') return MCP.main(process.argv.slice(3));
   const opts = parseArgs(process.argv.slice(2));
   const c = makeChalk(opts.noColor);
 
@@ -830,13 +955,13 @@ function main() {
   say(c.dim(opts.dryRun ? '  (dry run, nothing will change)' : '  maximum signal, minimum noise'));
   say('');
 
-  let targets = PROVIDERS.filter(p => opts.only.length ? opts.only.includes(p.id) : detectMatch(p.detect));
+  let targets = PROVIDERS.filter(p => opts.only.length ? opts.only.includes(p.id) : providerDetected(p));
   if (opts.update) targets = targets.filter(p => installedFor(p.id, opts));
   if (targets.length === 0) {
     if (opts.update) {
       warn('Nothing to update: Chisle is not installed for any detected agent.');
       note('Run `npx chisle` to install it, or `npx chisle --list` to see what we look for.');
-      note('Project-scoped agents (Cursor, Windsurf, Cline, Kiro, Copilot) are per-repo:');
+      note('Project-scoped agents (Cursor, Windsurf, Cline, Kiro, Copilot, Antigravity) are per-repo:');
       note('run this from the project that has the rule file.');
       return;
     }
@@ -852,6 +977,7 @@ function main() {
     else if (p.id === 'codex') installCodex(ctx);
     else if (p.id === 'opencode') installOpencode(ctx);
     else if (p.id === 'hermes') installHermes(ctx);
+    else if (p.id === 'copilot-cli') installCopilotCli(ctx);
     else installProjectRule(ctx, p);
   }
 

package/bin/lib/mcp.js

@@ -0,0 +1,179 @@
+// chisle — `npx chisle mcp <wrap|unwrap|status>`: route stdio MCP servers
+// through hooks/chisle-mcp-proxy.js so their oversized tool results get the
+// same compression Claude Code and Pi get from PostToolUse.
+//
+// Opt-in, because it rewrites other tools' config files:
+//   - strict JSON only: a file with comments is reported and left alone,
+//     since rewriting it would drop them
+//   - first write of each file keeps a `<file>.chisle-bak` copy
+//   - only stdio entries (`command`) are wrapped; url/http servers untouched
+//   - wrapped form is reversible from the args alone, no extra keys a host
+//     schema might reject: { command: "node", args: [proxy, "--", cmd, ...args] }
+//
+// Claude Code is never a target: its PostToolUse hook already compresses
+// mcp__* output, and wrapping would only add a process per server.
+// Codex (TOML config) is not wrapped automatically.
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { getConfigDir } = require('../../hooks/chisle-config');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const PROXY_FILE = 'chisle-mcp-proxy.js';
+const PROXY_SOURCES = ['chisle-mcp-proxy.js', 'chisle-compress-output.js', 'chisle-config.js'];
+
+function home() { return process.env.CHISLE_HOME || os.homedir(); }
+function proxyDir() { return path.join(getConfigDir(), 'mcp-proxy'); }
+
+// VS Code-family user dirs, for Cline's global MCP settings.
+function vscodeUserDirs() {
+  const base = process.platform === 'darwin' ? path.join(home(), 'Library', 'Application Support')
+    : process.platform === 'win32' ? (process.env.APPDATA || path.join(home(), 'AppData', 'Roaming'))
+    : (process.env.XDG_CONFIG_HOME || path.join(home(), '.config'));
+  return ['Code', 'Code - Insiders', 'VSCodium', 'Cursor', 'Windsurf'].map(n => path.join(base, n, 'User'));
+}
+
+// Global MCP config files, all `{ "mcpServers": { name: { command, args } } }`.
+function targets() {
+  const h = home();
+  const copilot = process.env.COPILOT_HOME || path.join(h, '.copilot');
+  const list = [
+    ['cursor', 'Cursor', path.join(h, '.cursor', 'mcp.json')],
+    ['windsurf', 'Windsurf', path.join(h, '.codeium', 'windsurf', 'mcp_config.json')],
+    ['gemini', 'Gemini CLI', path.join(h, '.gemini', 'settings.json')],
+    ['qwen', 'Qwen Code', path.join(h, '.qwen', 'settings.json')],
+    ['kiro', 'Kiro', path.join(h, '.kiro', 'settings', 'mcp.json')],
+    ['copilot-cli', 'Copilot CLI', path.join(copilot, 'mcp-config.json')],
+  ];
+  for (const dir of vscodeUserDirs()) {
+    list.push(['cline', 'Cline', path.join(dir, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json')]);
+  }
+  return list.map(([id, label, file]) => ({ id, label, file }));
+}
+
+function isWrapped(entry) {
+  return !!(entry && Array.isArray(entry.args) && typeof entry.args[0] === 'string' &&
+    path.basename(entry.args[0]) === PROXY_FILE && entry.args[1] === '--');
+}
+
+function isStdio(entry) {
+  return !!(entry && typeof entry.command === 'string' && entry.command &&
+    !entry.url && !entry.httpUrl && !entry.serverUrl &&
+    (entry.type == null || entry.type === 'stdio' || entry.type === 'local'));
+}
+
+function wrapEntry(entry, proxy) {
+  const args = Array.isArray(entry.args) ? entry.args : [];
+  entry.args = [proxy, '--', entry.command, ...args];
+  entry.command = 'node';
+}
+
+function unwrapEntry(entry) {
+  const rest = entry.args.slice(2);
+  entry.command = rest[0];
+  entry.args = rest.slice(1);
+  if (!entry.args.length) delete entry.args; // wrap added it; most configs omit an empty one
+}
+
+function readConfig(file) {
+  let raw;
+  try { raw = fs.readFileSync(file, 'utf8'); } catch (e) { return { missing: true }; }
+  try {
+    const data = JSON.parse(raw.replace(/^/, ''));
+    if (!data || typeof data !== 'object' || Array.isArray(data)) return { error: 'not a JSON object' };
+    return { data, raw };
+  } catch (e) { return { error: 'not strict JSON (comments?); edit by hand' }; }
+}
+
+function writeConfig(file, raw, data) {
+  const bak = file + '.chisle-bak';
+  if (!fs.existsSync(bak)) fs.writeFileSync(bak, raw, { mode: 0o600 });
+  let mode = 0o600;
+  try { mode = fs.statSync(file).mode & 0o777; } catch (e) {}
+  const tmp = file + '.chisle-tmp-' + process.pid;
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { mode });
+  fs.renameSync(tmp, file);
+}
+
+function installProxy() {
+  const dir = proxyDir();
+  fs.mkdirSync(dir, { recursive: true });
+  for (const f of PROXY_SOURCES) fs.copyFileSync(path.join(REPO_ROOT, 'hooks', f), path.join(dir, f));
+  fs.writeFileSync(path.join(dir, 'package.json'), '{ "type": "commonjs" }\n');
+  return path.join(dir, PROXY_FILE);
+}
+
+function parse(argv) {
+  const o = { action: argv[0], dryRun: false, only: [], files: [] };
+  for (let i = 1; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--dry-run') o.dryRun = true;
+    else if (a === '--only' && argv[i + 1]) o.only.push(argv[++i]);
+    else if (a === '--file' && argv[i + 1]) o.files.push(path.resolve(argv[++i]));
+    else if (a === '--no-color' || a === '--') continue;
+    else throw new Error('unknown option: ' + a);
+  }
+  if (!['wrap', 'unwrap', 'status'].includes(o.action)) throw new Error('usage: npx chisle mcp <wrap|unwrap|status> [--only <agent>] [--file <mcp.json>] [--dry-run]');
+  return o;
+}
+
+function selected(o) {
+  if (o.files.length) return o.files.map(file => ({ id: 'file', label: 'custom', file }));
+  return targets().filter(t => !o.only.length || o.only.includes(t.id));
+}
+
+// Returns { changed, files } so `--uninstall` can reuse it quietly.
+function run(argv, out) {
+  out = out || (s => process.stdout.write(s + '\n'));
+  const o = parse(argv);
+  const proxy = o.action === 'wrap' && !o.dryRun ? installProxy() : path.join(proxyDir(), PROXY_FILE);
+  let changed = 0, found = 0;
+
+  for (const t of selected(o)) {
+    const cfg = readConfig(t.file);
+    if (cfg.missing) { if (o.files.length) out('  ' + t.file + ': not found'); continue; }
+    found++;
+    if (cfg.error) { out('  ' + t.label + ': ' + t.file + ': skipped, ' + cfg.error); continue; }
+    const servers = cfg.data.mcpServers;
+    if (!servers || typeof servers !== 'object') { out('  ' + t.label + ': no mcpServers in ' + t.file); continue; }
+
+    const names = Object.keys(servers);
+    const wrapped = names.filter(n => isWrapped(servers[n]));
+    if (o.action === 'status') {
+      out('  ' + t.label + ': ' + wrapped.length + '/' + names.filter(n => isStdio(servers[n])).length +
+        ' stdio server(s) wrapped  ' + t.file);
+      continue;
+    }
+
+    const todo = o.action === 'wrap'
+      ? names.filter(n => isStdio(servers[n]) && !isWrapped(servers[n]))
+      : wrapped;
+    if (!todo.length) { out('  ' + t.label + ': nothing to ' + o.action + '  ' + t.file); continue; }
+    for (const n of todo) (o.action === 'wrap' ? wrapEntry(servers[n], proxy) : unwrapEntry(servers[n]));
+    if (!o.dryRun) writeConfig(t.file, cfg.raw, cfg.data);
+    changed += todo.length;
+    out('  ' + t.label + ': ' + (o.dryRun ? 'would ' + o.action : o.action + 'ped') + ' ' + todo.join(', ') + '  ' + t.file);
+  }
+
+  if (!found) out('  no MCP config files found' + (o.only.length ? ' for ' + o.only.join(', ') : ''));
+  if (o.action === 'status') {
+    const dir = process.env.CHISLE_STATE_DIR || getConfigDir();
+    let stats = null;
+    try { stats = JSON.parse(fs.readFileSync(path.join(dir, '.chisle-compress-stats.json'), 'utf8')); } catch (e) {}
+    out('\n  saved so far: ' + (stats && Number.isFinite(stats.savedChars)
+      ? stats.savedChars.toLocaleString('en-US') + ' chars over ' + stats.events + ' tool result(s)'
+      : 'nothing yet') + '  (' + dir + ')');
+  }
+  if (o.action === 'wrap' && changed && !o.dryRun) out('\n  Restart the agent so it relaunches its MCP servers.');
+  return { changed, found };
+}
+
+function main(argv) {
+  try { run(argv); }
+  catch (e) { process.stderr.write('error: ' + e.message + '\n'); process.exit(2); }
+}
+
+module.exports = { main, run, targets, isWrapped, isStdio, proxyDir };