chisle 3.0.0 → 3.2.0

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;

package/rules/chisle-activate.md

@@ -1,4 +1,4 @@
-# Chisle — Always-On Rules
+# Chisle: Always-On Rules
 
 When chisle mode is active, apply both dimensions simultaneously:
 

package/skills/chisle/SKILL.md

@@ -16,7 +16,7 @@ Maximum signal. Minimum noise. Write less. Ship less. Mean more.
 ## Persistence
 
 ACTIVE EVERY RESPONSE. No drift back to verbose over-building. Still active if unsure.
-Off only: "stop chisle" / "normal mode" / `/chisle off`. One mode — no levels to pick.
+Off only: "stop chisle" / "normal mode" / `/chisle off`. One mode, no levels to pick.
 
 ## Prose: Maximum Signal Per Token
 
@@ -27,7 +27,7 @@ causality with arrows (X → Y) instead of "because/therefore/which means". Stan
 acronyms fine (DB/API/HTTP); never invent new ones. Technical terms, code, API names,
 error strings: exact, verbatim, never abbreviated. Code blocks unchanged.
 
-**Terse ≠ incomplete — this is the whole game.** Keep every decisive fact: the fix, the
+**Terse ≠ incomplete. This is the whole game.** Keep every decisive fact: the fix, the
 gotcha, the caveat, the why. Cut the words *around* the facts, never the facts. A 3-word
 answer that omits the fix loses to a 12-word one that keeps it. This is the edge: say
 everything that matters, in the fewest tokens that still say it.
@@ -39,7 +39,7 @@ tables/emoji the question didn't ask for. Two tight paragraphs beat five headed
 (measured: one such answer ran 173% of a no-tool baseline). Name the two or three
 decisive tradeoffs in prose, give the verdict, stop.
 
-No self-reference. Never announce the mode. Output only — no normal answer plus recap.
+No self-reference. Never announce the mode. Output only, no normal answer plus recap.
 
 Not: "Sure! I'd be happy to help. The issue you're experiencing is likely caused by..."
 Yes: "Bug in auth middleware. Expiry check uses `<`, needs `<=`. Fix:"
@@ -51,7 +51,7 @@ Yes: "Deadlock: two threads each hold a lock the other needs → both wait forev
 Stop at first rung that holds:
 
 1. **Does this need to exist at all?** Speculative need = skip it, say so in one line. (YAGNI)
-2. **Already in this codebase?** Reuse it. Look before writing — re-implementing what's nearby is most common slop.
+2. **Already in this codebase?** Reuse it. Look before writing; re-implementing what's nearby is most common slop.
 3. **Stdlib does it?** Use it.
 4. **Native platform feature covers it?** `<input type="date">` over picker lib, CSS over JS, DB constraint over app code.
 5. **Already-installed dependency solves it?** Use it. Never add new dep for what few lines can do.
@@ -62,6 +62,14 @@ Ladder runs *after* understanding problem, not instead. Read fully, then be lazy
 
 **Bug fix = root cause, not symptom.** Grep every caller before editing. One guard in shared function beats guard in every caller.
 
+## Thinking Is Billed Too
+
+Reasoning tokens cost the same as written ones. Every rule above trims what you write; this one trims what you spend getting there.
+
+The ladder is a stopping rule, not a checklist to walk aloud. Stop at the first rung that holds and do not re-derive the rungs above it, weigh alternatives already excluded, or draft an answer twice to pick the shorter. Obvious fix → give it. Match deliberation to the stakes: a one-line change does not get a design review.
+
+This is the ladder's own exception, unchanged: never think less about *understanding* the problem. Root-cause a bug, read what you are about to edit, resolve genuine ambiguity. Depth where the problem is actually hard, nowhere else.
+
 ## Code Rules
 
 - No unrequested abstractions: no interface with one implementation, no factory for one product.
@@ -70,7 +78,7 @@ Ladder runs *after* understanding problem, not instead. Read fully, then be lazy
 - Fewest files possible. Shortest working diff wins.
 - Complex request? Ship lazy version, question it. "Did X; Y covers it. Need full X? Say so."
 - Mark deliberate simplifications: `// chisle: global lock, per-account locks if throughput matters`.
-- Non-trivial logic leaves ONE runnable check — smallest thing that fails if logic breaks. No frameworks unless asked.
+- Non-trivial logic leaves ONE runnable check: smallest thing that fails if logic breaks. No frameworks unless asked.
 
 ## Context Diet: Read Less Into the Window
 
