chisle 2.0.0 → 3.1.0

package/commands/chisle.toml

@@ -1,8 +1,7 @@
 # chisle slash command
 # Maximum-efficiency dev mode
-# Usage: /chisle [lite|full|ultra]
+# Usage: /chisle  ·  /chisle off
 
 [command]
 name = "chisle"
-description = "Activate chisle mode: zero-fluff prose + YAGNI ladder code decisions. Levels: lite, full (default), ultra."
-argument-hint = "[lite|full|ultra]"
+description = "Activate chisle: zero-fluff prose + YAGNI ladder code decisions. /chisle off to stop."

package/hooks/chisle-activate.js

@@ -3,13 +3,13 @@
 //
 // 1. Writes flag at $CLAUDE_CONFIG_DIR/.chisle-active
 // 2. Resets session turn counter
-// 3. Emits chisle ruleset (filtered to active level) as system context
+// 3. Emits the chisle ruleset as system context
 // 4. Nudges user to configure statusline if missing
 // 5. Major-version update notice (majors only, cached, fail-silent)
 
 const fs = require('fs');
 const path = require('path');
-const { getDefaultMode, getClaudeDir, safeWriteFlag } = require('./chisle-config');
+const { getDefaultMode, getClaudeDir, safeWriteFlag, legacySetting } = require('./chisle-config');
 
 // ── Update-notice helpers (pure — tested directly) ─────────────────────────
 // Minor/patch releases stay quiet: a nudge per major is signal, more is spam.
@@ -55,8 +55,16 @@ async function latestVersion(cachePath) {
   } catch (e) { return null; }
 }
 
+// SessionStart fires on startup, resume, clear and compact. Only a genuinely
+// new session needs the whole ruleset: on the other three the conversation
+// already carries it, and the UserPromptSubmit reminder re-states the active
+// behaviour every turn anyway. Re-sending ~1.6k tokens each time was the bulk
+// of the plugin's own overhead and piled standing instructions on top of what
+// the user actually asked for. Measured and reported by @enc0ded (#2).
+const FULL_INJECT_SOURCES = new Set(['startup']);
+
 // ── Hook body ───────────────────────────────────────────────────────────────
