chisle 3.0.0 → 3.2.0

package/bin/install.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-// chisle — cross-platform installer.
+// chisle: cross-platform installer.
 //
 // Detects the AI coding agents on this machine and installs Chisle for each:
 //   - Claude Code  → plugin (marketplace add + install), fallback to standalone
 //                    hooks + settings.json merge + statusline badge
+//   - Pi           → Pi package (extension + skill)
 //   - Gemini CLI   → gemini extensions install
 //   - Codex        → fenced ruleset appended to ~/.codex/AGENTS.md
 //   - Cursor/Windsurf/Cline/Kiro/Copilot → project rule file dropped into CWD
@@ -39,6 +40,7 @@ const REPO_ROOT = path.resolve(__dirname, '..');
 //        (that's how Cursor/Cline/Copilot rules actually work).
 const PROVIDERS = [
   { id: 'claude',   label: 'Claude Code',   scope: 'global',  detect: 'cmd:claude' },
+  { 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: 'cursor',   label: 'Cursor',        scope: 'project', detect: 'cmd:cursor||dir:~/.cursor',
@@ -56,13 +58,14 @@ const PROVIDERS = [
 // ── argv ────────────────────────────────────────────────────────────────────
 function parseArgs(argv) {
   const opts = { dryRun: false, force: false, list: false, uninstall: false,
-                 noColor: false, help: false, only: [], configDir: null };
+                 noColor: false, help: false, stats: false, only: [], configDir: null };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     switch (a) {
       case '--dry-run': opts.dryRun = true; break;
       case '--force': opts.force = true; break;
       case '--list': opts.list = true; break;
+      case '--stats': opts.stats = true; break;
       case '--uninstall': case '-u': opts.uninstall = true; break;
       case '--no-color': opts.noColor = true; break;
       case '-h': case '--help': opts.help = true; break;
@@ -183,10 +186,10 @@ function installClaude(ctx) {
       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; }
-      else warn('  claude plugin install failed — falling back to standalone hooks');
+      else warn('  claude plugin install failed, falling back to standalone hooks');
     }
   } else {
-    note('  claude CLI not on PATH — wiring standalone hooks in settings.json');
+    note('  claude CLI not on PATH, wiring standalone hooks in settings.json');
   }
 
   if (!pluginOK) {
@@ -196,11 +199,23 @@ function installClaude(ctx) {
     else results.failed.push(['claude-hooks', r]);
   } else {
     note('  hooks: plugin manifest handles SessionStart + UserPromptSubmit + PostToolUse');
+    // Plugin path won, so drop any standalone wiring left by an earlier run, or
+    // both copies of every hook run on each event and the PostToolUse pair
+    // dedups first-seen output against itself.
+    const settingsPath = path.join(claudeDir(opts), 'settings.json');
+    const settings = SETTINGS.readSettings(settingsPath);
+    if (settings && SETTINGS.removeHooks(settings, 'chisle-') > 0) {
+      if (!opts.dryRun) {
+        SETTINGS.validateHookFields(settings);
+        SETTINGS.writeSettings(settingsPath, settings);
+      }
+      note('  removed superseded standalone hook entries from settings.json');
+    }
   }
   process.stdout.write('\n');
 }
 
-// Standalone wiring — copy hooks into <configDir>/chisle-hooks/ and merge
+// Standalone wiring: copy hooks into <configDir>/chisle-hooks/ and merge
 // settings.json. Used when the plugin path is unavailable.
 function installClaudeHooks(ctx) {
   const { opts, warn, note } = ctx;
@@ -209,7 +224,7 @@ function installClaudeHooks(ctx) {
   const hooksDst = path.join(cfg, 'chisle-hooks');
   const settingsPath = path.join(cfg, 'settings.json');
   const HOOK_FILES = ['package.json', 'chisle-config.js', 'chisle-activate.js',
-                      'chisle-mode-tracker.js', 'chisle-compress-output.js',
+                      'chisle-mode.js', 'chisle-mode-tracker.js', 'chisle-compress-output.js',
                       'chisle-statusline.sh', 'chisle-statusline.ps1'];
 
   if (opts.dryRun) {
@@ -254,7 +269,7 @@ function installClaudeHooks(ctx) {
   } else {
     const existing = typeof settings.statusLine === 'string' ? settings.statusLine : (settings.statusLine.command || '');
     if (existing.includes('chisle-statusline')) process.stdout.write('  statusline badge already configured.\n');
-    else process.stdout.write('  NOTE: existing statusline detected — CHISLE badge NOT added (see docs/install-windows.md).\n');
+    else process.stdout.write('  NOTE: existing statusline detected, CHISLE badge NOT added (see docs/install-windows.md).\n');
   }
 
   SETTINGS.validateHookFields(settings);
@@ -263,6 +278,30 @@ function installClaudeHooks(ctx) {
   return 'ok';
 }
 
+// ── Pi ──────────────────────────────────────────────────────────────────────
+function piSources(output) {
+  return String(output || '').split('\n').map(line => line.trim())
+    .filter(line => /^npm:chisle(?:@|$)/i.test(line) || /^git:.*github\.com\/JayPokale\/Chisle(?:@|$)/i.test(line))
+    .map(source => source.replace(/@[^/@]+$/, ''));
+}
+
+function installPi(ctx) {
+  const { say, note, opts, results } = ctx;
+  results.detected++;
+  say('→ Pi detected');
+  if (!opts.force) {
+    const installed = piSources(capture('pi', ['list']).stdout);
+    if (installed.length) {
+      note('  chisle package already installed (use --force)');
+      results.skipped.push(['pi', 'already installed']); process.stdout.write('\n'); return;
+    }
+  }
+  const r = run('pi', ['install', 'npm:chisle'], opts.dryRun);
+  if ((r.status || 0) === 0) results.installed.push('pi');
+  else results.failed.push(['pi', 'pi package install failed']);
+  process.stdout.write('\n');
+}
+
 // ── Gemini ──────────────────────────────────────────────────────────────────
 function installGemini(ctx) {
   const { say, note, opts, results } = ctx;
@@ -347,66 +386,80 @@ function uninstall(ctx) {
   say(c.orange('Chisle uninstall'));
   let touched = 0;
 
-  // Claude plugin
-  if (hasCmd('claude') && !opts.dryRun) {
-    const r = capture('claude', ['plugin', 'list']);
-    if (r.status === 0 && /chisle/i.test(r.stdout || '')) {
-      run('claude', ['plugin', 'uninstall', 'chisle@chisle'], opts.dryRun); touched++;
+  const wants = id => !opts.only.length || opts.only.includes(id);
+
+  if (wants('claude')) {
+    // Claude plugin
+    if (hasCmd('claude') && !opts.dryRun) {
+      const r = capture('claude', ['plugin', 'list']);
+      if (r.status === 0 && /chisle/i.test(r.stdout || '')) {
+        run('claude', ['plugin', 'uninstall', 'chisle@chisle'], opts.dryRun); touched++;
+      }
     }
-  }
 
-  // Claude standalone hooks + statusline
-  const cfg = claudeDir(opts);
-  const settingsPath = path.join(cfg, 'settings.json');
-  const settings = SETTINGS.readSettings(settingsPath);
-  if (settings) {
-    const removed = SETTINGS.removeHooks(settings, 'chisle-');
-    let slRemoved = false;
-    if (settings.statusLine && typeof settings.statusLine.command === 'string'
-        && settings.statusLine.command.includes('chisle-statusline')) { delete settings.statusLine; slRemoved = true; }
-    if (removed > 0 || slRemoved) {
-      if (!opts.dryRun) { SETTINGS.validateHookFields(settings); SETTINGS.writeSettings(settingsPath, settings); }
-      note(`  removed ${removed} hook entr${removed === 1 ? 'y' : 'ies'}${slRemoved ? ' + statusline' : ''} from settings.json`);
-      touched++;
+    // Claude standalone hooks + statusline
+    const cfg = claudeDir(opts);
+    const settingsPath = path.join(cfg, 'settings.json');
+    const settings = SETTINGS.readSettings(settingsPath);
+    if (settings) {
+      const removed = SETTINGS.removeHooks(settings, 'chisle-');
+      let slRemoved = false;
+      if (settings.statusLine && typeof settings.statusLine.command === 'string'
+          && settings.statusLine.command.includes('chisle-statusline')) { delete settings.statusLine; slRemoved = true; }
+      if (removed > 0 || slRemoved) {
+        if (!opts.dryRun) { SETTINGS.validateHookFields(settings); SETTINGS.writeSettings(settingsPath, settings); }
+        note(`  removed ${removed} hook entr${removed === 1 ? 'y' : 'ies'}${slRemoved ? ' + statusline' : ''} from settings.json`);
+        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 f of ['.chisle-active', '.chisle-session-turns', '.chisle-statusline-suffix',
+                     '.chisle-compress-stats.json', '.chisle-compress-last.json', '.chisle-update-check.json']) {
+      const p = path.join(cfg, f);
+      if (fs.existsSync(p)) { if (!opts.dryRun) { try { fs.unlinkSync(p); } catch (_) {} } note(`  removed ${p}`); 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++; }
 
-  // Flag files
-  for (const f of ['.chisle-active', '.chisle-session-turns', '.chisle-statusline-suffix',
-                   '.chisle-compress-stats.json', '.chisle-compress-last.json', '.chisle-update-check.json']) {
-    const p = path.join(cfg, f);
-    if (fs.existsSync(p)) { if (!opts.dryRun) { try { fs.unlinkSync(p); } catch (_) {} } note(`  removed ${p}`); touched++; }
+  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++;
+    }
   }
 
-  // Codex fenced block
-  const codexMd = path.join(os.homedir(), '.codex', 'AGENTS.md');
-  if (fs.existsSync(codexMd)) {
-    const txt = fs.readFileSync(codexMd, 'utf8');
-    if (txt.includes(FENCE_BEGIN)) {
-      const stripped = txt.replace(new RegExp(`\\n?${FENCE_BEGIN}[\\s\\S]*?${FENCE_END}\\n?`), '\n').replace(/\n{3,}/g, '\n\n');
-      if (!opts.dryRun) fs.writeFileSync(codexMd, stripped, { mode: 0o644 });
-      note(`  removed chisle block from ${codexMd}`); touched++;
+  if (wants('codex')) {
+    const codexMd = path.join(os.homedir(), '.codex', 'AGENTS.md');
+    if (fs.existsSync(codexMd)) {
+      const txt = fs.readFileSync(codexMd, 'utf8');
+      if (txt.includes(FENCE_BEGIN)) {
+        const stripped = txt.replace(new RegExp(`\\n?${FENCE_BEGIN}[\\s\\S]*?${FENCE_END}\\n?`), '\n').replace(/\n{3,}/g, '\n\n');
+        if (!opts.dryRun) fs.writeFileSync(codexMd, stripped, { mode: 0o644 });
+        note(`  removed chisle block from ${codexMd}`); touched++;
+      }
     }
   }
 
-  note('');
-  note('Project-scoped rule files (.cursor/, .windsurf/, .clinerules/, .kiro/, .github/copilot-instructions.md)');
-  note('live in your project repos — remove them per-project with git if you added them there.');
+  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('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.'));
 }
 
 // ── help / banner ───────────────────────────────────────────────────────────
 function printHelp(c) {
-  process.stdout.write(`${c.orange('chisle')} — maximum-efficiency dev mode installer
+  process.stdout.write(`${c.orange('chisle')}: maximum-efficiency dev mode installer
 
 Usage:
   npx chisle [flags]
 
 Flags:
   --list           Detect agents and print them; install nothing
-  --only <id>      Install only for one agent (repeatable)
+  --stats          Print tool-output savings recorded so far; change nothing
+  --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
@@ -420,11 +473,51 @@ 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
 `);
 }
 
+// ── stats ───────────────────────────────────────────────────────────────────
+// Reads the compressor's ledger. Input axis only, and deliberately so: chars
+// elided have a real baseline (we know exactly what was cut), while the output
+// axis has none, since there is no way to know what the model would have written
+// 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 p = path.join(dir, '.chisle-compress-stats.json');
+  process.stdout.write(c.orange('chisle') + ': tool-output savings\n\n');
+
+  let stats = null;
+  try {
+    if (!fs.lstatSync(p).isSymbolicLink()) {
+      const parsed = JSON.parse(fs.readFileSync(p, 'utf8'));
+      if (parsed && Number.isFinite(parsed.savedChars) && Number.isFinite(parsed.events)) stats = parsed;
+    }
+  } catch (e) {}
+
+  if (!stats || stats.events === 0) {
+    process.stdout.write('  no compression recorded yet\n\n');
+    process.stdout.write(c.dim(`  ledger: ${p}\n`));
+    process.stdout.write(c.dim('  it fills as the compressor elides oversized tool output.\n'));
+    process.stdout.write(c.dim("  nothing there after real use? check `npx chisle --list` and that Chisle is active.\n"));
+    return;
+  }
+
+  const chars = stats.savedChars;
+  const tokens = Math.floor(chars / 4);
+  const per = Math.round(chars / stats.events);
+  const fmt = (n) => n.toLocaleString('en-US');
+  process.stdout.write(`  saved:      ${c.green(fmt(chars) + ' chars')}  (~${fmt(tokens)} tokens)\n`);
+  process.stdout.write(`  outputs:    ${fmt(stats.events)} compressed, ${fmt(per)} chars each on average\n\n`);
+  process.stdout.write(c.dim('  A floor, not an estimate: every saved byte also stops being re-sent\n'));
+  process.stdout.write(c.dim('  on every later request in that session.\n\n'));
+  process.stdout.write(c.dim(`  ledger: ${p}\n`));
+  process.stdout.write(c.dim('  per-transcript detail: node benchmarks/replay-compress.js (in a repo clone)\n'));
+}
+
 function printList(c) {
-  process.stdout.write(c.orange('chisle') + ' — detected agents:\n\n');
+  process.stdout.write(c.orange('chisle') + ': detected agents:\n\n');
   for (const p of PROVIDERS) {
     const found = detectMatch(p.detect);
     const mark = found ? c.green('✓') : c.dim('·');
@@ -441,6 +534,7 @@ function main() {
 
   if (opts.help) return printHelp(c);
   if (opts.list) return printList(c);
+  if (opts.stats) return printStats(c, opts);
 
   const results = { detected: 0, installed: [], skipped: [], failed: [] };
   const say = (s) => process.stdout.write(s + '\n');
@@ -451,7 +545,7 @@ function main() {
   if (opts.uninstall) return uninstall(ctx);
 
   say(c.orange('╭─ Chisle installer ─╮'));
-  say(c.dim(opts.dryRun ? '  (dry run — nothing will change)' : '  maximum signal, minimum noise'));
+  say(c.dim(opts.dryRun ? '  (dry run, nothing will change)' : '  maximum signal, minimum noise'));
   say('');
 
   const targets = PROVIDERS.filter(p => opts.only.length ? opts.only.includes(p.id) : detectMatch(p.detect));
@@ -463,6 +557,7 @@ function main() {
 
   for (const p of targets) {
     if (p.id === 'claude') installClaude(ctx);
+    else if (p.id === 'pi') installPi(ctx);
     else if (p.id === 'gemini') installGemini(ctx);
     else if (p.id === 'codex') installCodex(ctx);
     else installProjectRule(ctx, p);
@@ -476,7 +571,7 @@ function main() {
   if (results.failed.length)    say(c.red(`  failed:    ${results.failed.map(s => s[0] + ' (' + s[1] + ')').join(', ')}`));
   say('');
   if (!opts.dryRun && results.installed.length) {
-    say(c.orange('Done.') + ' Restart your agent. Type ' + c.orange('/chisle') + ' (Claude Code) or just start coding.');
+    say(c.orange('Done.') + ' Restart your agent. Type ' + c.orange('/chisle') + ' in Claude Code or Pi, or just start coding.');
     note('If Chisle earns its keep, a star helps others find it: https://github.com/JayPokale/Chisle');
   }
   process.exit(results.failed.length ? 1 : 0);

package/commands/chisle-audit.toml

@@ -1,4 +1,4 @@
-# chisle-audit — one-shot efficiency audit across both axes
+# chisle-audit: one-shot efficiency audit across both axes
 [command]
 name = "chisle-audit"
 description = "Audit a diff, file, or repo for BOTH over-engineered code and bloated prose/docs. Ranked report, biggest cut first. Changes nothing."

package/commands/chisle-help.toml

@@ -1,4 +1,4 @@
-# chisle-help — quick reference card
+# chisle-help: quick reference card
 [command]
 name = "chisle-help"
 description = "Show Chisle quick reference: modes, levels, commands."

package/commands/chisle-review.toml

@@ -1,4 +1,4 @@
-# chisle-review — review a diff/file for over-engineering
+# chisle-review: review a diff/file for over-engineering
 [command]
 name = "chisle-review"
 description = "Review the current diff or a file for bloat, speculative abstractions, and reinvented stdlib."

package/hooks/chisle-compress-output.js

@@ -130,7 +130,17 @@ function scrub(text) {
 // skipped when the payload carries none.
 const DEDUP_MIN = 2048;
 
-function dedupCheck(toolName, text, sessionId) {
+function duplicateMarker(toolName, text, reference = 'previous') {
+  const lines = text.split('\n');
+  const prior = reference === 'previous' ? 'the previous' : 'an earlier';
+  const preview = lines.slice(0, 5)
+    .map(l => l.length > MAX_SALVAGE_LINE ? l.slice(0, MAX_SALVAGE_LINE) + '…' : l);
+  return '[chisle: output byte-identical to ' + prior + ' ' + toolName + ' result — ' +
+    text.length.toLocaleString('en-US') + ' chars / ' + lines.length +
+    ' lines, unchanged. First lines:]\n' + preview.join('\n');
+}
+
+function dedupCheck(toolName, text, sessionId, toolUseId) {
   if (process.env.CHISLE_COMPRESS_DEDUP === '0') return null;
   if (!sessionId || typeof sessionId !== 'string') return null;
   if (text.length < DEDUP_MIN) return null;
@@ -142,18 +152,22 @@ function dedupCheck(toolName, text, sessionId) {
     if (state.session !== sessionId) state = { session: sessionId, tools: {} };
     if (!state.tools || typeof state.tools !== 'object') state.tools = {};
     const hash = crypto.createHash('sha256').update(text).digest('hex');
-    const dup = state.tools[toolName] === hash;
-    state.tools[toolName] = hash;
+    // A second hook invocation for the SAME tool call is not the model seeing
+    // the output twice. That happens whenever this hook is registered more than
+    // once (plugin manifest + a leftover settings.json entry), because both
+    // copies share this state file: copy A stores the hash, copy B matches it
+    // and reports first-seen output as a duplicate of itself. Old string-valued
+    // entries read through `rec`, so an existing state file needs no migration,
+    // and a payload with no tool_use_id keeps today's exact behaviour.
+    const prev = state.tools[toolName];
+    const rec = (prev && typeof prev === 'object') ? prev : { hash: prev, id: null };
+    const sameCall = !!(toolUseId && rec.id && rec.id === toolUseId);
+    const dup = rec.hash === hash && !sameCall;
+    state.tools[toolName] = { hash, id: toolUseId || rec.id || null };
     const tmp = p + '.' + process.pid + '.tmp';
     fs.writeFileSync(tmp, JSON.stringify(state), { mode: 0o600 });
     fs.renameSync(tmp, p);
-    if (!dup) return null;
-    const lines = text.split('\n');
-    const preview = lines.slice(0, 5)
-      .map(l => l.length > MAX_SALVAGE_LINE ? l.slice(0, MAX_SALVAGE_LINE) + '…' : l);
-    return '[chisle: output byte-identical to the previous ' + toolName + ' result — ' +
-      text.length.toLocaleString('en-US') + ' chars / ' + lines.length +
-      ' lines, unchanged. First lines:]\n' + preview.join('\n');
+    return dup ? duplicateMarker(toolName, text) : null;
   } catch (e) { return null; }
 }
 
@@ -259,7 +273,7 @@ function processPayload(payload, mode) {
 
   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);
+  const dup = dedupCheck(payload.tool_name, text, payload.session_id, payload.tool_use_id);
   if (dup != null && dup.length < text.length) return dup;
   return transform(text, limitsFor());
 }
@@ -293,4 +307,4 @@ function main() {
 
 if (require.main === module) main();
 
-module.exports = { extractText, rebuildResponse, scrub, compress, transform, limitsFor, toolAllowed, processPayload, THRESHOLDS, SAFE_TOOLS };
+module.exports = { extractText, rebuildResponse, scrub, compress, transform, limitsFor, toolAllowed, processPayload, duplicateMarker, THRESHOLDS, SAFE_TOOLS };

package/hooks/chisle-mode-tracker.js

@@ -5,7 +5,8 @@
 
 const fs = require('fs');
 const path = require('path');
-const { getDefaultMode, getClaudeDir, safeWriteFlag, readFlag } = require('./chisle-config');
+const { getClaudeDir, safeWriteFlag, readFlag } = require('./chisle-config');
+const { requestedMode } = require('./chisle-mode');
 
 const claudeDir = getClaudeDir();
 const flagPath = path.join(claudeDir, '.chisle-active');
@@ -16,39 +17,12 @@ process.stdin.on('end', () => {
   try {
     const data = JSON.parse(input.replace(/^/, ''));
     const prompt = (data.prompt || '').trim();
-    const promptLower = prompt.toLowerCase();
+    const request = requestedMode(prompt);
 
-    // Natural language activation
-    if (/\b(activate|enable|turn on|start|use)\b.*\bchisle\b/i.test(promptLower) ||
-        /\bchisle\b.*\b(mode|activate|enable|on)\b/i.test(promptLower) ||
-        /\bchislif(y|ier)\b/i.test(promptLower)) {
-      if (!/\b(stop|disable|turn off|deactivate|off)\b/i.test(promptLower)) {
-        const mode = getDefaultMode();
-        if (mode !== 'off') safeWriteFlag(flagPath, mode);
-      }
-    }
-
-    // /chisle slash commands. No level argument any more: /chisle on,
-    // /chisle off, nothing else.
-    if (/^\/chisle(\b|:chisle\b)/.test(promptLower)) {
-      const parts = promptLower.split(/\s+/);
-      const arg = parts[1] || '';
-      if (arg === 'off' || arg === 'stop' || arg === 'disable') {
-        try { fs.unlinkSync(flagPath); } catch (e) {}
-      } else {
-        const mode = getDefaultMode();
-        if (mode !== 'off') safeWriteFlag(flagPath, mode);
-      }
-    }
-
-    // Natural language deactivation.
-    // Only fire when the off-verb actually targets chisle — NOT when chisle merely
-    // appears in a sentence that also mentions turning something else off.
-    // ("use chisle to turn off the logger" must NOT deactivate.)
-    if (/\b(turn off|disable|deactivate|stop|kill|exit)\s+chisle\b/i.test(promptLower) ||
-        /\bchisle\s+(mode\s+)?(off|stop|disable|deactivate)\b/i.test(promptLower) ||
-        /\bnormal mode\b/i.test(promptLower)) {
+    if (request === 'off') {
       try { fs.unlinkSync(flagPath); } catch (e) {}
+    } else if (request === 'on') {
+      safeWriteFlag(flagPath, 'on');
     }
 
     // Per-turn reinforcement

package/hooks/chisle-mode.js

@@ -0,0 +1,19 @@
+'use strict';
+
+// Shared mode-directive parser. Harness adapters decide how to persist mode.
+function requestedMode(prompt) {
+  const text = String(prompt || '').trim().toLowerCase();
+
+  if (/\b(turn off|disable|deactivate|stop|kill|exit)\s+chisle\b/i.test(text) ||
+      /\bchisle\s+(mode\s+)?(off|stop|disable|deactivate)\b/i.test(text) ||
+      /\bnormal mode\b/i.test(text)) return 'off';
+
+  if (/^\/chisle(\b|:chisle\b)/.test(text) ||
+      /\b(activate|enable|turn on|start|use)\b.*\bchisle\b/i.test(text) ||
+      /\bchisle\b.*\b(mode|activate|enable|on)\b/i.test(text) ||
+      /\bchislif(y|ier)\b/i.test(text)) return 'on';
+
+  return null;
+}
+
+module.exports = { requestedMode };

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "chisle",
-  "version": "3.0.0",
-  "description": "Maximum-efficiency dev mode for Claude Code. Zero-fluff prose + YAGNI-first code decisions. One plugin that does both.",
+  "version": "3.2.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",
     "productivity",
     "yagni",
     "minimal"
@@ -19,10 +21,6 @@
       "name": "Claude (Anthropic)",
       "url": "https://claude.com/claude-code"
     },
-    {
-      "name": "Antigravity (Google)",
-      "url": "https://antigravity.google"
-    },
     {
       "name": "Codex (OpenAI)",
       "url": "https://openai.com/codex/"
@@ -42,6 +40,14 @@
   "engines": {
     "node": ">=18"
   },
+  "pi": {
+    "extensions": [
+      "./pi-extension/index.js"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
   "scripts": {
     "test": "node --test tests/*.js",
     "build:rules": "node scripts/build-rules.js",
@@ -55,6 +61,7 @@
   "files": [
     "bin/",
     "hooks/",
+    "pi-extension/",
     "skills/",
     "commands/",
     "rules/",