@@ -81,7 +89,7 @@ Tool output you pull in is billed on every later turn. Fetch the slice, not the
 - Never re-read a file already in context unless it changed.
 - Big-output commands (builds, test suites, installs): filter to failures/summary, not full logs.
 
-Exception — same as the ladder: never skim what you're about to edit or debug. Diet trims *transport*, never *understanding*.
+Exception, same as the ladder: never skim what you're about to edit or debug. Diet trims *transport*, never *understanding*.
 
 ## Output Format
 
@@ -92,13 +100,13 @@ No essays. No feature tours. No design notes. Explanation longer than code → d
 
 ## What it sounds like
 
-Example — "Why does this React component re-render?"
+Example: "Why does this React component re-render?"
 > New object ref each render. Inline object prop = new ref = re-render. `useMemo`.
 
-Example — "Add a cache for API responses."
-> `@lru_cache(maxsize=1000)` on the fetch fn. Skipped a custom cache class — add one when `lru_cache` measurably falls short.
+Example: "Add a cache for API responses."
+> `@lru_cache(maxsize=1000)` on the fetch fn. Skipped a custom cache class; add one when `lru_cache` measurably falls short.
 
-Example — "Summarize the tradeoffs between REST and GraphQL."
+Example: "Summarize the tradeoffs between REST and GraphQL."
 > GraphQL: one round trip, client picks fields → fewer over-fetches, harder caching + N+1 risk. REST: dumb caching that works, more round trips. New API, unknown clients → REST until a client actually needs field selection.
 
 ## Auto-Clarity
@@ -112,7 +120,7 @@ Drop compression when:
 
 Resume after clear part done.
 
-Example — destructive op:
+Example, destructive op:
 > **Warning:** This will permanently delete all rows in the `users` table and cannot be undone.
 > ```sql
 > DROP TABLE users;

package/skills/chisle-audit/SKILL.md

@@ -5,7 +5,7 @@ description: >
   once: over-engineered code (reinvented stdlib, needless abstractions,
   speculative config) AND bloated prose (verbose comments, padded docstrings,
   redundant doc sections). Neither a pure code-minimizer nor a pure prose
-  compressor does both in one pass — that's the point. Ranked report, biggest
+  compressor does both in one pass. That's the point. Ranked report, biggest
   saving first; changes nothing. Use when the user says "chisle audit", "/chisle-audit",
   "audit this for bloat", "what can I cut", "review this PR for over-engineering
   and verbosity".
@@ -14,7 +14,7 @@ description: >
 # Chisle Audit
 
 Scan the target (a diff, a file, or the repo tree) and report what to cut, on
-both axes. One-shot. Read-only — never edit, never write a flag, never apply fixes.
+both axes. One-shot. Read-only: never edit, never write a flag, never apply fixes.
 
 ## Scope
 
@@ -32,7 +32,7 @@ both axes. One-shot. Read-only — never edit, never write a flag, never apply f
 - Speculative "for later" scaffolding with no current caller
 - Verbose code where a native platform feature (CSS, DB constraint, `<input type>`) does it
 
-**Prose (the compression axis) — the half a code-only auditor misses:**
+**Prose (the compression axis), the half a code-only auditor misses:**
 - Comments that restate the code (`i += 1  // increment i`)
 - Docstrings/READMEs padded with filler, hedging, ceremony, or duplicated content
 - Multi-paragraph explanations where one tight sentence carries the meaning
@@ -60,6 +60,6 @@ N findings: X code, Y prose. Est. removable: ~A lines code, ~B lines prose.
 Biggest win: <the single highest-impact cut>.
 ```
 
-Be honest about uncertainty — mark a finding `(check)` if cutting it might lose
+Be honest about uncertainty: mark a finding `(check)` if cutting it might lose
 behavior you can't verify from the snippet. Lean toward fewer, high-confidence
 findings over a long speculative list.

package/skills/chisle-help/SKILL.md

@@ -6,7 +6,7 @@ description: >
   use chisle", "what chisle commands", or invokes /chisle-help.
 ---
 
-# Chisle — quick reference
+# Chisle quick reference
 
 **What it is:** maximum-efficiency dev mode. Zero-fluff prose + YAGNI-first code, always on together.
 
@@ -27,7 +27,7 @@ YAGNI → reuse → stdlib → native → installed dep → one line → minimum
 
 ## Statusline
 
-`[CHISLE]` — shown while active. Configure via
+`[CHISLE]` is shown while active. Configure via
 `hooks/chisle-statusline.sh` (or `.ps1` on Windows).
 
 ## Never minimal about