-function run() {
+function run(source) {
   const claudeDir = getClaudeDir();
   const flagPath = path.join(claudeDir, '.chisle-active');
   const settingsPath = path.join(claudeDir, 'settings.json');
@@ -72,8 +80,17 @@ function run() {
   // 1. Write flag
   safeWriteFlag(flagPath, mode);
 
-  // 2. Read SKILL.md — single source of truth for behavior
-  const modeLabel = mode;
+  // 2. Resumed/cleared/compacted session: reactivate, don't re-teach.
+  if (!FULL_INJECT_SOURCES.has(source)) {
+    process.stdout.write(
+      'CHISLE ACTIVE (resumed). ' +
+      'Ruleset already in context; see the chisle skill if it is not.'
+    );
+    return;
+  }
+
+  // 3. Read SKILL.md — single source of truth for behaviour. No level
+  // filtering any more: there is one mode, so the whole body ships.
   let skillContent = '';
   try {
     skillContent = fs.readFileSync(
@@ -84,31 +101,14 @@ function run() {
   let output;
 
   if (skillContent) {
-    const body = skillContent.replace(/^---[\s\S]*?---\s*/, '');
-
-    const filtered = body.split('\n').reduce((acc, line) => {
-      const tableRowMatch = line.match(/^\|\s*\*\*(\S+?)\*\*\s*\|/);
-      if (tableRowMatch) {
-        if (tableRowMatch[1] === modeLabel) acc.push(line);
-        return acc;
-      }
-      const exampleMatch = line.match(/^- (\S+?):\s/);
-      if (exampleMatch) {
-        if (exampleMatch[1] === modeLabel) acc.push(line);
-        return acc;
-      }
-      acc.push(line);
-      return acc;
-    }, []);
-
-    output = 'CHISLE MODE ACTIVE — level: ' + modeLabel + '\n\n' + filtered.join('\n');
+    output = 'CHISLE ACTIVE\n\n' + skillContent.replace(/^---[\s\S]*?---\s*/, '');
   } else {
     // Fallback ruleset when SKILL.md not found
     output =
-      'CHISLE MODE ACTIVE — level: ' + modeLabel + '\n\n' +
+      'CHISLE ACTIVE\n\n' +
       'Chisle: maximum-efficiency dev mode. Zero-fluff prose. YAGNI-first code.\n\n' +
       '## Persistence\n\n' +
-      'ACTIVE EVERY RESPONSE. Off only: "stop chisle" / "normal mode". Switch: `/chisle lite|full|ultra`.\n\n' +
+      'ACTIVE EVERY RESPONSE. Off only: "stop chisle" / "normal mode".\n\n' +
       '## Prose\n\n' +
       'Drop articles/filler/pleasantries/hedging. Fragments OK. Technical terms exact.\n\n' +
       '## Code\n\n' +
@@ -131,14 +131,25 @@ function run() {
       const statusLineSnippet =
         '"statusLine": { "type": "command", "command": ' + JSON.stringify(command) + ' }';
       output += '\n\n' +
-        'STATUSLINE SETUP NEEDED: The chisle plugin includes a statusline badge showing active mode ' +
-        '(e.g. [CHISLE], [CHISLE:ULTRA]) with token savings. It is not configured yet. ' +
+        'STATUSLINE SETUP NEEDED: The chisle plugin includes a statusline badge ' +
+        '([CHISLE]) with token savings. It is not configured yet. ' +
         'To enable, add this to ' + settingsPath + ': ' +
         statusLineSnippet + ' ' +
         'Proactively offer to set this up for the user on first interaction.';
     }
   } catch (e) {}
 
+  // 3b. One-time courtesy for the 3.0.0 upgrade: a lite/full/ultra setting is
+  // no longer meaningful. Chisle still runs (the value falls through to the
+  // default), but silently ignoring a setting someone chose is worse than
+  // saying so once.
+  const legacy = legacySetting();
+  if (legacy) {
+    output += '\n\nCHISLE NOTE: `' + legacy.value + '` came from ' + legacy.source +
+      '. Intensity levels were removed in 3.0.0 — there is one mode now, and it is ' +
+      'active. Set it to `on` or `off`, or drop it entirely. Mention this once.';
+  }
+
   // 4. Update notice, then emit. CHISLE_UPDATE_CHECK=0 disables.
   (async () => {
     try {
@@ -155,6 +166,24 @@ function run() {
   })();
 }
 
-if (require.main === module) run();
+// Claude Code pipes the hook payload (including `source`) on stdin. If it is
+// absent or unparseable, fall back to a full inject — over-teaching once is a
+// far cheaper failure than a session that never receives the ruleset at all.
+function main() {
+  let input = '';
+  process.stdin.on('data', chunk => { input += chunk; });
+  process.stdin.on('end', () => {
+    let source = 'startup';
+    try {
+      const parsed = JSON.parse(input.replace(/^/, ''));
+      if (parsed && typeof parsed.source === 'string') source = parsed.source;
+    } catch (e) {}
+    run(source);
+  });
+  // stdin never opened (manual run): behave like a fresh session.
+  if (process.stdin.isTTY) run('startup');
+}
+
+if (require.main === module) main();
 
 module.exports = { majorOf, majorUpdateNotice };

package/hooks/chisle-compress-output.js

@@ -19,11 +19,11 @@
 //   scrub  (output > 1k)  — lossless: strip ANSI escapes, collapse blank-line
 //                           runs, collapse ≥4 identical consecutive lines to
 //                           one + "[repeated N×]". No information lost.
-//   elide  (output > mode threshold) — head + tail + error salvage, as above.
+//   elide  (output > threshold) — head + tail + error salvage, as above.
 // 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 tracks the /chisle mode flag (off → untouched). Tunables via env:
+// Compression follows the /chisle flag (off → untouched). Tunables via env:
 //   CHISLE_COMPRESS=0                 — kill switch
 //   CHISLE_COMPRESS_SCRUB=0           — disable the lossless scrub tier
 //   CHISLE_COMPRESS_DEDUP=0           — disable duplicate-output markers
@@ -39,12 +39,10 @@ const path = require('path');
 const crypto = require('crypto');
 const { getClaudeDir, readFlag } = require('./chisle-config');
 
-// Mode → thresholds. Tighter mode, tighter budget. Env overrides all.
-const THRESHOLDS = {
-  lite:  { maxChars: 16000, headLines: 100, tailLines: 80 },
-  full:  { maxChars: 8000,  headLines: 60,  tailLines: 40 },
-  ultra: { maxChars: 5000,  headLines: 40,  tailLines: 30 },
-};
+// One threshold. Env overrides all.
+// These are the values the old 'full' level used — the default,
+// and the only one the published benchmarks ever ran at.
+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.
@@ -66,8 +64,8 @@ function envInt(name, fallback) {
   return Number.isFinite(n) && n > 0 ? n : fallback;
 }
 
-function limitsFor(mode) {
-  const base = THRESHOLDS[mode] || THRESHOLDS.full;
+function limitsFor() {
+  const base = THRESHOLDS;
   return {
     maxChars: envInt('CHISLE_COMPRESS_MAX_CHARS', base.maxChars),
     headLines: envInt('CHISLE_COMPRESS_HEAD_LINES', base.headLines),
@@ -132,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;
@@ -144,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; }
 }
 
@@ -225,6 +237,32 @@ function transform(text, limits) {
   return text.length - t.length >= MIN_WIN ? t : null;
 }
 
+// Put the compressed text back into the ORIGINAL response shape.
+//
+// Claude Code validates updatedToolOutput against the tool's own output schema
+// before applying it. Bash results are objects ({stdout, stderr, ...}), so
+// handing back a bare string is rejected on every call — the hook appears to
+// 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).
+function rebuildResponse(response, updated) {
+  if (response == null || typeof response === 'string') return updated;
+  if (typeof response === 'object' && !Array.isArray(response)) {
+    for (const key of ['stdout', 'output', 'content', 'text', 'result']) {
+      if (typeof response[key] === 'string') {
+        const out = { ...response, [key]: updated };
+        // extractText already folded stderr into the compressed text; leaving
+        // the original stderr in place would duplicate it.
+        if (key === 'stdout' && typeof response.stderr === 'string') out.stderr = '';
+        return out;
+      }
+    }
+  }
+  // Unrecognized shape (e.g. MCP content-block arrays). Skip rather than guess:
+  // a wrong shape is silently rejected, which is the bug this function fixes.
+  return null;
+}
+
 // Full pipeline on one hook payload → updated output string, or null to keep
 // the original. Pure given (payload, mode, env) except dedup state.
 function processPayload(payload, mode) {
@@ -235,9 +273,9 @@ 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(mode));
+  return transform(text, limitsFor());
 }
 
 function main() {
@@ -249,12 +287,18 @@ function main() {
       const mode = readFlag(path.join(getClaudeDir(), '.chisle-active'));
       const updated = processPayload(payload, mode);
       if (updated == null) return;
-      const original = extractText(payload.tool_response != null ? payload.tool_response : payload.tool_output);
+      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.
+      if (rebuilt == null) return;
+      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);
       process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
           hookEventName: 'PostToolUse',
-          updatedToolOutput: updated,
+          updatedToolOutput: rebuilt,
         },
       }));
     } catch (e) {} // silent — never break the tool pipeline
@@ -263,4 +307,4 @@ function main() {
 
 if (require.main === module) main();
 
-module.exports = { extractText, 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-config.js

@@ -4,13 +4,35 @@
 // Resolution order for default mode:
 //   1. CHISLE_DEFAULT_MODE environment variable
 //   2. User config: $XDG_CONFIG_HOME/chisle/config.json, ~/.config/chisle/config.json
-//   3. 'full'
+//   3. 'on'
 
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const VALID_MODES = ['off', 'lite', 'full', 'ultra'];
+// One mode. The intensity levels are gone: three dials on a tool whose whole
+// argument is "fewer knobs" was the joke writing itself, and the middle setting
+// was the only one ever benchmarked. 'on' or 'off'.
+const VALID_MODES = ['off', 'on'];
+
+// Values that meant something before 3.0.0. Kept only so the upgrade can say
+// "your setting no longer does anything" instead of ignoring it in silence.
+const LEGACY_MODES = ['lite', 'full', 'ultra'];
+
+// Returns the stale value and where it came from, or null. Never throws.
+function legacySetting() {
+  const env = process.env.CHISLE_DEFAULT_MODE;
+  if (env && LEGACY_MODES.includes(String(env).toLowerCase())) {
+    return { value: String(env).toLowerCase(), source: 'CHISLE_DEFAULT_MODE' };
+  }
+  try {
+    const p = path.join(getConfigDir(), 'config.json');
+    const c = JSON.parse(fs.readFileSync(p, 'utf8'));
+    const v = c && c.defaultMode ? String(c.defaultMode).toLowerCase() : null;
+    if (v && LEGACY_MODES.includes(v)) return { value: v, source: p };
+  } catch (e) {}
+  return null;
+}
 
 function getClaudeDir() {
   return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
@@ -48,7 +70,7 @@ function getDefaultMode() {
   }
   const userMode = readModeFromConfigFile(path.join(getConfigDir(), 'config.json'));
   if (userMode) return userMode;
-  return 'full';
+  return 'on';
 }
 
 // Symlink-safe, atomic flag write with 0600 perms.
@@ -149,4 +171,7 @@ function readFlag(flagPath) {
   }
 }
 
-module.exports = { getDefaultMode, getClaudeDir, VALID_MODES, safeWriteFlag, readFlag };
+module.exports = {
+  LEGACY_MODES, legacySetting, getDefaultMode, getClaudeDir,
+  VALID_MODES, safeWriteFlag, readFlag,
+};

package/hooks/chisle-mode-tracker.js

@@ -5,7 +5,8 @@
 
 const fs = require('fs');
 const path = require('path');
-const { getDefaultMode, getClaudeDir, VALID_MODES, 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,68 +17,25 @@ 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
-    if (/^\/chisle(\b|:chisle\b)/.test(promptLower)) {
-      const parts = promptLower.split(/\s+/);
-      const cmd = parts[0];
-      const arg = parts[1] || '';
-
-      let mode = null;
-
-      if (cmd === '/chisle' || cmd === '/chisle:chisle') {
-        if (!arg) {
-          mode = getDefaultMode();
-        } else if (arg === 'off' || arg === 'stop' || arg === 'disable') {
-          mode = 'off';
-        } else if (VALID_MODES.includes(arg)) {
-          mode = arg;
-        }
-      }
-
-      if (mode && mode !== 'off') {
-        safeWriteFlag(flagPath, mode);
-      } else if (mode === 'off') {
-        try { fs.unlinkSync(flagPath); } catch (e) {}
-      }
-    }
-
-    // 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
     const activeMode = readFlag(flagPath);
     if (activeMode && activeMode !== 'off') {
       // Inject compact reminder — keeps chisle visible across context compression
-      const ladderHint = activeMode === 'ultra'
-        ? 'YAGNI extremist: delete before add, challenge req in same breath.'
-        : 'Code: YAGNI ladder first (stdlib → native → dep → one line → min code).';
-
       process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
           hookEventName: 'UserPromptSubmit',
           additionalContext:
-            'CHISLE MODE ACTIVE (' + activeMode + '). ' +
+            'CHISLE ACTIVE. ' +
             'Prose: drop articles/filler/pleasantries/hedging. Fragments OK. ' +
-            ladderHint + ' ' +
+            'Code: YAGNI ladder first (reuse → stdlib → native → dep → one line → min code). ' +
             'Code/commits/security: write normal.'
         }
       }));

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/hooks/chisle-statusline.ps1

@@ -21,10 +21,8 @@ $mode = $raw.Substring(0, [Math]::Min(64, $raw.Length)).ToLower()
 $mode = ($mode -replace '[^a-z0-9-]', '')
 
 switch ($mode) {
-  'off'   { }
-  'lite'  { }
-  'full'  { }
-  'ultra' { }
+  'off' { }
+  'on'  { }
   default { exit 0 }
 }
 
@@ -47,8 +45,5 @@ if ($sitem -and -not ($sitem.Attributes -band [IO.FileAttributes]::ReparsePoint)
   }
 }
 
-if ([string]::IsNullOrEmpty($mode) -or $mode -eq 'full') {
-  Write-Host -NoNewline "$orange[CHISLE]$reset$suffix"
-} else {
-  Write-Host -NoNewline ("{0}[CHISLE:{1}]{2}{3}" -f $orange, $mode.ToUpper(), $reset, $suffix)
-}
+# One mode, one badge.
+Write-Host -NoNewline "$orange[CHISLE]$reset$suffix"

package/hooks/chisle-statusline.sh

@@ -21,7 +21,7 @@ MODE=$(printf '%s' "$MODE" | tr -cd 'a-z0-9-')
 
 # Whitelist — render nothing for unknown values rather than echo attacker bytes.
 case "$MODE" in
-  off|lite|full|ultra) ;;
+  off|on) ;;
   *) exit 0 ;;
 esac
 
