chisle 3.0.0 → 3.1.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Maximum-efficiency dev mode. Zero-fluff prose combined with YAGNI/ladder-first code decisions. One persona: the senior dev who deletes code for fun and bills by the syllable.",
   "hooks": {
     "SessionStart": [

package/README.md

@@ -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-8%20agents-d78a3c?style=flat-square" alt="Works with 8 agents">
+  <img src="https://img.shields.io/badge/works%20with-9%20agents-d78a3c?style=flat-square" alt="Works with 9 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">
@@ -79,30 +79,30 @@ Most efficiency tools compress one thing. Chisle compresses **three**:
 |---|---|---|
 | **Output: prose** | filler, hedging, manufactured structure | zero-fluff ruleset, injected per session |
 | **Output: code** | speculative abstractions, unrequested boilerplate | YAGNI efficiency ladder |
-| **Input: context** | oversized tool output flooding the window | `PostToolUse` hook — scrub, elide, dedup — plus prevention rules |
+| **Input: context** | oversized tool output flooding the window | Claude `PostToolUse` / Pi `tool_result` — scrub, elide, dedup — plus prevention rules |
 
 Where each one attaches to a session:
 
 ```mermaid
 flowchart LR
     subgraph S["Session start"]
-        H1["SessionStart hook<br/>~1.6k tokens, new sessions only"]
+        H1["Ruleset injection<br/>once per active session"]
     end
     subgraph T["Every turn"]
-        H2["UserPromptSubmit hook<br/>~50-token reminder"]
+        H2["Mode tracking<br/>Claude + Pi"]
     end
     subgraph L["Every tool call"]
-        H3["PostToolUse hook<br/>scrub → elide → dedup"]
+        H3["PostToolUse / tool_result<br/>scrub → elide → dedup"]
     end
 
     H1 --> M(["Model"])
     H2 --> M
     M -->|writes| O["Output:<br/>terser prose,<br/>YAGNI-first code"]
-    M -->|calls a tool| TOOL[["Bash / Grep / WebFetch / mcp__*"]]
+    M -->|calls a tool| TOOL[["Bash / grep / web / extension tools"]]
     TOOL -->|raw output| H3
     H3 -->|"compressed, rebuilt into<br/>the tool's own shape"| M
 
-    RE["Read / Edit"] -.->|"never touched —<br/>exact bytes feed later edits"| M
+    RE["Read / Edit / Write"] -.->|"never touched —<br/>exact bytes feed later edits"| M
 
     style M fill:#1f2937,stroke:#d78a3c,color:#e6edf3
     style O fill:#14532d,stroke:#2da44e,color:#e6edf3
@@ -110,7 +110,7 @@ flowchart LR
     style RE fill:#3f1d1d,stroke:#cf3b3b,color:#e6edf3
 ```
 
-The loop on the right is the input axis: tool output is billed again on *every* later request in the session, so shrinking it once pays repeatedly. `Read` and `Edit` are deliberately outside it.
+The loop on the right is the input axis: tool output is billed again on *every* later request in the session, so shrinking it once pays repeatedly. `Read`, `Edit`, and `Write` are deliberately outside it.
 
 <p align="center">
   <img src="assets/thumbnail.png" width="820" alt="Chisle — less tokens, same results. Four parts: output compressor (compress noisy tool outputs), context diet (read only what's actually relevant), terse persona (short, focused, YAGNI-first), YAGNI ladder (do less, reuse more, build only when needed).">
@@ -122,7 +122,7 @@ Every "be concise" tool has a worst day — the day it makes the model write *mo
 
 ## Install
 
-One command. Auto-detects your agents (Claude Code, 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) and wires each one. `--uninstall` puts everything back.
 
 ```bash
 npx chisle
@@ -138,9 +138,9 @@ curl -fsSL https://raw.githubusercontent.com/JayPokale/Chisle/main/install.sh |
 irm https://raw.githubusercontent.com/JayPokale/Chisle/main/install.ps1 | iex
 ```
 
-Preview first with `npx chisle --dry-run`, scope with `--only claude`, see everything with `npx chisle --help`. Remove with `npx chisle --uninstall`.
+Preview first with `npx chisle --dry-run`, scope with `--only claude` or `--only pi`, see everything with `npx chisle --help`. Remove with `npx chisle --uninstall`.
 
-**Requirements:** Node ≥18 (installer / `npx`) · Claude Code for `/chisle` toggling and input-side compression — the always-on ruleset still ships to every other agent.
+**Requirements:** Node ≥18 (installer / `npx`) · Claude Code or Pi for `/chisle` toggling and input-side compression — the always-on ruleset still ships to every other agent.
 
 ### Upgrading
 
@@ -167,17 +167,26 @@ claude plugin marketplace add JayPokale/Chisle   # register the marketplace
 claude plugin install chisle@chisle              # enable the plugin
 ```
 
+### Pi package
+
+```bash
+pi install npm:chisle
+```
+
+The package loads the zero-dependency extension and `chisle` skill globally. Pi extensions run with your user permissions; review the source before installation. Project-local installs (`pi install -l npm:chisle`) load only after you trust that project.
+
 ### See what it would do, before it does it
 
 ```bash
 npx chisle --dry-run    # prints every file it would touch, changes nothing
 ```
 
-Want the savings measured on your own work rather than ours? Clone the repo and replay the compressor over your existing Claude Code transcripts — it reads them locally, writes nothing, and reports the tokens the input-side hook would have stripped:
+Want the savings measured on your own work rather than ours? Clone the repo and replay the compressor over local transcripts — it reads them locally, writes nothing, and reports the input the hook would have stripped:
 
 ```bash
 git clone https://github.com/JayPokale/Chisle && cd Chisle
-node benchmarks/replay-compress.js
+node benchmarks/replay-compress.js       # Claude Code
+node benchmarks/replay-compress.js pi    # Pi; marginal over Pi's native truncation
 ```
 
 ---
@@ -283,7 +292,7 @@ SUITE=large bash benchmarks/run-live.sh <model> benchmarks/results/raw-large
 
 The row that matters is the last one. Every tool here looks good on its best day; the numbers above are the only ones in this class published alongside the run that went wrong. [Full comparison →](docs/comparison.md)
 
-### Input axis — tool-output compression (Claude Code)
+### Input axis — tool-output compression (Claude Code + Pi)
 
 Measured over 171 real sessions ([receipts](benchmarks/results/2026-07-07-input-axis.md)): tool output is **67.5%** of context content, and every byte of it is re-billed on *every subsequent request* in the session (median: 171 requests). A `PostToolUse` hook shrinks it before the model reads it — deterministic, zero LLM, zero network:
 
@@ -293,10 +302,13 @@ Measured over 171 real sessions ([receipts](benchmarks/results/2026-07-07-input-
 | **elide** | oversized output → head + tail, error-like lines salvaged from the cut | bounded, guarded |
 | **dedup** | byte-identical repeat of a tool's previous output (same session) → one-line marker | none — the copy is already in context |
 
-Replayed over the same 171 sessions: **~61k tokens** saved one-shot, ~46% off every eligible output — floor, not estimate, since each saved byte also stops being re-sent on every later request. Correctness rules: allowlist only (`Bash`, `Agent`, `WebFetch`, `WebSearch`, `Grep`, `Glob`, `mcp__*`) — never `Read`/`Edit`, whose exact bytes feed later edits. Honest ledger: dedup scored **0 hits** on this corpus (rtk-filtered at source); it's kept for the test-rerun case, kill-switchable, and labeled speculative until it earns a number. Replay it on your own transcripts:
+Replayed over the same 171 Claude Code sessions: **~61k tokens** saved one-shot, ~46% off every eligible output — floor, not estimate, since each saved byte also stops being re-sent on every later request. Correctness rules: allowlist only (`Bash`, `Agent`, `WebFetch`, `WebSearch`, `Grep`, `Glob`, `mcp__*`) — never `Read`/`Edit`, whose exact bytes feed later edits. Honest ledger: dedup scored **0 hits** on this corpus (rtk-filtered at source); it's kept for the test-rerun case, kill-switchable, and labeled speculative until it earns a number.
+
+Pi already truncates built-in output at 50KB/2,000 lines. Replay over 8,044 persisted Pi results measured the compressor's **marginal** saving after that truncation: **27.4% of tool-output chars** ([receipt + raw live Pi arm](benchmarks/results/2026-09-11-pi.md)). Pi compresses `bash`, `powershell`, `grep`, `find`, `ls`, MCP, and explicitly allowlisted extension-tool results; `read`/`edit`/`write` remain untouched. `CHISLE_COMPRESS_TOOLS` supplies the same explicit override for runtime and replay. Runtime dedup only compares earlier turns, so concurrently completed sibling calls cannot dedup one another.
 
 ```bash
-node benchmarks/replay-compress.js        # what it would have saved you
+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.
@@ -404,12 +416,12 @@ Chisle borrows the best published token-saving techniques and implements the one
 
 ## Multi-agent
 
-Primarily a Claude Code plugin, but ships to every agent with a rules/context file — Cursor, Windsurf, Cline, Kiro, Codex, Gemini, Copilot. Per-agent copies generated by `scripts/build-rules.js` (a condensed mirror of the skill — edit both, CI checks sync). See [`docs/agent-portability.md`](./docs/agent-portability.md). Input-side compression is Claude Code-only for now: no other agent exposes a post-tool output rewrite hook.
+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).
 
 ## FAQ
 
 **Doesn't injecting a persona every turn cost tokens?**
-Yes — a ruleset at session start (~1.6k tokens) plus a ~50-token reminder per turn. Output is where it pays back: coding answers shrink 40–60% (benchmarks), and output bills several × higher than input.
+Claude Code uses a ruleset at session start (~1.6k tokens) plus a ~50-token reminder per turn. Pi injects one persistent rules message only when project `AGENTS.md` does not already provide it; resume/reload does not duplicate it, and compaction restores it only if removed.
 
 Worth reading the dissent before you take that on faith: [@enc0ded](https://github.com/enc0ded) measured 173 of their own sessions ([#2](https://github.com/JayPokale/Chisle/issues/2)) and found the injection overhead roughly cancelling the compressor's savings — because the ruleset was being re-sent on every resume and clear, not just at startup. That re-injection is fixed, which removes most of the overhead they measured, but their wider point stands: prose is only ~25% of what the model emits, so the ceiling on the output axis is lower than the headline suggests, and on a one-line throwaway prompt the overhead still exceeds the saving.
 

package/bin/install.js

@@ -4,6 +4,7 @@
 // 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',
@@ -196,6 +198,18 @@ function installClaude(ctx) {
     else results.failed.push(['claude-hooks', r]);
   } else {
     note('  hooks: plugin manifest handles SessionStart + UserPromptSubmit + PostToolUse');
+    // Plugin path won — 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');
 }
@@ -209,7 +223,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) {
@@ -263,6 +277,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,53 +385,66 @@ 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 — 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.'));
 }
 
@@ -406,7 +457,7 @@ Usage:
 
 Flags:
   --list           Detect agents and print them; install nothing
-  --only <id>      Install only for one agent (repeatable)
+  --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
@@ -463,6 +514,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 +528,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/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.1.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/",

package/pi-extension/index.js

@@ -0,0 +1,188 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { getDefaultMode } = require('../hooks/chisle-config');
+const { duplicateMarker, limitsFor, transform } = require('../hooks/chisle-compress-output');
+const { requestedMode } = require('../hooks/chisle-mode');
+
+const RULES_TYPE = 'chisle-rules';
+const MODE_TYPE = 'chisle-mode';
+const SAFE_TOOLS = new Set(['bash', 'powershell', 'grep', 'find', 'ls']);
+const NEVER_COMPRESS = new Set(['read', 'edit', 'write']);
+const DEDUP_MIN = 2048;
+const FALLBACK_RULES = `CHISLE ACTIVE
+
+Chisle: maximum-efficiency dev mode. Zero-fluff prose. YAGNI-first code.
+
+Drop articles, filler, pleasantries, and hedging. Fragments OK; technical terms exact.
+Code ladder: YAGNI → reuse → stdlib → native → installed dependency → one line → minimum code.
+Never simplify away input validation, data-loss prevention, security, accessibility, or explicit requirements.`;
+
+function loadRules() {
+  try {
+    const skill = fs.readFileSync(path.join(__dirname, '..', 'skills', 'chisle', 'SKILL.md'), 'utf8');
+    return 'CHISLE ACTIVE\n\n' + skill.replace(/^---[\s\S]*?---\s*/, '');
+  } catch (_) {
+    return FALLBACK_RULES;
+  }
+}
+
+function hasRulesEntry(entries) {
+  return (entries || []).some(entry =>
+    (entry.type === 'custom_message' && entry.customType === RULES_TYPE) ||
+    (entry.type === 'message' && entry.message && entry.message.role === 'custom' &&
+      entry.message.customType === RULES_TYPE));
+}
+
+function promptHasRules(event) {
+  const containsRules = text => /^# Chisle\s*$/m.test(text || '') &&
+    (text || '').includes('## Prose: zero fluff') &&
+    (text || '').includes('## Code: the efficiency ladder');
+  if (containsRules(event.systemPrompt)) return true;
+  return (event.systemPromptOptions && event.systemPromptOptions.contextFiles || [])
+    .some(file => containsRules(file.content));
+}
+
+function piToolAllowed(name) {
+  if (!name || NEVER_COMPRESS.has(name.toLowerCase())) return false;
+  if (process.env.CHISLE_COMPRESS_TOOLS) {
+    return process.env.CHISLE_COMPRESS_TOOLS.split(',').map(s => s.trim()).filter(Boolean).includes(name);
+  }
+  return SAFE_TOOLS.has(name.toLowerCase()) || name.startsWith('mcp__');
+}
+
+function chisleExtension(pi) {
+  const rules = loadRules();
+  let active = getDefaultMode() !== 'off';
+  let rulesInContext = false;
+  let savedChars = 0;
+  let lastByToolBlock = new Map();
+  let dedupBaseline = new Map();
+  const stopRulesSignal = pi.events.on('chisle:rules-injected', () => { rulesInContext = true; });
+  const stopModeSignal = pi.events.on('chisle:mode', mode => { active = mode === 'on'; });
+
+  function updateStatus(ctx) {
+    if (!ctx.hasUI) return;
+    if (!active) return ctx.ui.setStatus('chisle', undefined);
+    const tokens = Math.floor(savedChars / 4);
+    const saved = tokens >= 1000 ? ` ⇣${Math.floor(tokens / 1000)}k tok` : tokens ? ` ⇣${tokens} tok` : '';
+    ctx.ui.setStatus('chisle', ctx.ui.theme.fg('accent', `[CHISLE]${saved}`));
+  }
+
+  function restoreBranch(ctx) {
+    active = getDefaultMode() !== 'off';
+    savedChars = 0;
+    lastByToolBlock = new Map();
+    dedupBaseline = new Map();
+
+    const modeEntry = ctx.sessionManager.getBranch()
+      .filter(entry => entry.type === 'custom' && entry.customType === MODE_TYPE).pop();
+    if (modeEntry && modeEntry.data && ['on', 'off'].includes(modeEntry.data.mode)) {
+      active = modeEntry.data.mode === 'on';
+    }
+    rulesInContext = hasRulesEntry(ctx.sessionManager.buildContextEntries());
+    updateStatus(ctx);
+  }
+
+  function setMode(request, ctx) {
+    active = request === 'on';
+    pi.events.emit('chisle:mode', active ? 'on' : 'off');
+    pi.appendEntry(MODE_TYPE, { mode: active ? 'on' : 'off' });
+    updateStatus(ctx);
+    if (ctx.hasUI) ctx.ui.notify(active ? 'Chisle enabled.' : 'Chisle disabled.', 'info');
+  }
+
+  pi.registerCommand('chisle', {
+    description: 'Enable Chisle or set /chisle on|off',
+    handler: async (args, ctx) => {
+      const request = requestedMode(`/chisle ${args || ''}`) || 'on';
+      setMode(request, ctx);
+    },
+  });
+
+  pi.on('session_start', async (_event, ctx) => restoreBranch(ctx));
+  pi.on('session_tree', async (_event, ctx) => restoreBranch(ctx));
+
+  pi.on('session_shutdown', async (_event, ctx) => {
+    lastByToolBlock.clear();
+    dedupBaseline.clear();
+    stopRulesSignal();
+    stopModeSignal();
+    if (ctx.hasUI) ctx.ui.setStatus('chisle', undefined);
+  });
+
+  pi.on('session_compact', async (_event, ctx) => {
+    lastByToolBlock.clear();
+    dedupBaseline.clear();
+    rulesInContext = hasRulesEntry(ctx.sessionManager.buildContextEntries());
+  });
+
+  pi.on('input', async (event, ctx) => {
+    if (event.source === 'extension') return { action: 'continue' };
+    const request = requestedMode(event.text);
+    if (!request) return { action: 'continue' };
+    setMode(request, ctx);
+    return request === 'off' ? { action: 'handled' } : { action: 'continue' };
+  });
+
+  pi.on('before_agent_start', async event => {
+    if (!active) {
+      if (event.systemPrompt.includes('CHISLE DISABLED.')) return;
+      return { systemPrompt: event.systemPrompt + '\n\nCHISLE DISABLED. Ignore only Chisle style and efficiency-ladder instructions.' };
+    }
+    if (rulesInContext || promptHasRules(event)) return;
+    rulesInContext = true;
+    pi.events.emit('chisle:rules-injected');
+    return { message: { customType: RULES_TYPE, content: rules, display: false } };
+  });
+
+  pi.on('context', async event => {
+    if (active) return;
+    return { messages: event.messages.filter(message =>
+      !(message.role === 'custom' && message.customType === RULES_TYPE)) };
+  });
+
+  pi.on('turn_start', async () => {
+    dedupBaseline = new Map(lastByToolBlock);
+  });
+
+  pi.on('tool_result', async (event, ctx) => {
+    try {
+      if (!active || process.env.CHISLE_COMPRESS === '0' || !piToolAllowed(event.toolName) ||
+          !Array.isArray(event.content)) return;
+
+      let changed = false;
+      const content = event.content.map((block, index) => {
+        if (!block || block.type !== 'text' || typeof block.text !== 'string') return block;
+        const text = block.text;
+        const key = `${event.toolName}:${index}`;
+        let updated = null;
+
+        if (process.env.CHISLE_COMPRESS_DEDUP !== '0' && text.length >= DEDUP_MIN) {
+          const hash = crypto.createHash('sha256').update(text).digest('hex');
+          const previous = dedupBaseline.get(key);
+          lastByToolBlock.set(key, hash);
+          if (previous === hash) updated = duplicateMarker(event.toolName, text, 'earlier');
+        }
+        if (updated == null) updated = transform(text, limitsFor());
+        if (updated == null || updated.length >= text.length) return block;
+        changed = true;
+        savedChars += text.length - updated.length;
+        return { ...block, text: updated };
+      });
+
+      if (!changed) return;
+      updateStatus(ctx);
+      return { content };
+    } catch (_) {
+      return;
+    }
+  });
+}
+
+module.exports = chisleExtension;
+module.exports.loadRules = loadRules;
+module.exports.hasRulesEntry = hasRulesEntry;
+module.exports.piToolAllowed = piToolAllowed;