@@ -85,10 +85,5 @@ if [ -f "$STATS" ] && [ ! -L "$STATS" ]; then
   fi
 fi
 
-# Orange badge + loading bars trailing outside the bracket
-if [ -z "$MODE" ] || [ "$MODE" = "full" ]; then
-  printf '\033[38;5;172m[CHISLE]\033[0m%s' "$LIMITS"
-else
-  SUFFIX=$(printf '%s' "$MODE" | tr '[:lower:]' '[:upper:]')
-  printf '\033[38;5;172m[CHISLE:%s]\033[0m%s' "$SUFFIX" "$LIMITS"
-fi
+# Orange badge + loading bars trailing outside the bracket. One mode, one badge.
+printf '\033[38;5;172m[CHISLE]\033[0m%s' "$LIMITS"

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "chisle",
-  "version": "2.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,17 +40,28 @@
   "engines": {
     "node": ">=18"
   },
+  "pi": {
+    "extensions": [
+      "./pi-extension/index.js"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
   "scripts": {
     "test": "node --test tests/*.js",
     "build:rules": "node scripts/build-rules.js",
     "check:rules": "node scripts/build-rules.js --check",
     "build:chart": "node scripts/build-chart.js",
     "check:chart": "node scripts/build-chart.js --check",
-    "bench": "bash benchmarks/run-live.sh"
+    "bench": "bash benchmarks/run-live.sh",
+    "build:samples": "node scripts/build-samples.js",
+    "check:samples": "node scripts/build-samples.js --check"
   },
   "files": [
     "bin/",
     "hooks/",
+    "pi-extension/",
     "skills/",
     "commands/",
     "rules/",