chisle 2.0.0

package/hooks/chisle-activate.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+// chisle — SessionStart hook
+//
+// 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
+// 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');
+
+// ── Update-notice helpers (pure — tested directly) ─────────────────────────
+// Minor/patch releases stay quiet: a nudge per major is signal, more is spam.
+const UPDATE_CACHE_MS = 3 * 24 * 60 * 60 * 1000;
+
+function majorOf(v) {
+  const m = /^(\d+)\./.exec(String(v || ''));
+  return m ? parseInt(m[1], 10) : null;
+}
+
+// Notice line for a major jump, else null.
+function majorUpdateNotice(installed, latest) {
+  const i = majorOf(installed), l = majorOf(latest);
+  if (i == null || l == null || l <= i) return null;
+  return '\n\nCHISLE UPDATE AVAILABLE: v' + latest + ' (major; you run v' + installed + '). ' +
+    'Mention this to the user once: update with `claude plugin update chisle@chisle` or `npx chisle`.';
+}
+
+function installedVersion() {
+  try {
+    return JSON.parse(fs.readFileSync(
+      path.join(__dirname, '..', '.claude-plugin', 'plugin.json'), 'utf8')).version;
+  } catch (e) { return null; } // standalone-hooks install → no manifest → skip
+}
+
+// Registry lookup, cached on disk. Network capped at 1.5s inside the 5s hook budget.
+async function latestVersion(cachePath) {
+  try {
+    const c = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+    if (c && Date.now() - c.checkedAt < UPDATE_CACHE_MS) return c.latest;
+  } catch (e) {}
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 1500);
+    const res = await fetch('https://registry.npmjs.org/chisle/latest', { signal: ctrl.signal });
+    clearTimeout(t);
+    if (!res.ok) return null;
+    const latest = (await res.json()).version;
+    try {
+      fs.writeFileSync(cachePath, JSON.stringify({ checkedAt: Date.now(), latest }), { mode: 0o600 });
+    } catch (e) {}
+    return latest;
+  } catch (e) { return null; }
+}
+
+// ── Hook body ───────────────────────────────────────────────────────────────
+function run() {
+  const claudeDir = getClaudeDir();
+  const flagPath = path.join(claudeDir, '.chisle-active');
+  const settingsPath = path.join(claudeDir, 'settings.json');
+
+  const mode = getDefaultMode();
+
+  if (mode === 'off') {
+    try { fs.unlinkSync(flagPath); } catch (e) {}
+    process.stdout.write('OK');
+    process.exit(0);
+  }
+
+  // 1. Write flag
+  safeWriteFlag(flagPath, mode);
+
+  // 2. Read SKILL.md — single source of truth for behavior
+  const modeLabel = mode;
+  let skillContent = '';
+  try {
+    skillContent = fs.readFileSync(
+      path.join(__dirname, '..', 'skills', 'chisle', 'SKILL.md'), 'utf8'
+    );
+  } catch (e) {}
+
+  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');
+  } else {
+    // Fallback ruleset when SKILL.md not found
+    output =
+      'CHISLE MODE ACTIVE — level: ' + modeLabel + '\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' +
+      '## Prose\n\n' +
+      'Drop articles/filler/pleasantries/hedging. Fragments OK. Technical terms exact.\n\n' +
+      '## Code\n\n' +
+      'Ladder: YAGNI → reuse → stdlib → native → installed dep → one line → min code.\n' +
+      'No unrequested abstractions. Deletion over addition. Shortest diff wins.';
+  }
+
+  // 3. Detect missing statusline config
+  try {
+    let hasStatusline = false;
+    if (fs.existsSync(settingsPath)) {
+      const raw = fs.readFileSync(settingsPath, 'utf8').replace(/^/, '');
+      const settings = JSON.parse(raw);
+      if (settings.statusLine) hasStatusline = true;
+    }
+
+    if (!hasStatusline) {
+      const scriptPath = path.join(__dirname, 'chisle-statusline.sh');
+      const command = `bash "${scriptPath}"`;
+      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. ' +
+        'To enable, add this to ' + settingsPath + ': ' +
+        statusLineSnippet + ' ' +
+        'Proactively offer to set this up for the user on first interaction.';
+    }
+  } catch (e) {}
+
+  // 4. Update notice, then emit. CHISLE_UPDATE_CHECK=0 disables.
+  (async () => {
+    try {
+      if (process.env.CHISLE_UPDATE_CHECK !== '0') {
+        const installed = installedVersion();
+        if (installed) {
+          const latest = await latestVersion(path.join(claudeDir, '.chisle-update-check.json'));
+          const notice = majorUpdateNotice(installed, latest);
+          if (notice) output += notice;
+        }
+      }
+    } catch (e) {}
+    process.stdout.write(output);
+  })();
+}
+
+if (require.main === module) run();
+
+module.exports = { majorOf, majorUpdateNotice };

package/hooks/chisle-compress-output.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+// chisle — PostToolUse hook: tool-output compression (the input axis).
+//
+// Prompt-side rules shrink what the agent WRITES; this shrinks what it READS.
+// Oversized tool results (Bash dumps, subagent reports, web fetches) get their
+// repetitive middle elided — head kept (command context), tail kept (results/
+// errors), error-looking lines salvaged from the cut — and the trimmed version
+// replaces what the model sees via `updatedToolOutput`. Deterministic, zero
+// LLM, zero network. Small outputs pass through untouched.
+//
+// Correctness guardrails (why this never touches Read/Edit/Write):
+//   - Read output feeds later Edit old_string matching — eliding it makes the
+//     model edit against text it never saw. Allowlist below, never a blocklist.
+//   - Error lines in the elided middle are salvaged, capped, and kept verbatim.
+//   - If compression doesn't shrink the output, the original is kept.
+//   - Never throws: a broken hook must not break the tool pipeline.
+//
+// Two tiers, applied in order:
+//   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.
+// 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:
+//   CHISLE_COMPRESS=0                 — kill switch
+//   CHISLE_COMPRESS_SCRUB=0           — disable the lossless scrub tier
+//   CHISLE_COMPRESS_DEDUP=0           — disable duplicate-output markers
+//   CHISLE_COMPRESS_MAX_CHARS         — outputs at/under this size are not elided
+//   CHISLE_COMPRESS_HEAD_LINES        — lines kept from the top
+//   CHISLE_COMPRESS_TAIL_LINES        — lines kept from the bottom
+//   CHISLE_COMPRESS_TOOLS=Bash,Grep   — override the tool allowlist
+//
+// Savings accrue in <claudeDir>/.chisle-compress-stats.json for the statusline.
+
+const fs = require('fs');
+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 },
+};
+
+// 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.
+const SAFE_TOOLS = ['Bash', 'Agent', 'WebFetch', 'WebSearch', 'Grep', 'Glob'];
+const SALVAGE_RE = /\b(error|err!|fail(ed|ure|ing)?|exception|traceback|panic|fatal|denied|refused|timed?[ _-]?out|assert(ion)?|segfault|npe|undefined reference|cannot find|not found|warning)\b/i;
+const MAX_SALVAGED = 12;      // error lines rescued from the elided middle
+const MAX_SALVAGE_LINE = 300; // per-line char cap on salvaged lines
+
+function toolAllowed(name) {
+  if (!name || typeof name !== 'string') return false;
+  const list = process.env.CHISLE_COMPRESS_TOOLS
+    ? process.env.CHISLE_COMPRESS_TOOLS.split(',').map(s => s.trim()).filter(Boolean)
+    : SAFE_TOOLS;
+  return list.includes(name) || (!process.env.CHISLE_COMPRESS_TOOLS && name.startsWith('mcp__'));
+}
+
+function envInt(name, fallback) {
+  const n = parseInt(process.env[name], 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+function limitsFor(mode) {
+  const base = THRESHOLDS[mode] || THRESHOLDS.full;
+  return {
+    maxChars: envInt('CHISLE_COMPRESS_MAX_CHARS', base.maxChars),
+    headLines: envInt('CHISLE_COMPRESS_HEAD_LINES', base.headLines),
+    tailLines: envInt('CHISLE_COMPRESS_TAIL_LINES', base.tailLines),
+  };
+}
+
+// Pull a plain-text payload out of tool_response, whatever its shape.
+function extractText(response) {
+  if (response == null) return null;
+  if (typeof response === 'string') return response;
+  if (Array.isArray(response)) {
+    const parts = response.map(b => (b && typeof b.text === 'string') ? b.text : extractText(b && b.content)).filter(Boolean);
+    return parts.length ? parts.join('\n') : null;
+  }
+  if (typeof response === 'object') {
+    const parts = [];
+    for (const key of ['stdout', 'stderr', 'output', 'content', 'text', 'result']) {
+      const val = response[key];
+      if (typeof val === 'string' && val) parts.push(val);
+      else if (val && typeof val === 'object') { const t = extractText(val); if (t) parts.push(t); }
+    }
+    if (parts.length) return parts.join('\n');
+    try { return JSON.stringify(response); } catch (e) { return null; }
+  }
+  return String(response);
+}
+
+// ── Tier 1: lossless scrub ───────────────────────────────────────────────────
+// ANSI/OSC escapes are invisible to the model; blank runs and identical
+// consecutive lines carry their information in one copy.
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+const SCRUB_MIN = 1024;      // below this, not worth a hook round-trip
+const REPEAT_MIN = 4;        // identical consecutive lines before collapsing
+const MIN_WIN = 64;          // emit updated output only if it saves this much
+
+function scrub(text) {
+  let t = text.replace(ANSI_RE, '');
+  t = t.replace(/[ \t]+$/gm, '');            // trailing whitespace
+  t = t.replace(/\n{3,}/g, '\n\n');          // blank-line runs → one blank
+  // Collapse runs of identical non-empty lines.
+  const lines = t.split('\n');
+  const out = [];
+  for (let i = 0; i < lines.length; ) {
+    let j = i;
+    while (j < lines.length && lines[j] === lines[i]) j++;
+    const n = j - i;
+    if (n >= REPEAT_MIN && lines[i].trim()) {
+      out.push(lines[i], `... [chisle: line repeated ${n}×] ...`);
+    } else {
+      for (let k = 0; k < n; k++) out.push(lines[i]);
+    }
+    i = j;
+  }
+  return out.join('\n');
+}
+
+// ── Dedup: identical to this tool's previous output ─────────────────────────
+// The identical content is already in context verbatim, so a marker loses
+// nothing — but ONLY within the same session: a fresh session's context does
+// not contain the earlier copy, so state is keyed by session_id and dedup is
+// skipped when the payload carries none.
+const DEDUP_MIN = 2048;
+
+function dedupCheck(toolName, text, sessionId) {
+  if (process.env.CHISLE_COMPRESS_DEDUP === '0') return null;
+  if (!sessionId || typeof sessionId !== 'string') return null;
+  if (text.length < DEDUP_MIN) return null;
+  try {
+    const p = path.join(getClaudeDir(), '.chisle-compress-last.json');
+    try { if (fs.lstatSync(p).isSymbolicLink()) return null; } catch (e) { if (e.code !== 'ENOENT') return null; }
+    let state = {};
+    try { state = JSON.parse(fs.readFileSync(p, 'utf8')) || {}; } catch (e) {}
+    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;
+    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');
+  } catch (e) { return null; }
+}
+
+// ── Tier 2: elision ──────────────────────────────────────────────────────────
+// Keep head + tail; salvage error-looking lines from the elided middle so the
+// one line that mattered in a 3000-line build log survives the cut.
+function compress(text, limits) {
+  const { maxChars, headLines, tailLines } = limits;
+  const lines = text.split('\n');
+
+  if (lines.length <= headLines + tailLines) {
+    // Big in bytes, few lines (one giant line) — hard char cut.
+    const keep = Math.floor(maxChars / 2);
+    const elided = text.length - 2 * keep;
+    if (elided <= 0) return null;
+    return text.slice(0, keep) +
+      '\n... [chisle: elided ' + elided.toLocaleString('en-US') + ' chars from the middle] ...\n' +
+      text.slice(-keep);
+  }
+
+  const head = lines.slice(0, headLines);
+  const tail = lines.slice(-tailLines);
+  const middle = lines.slice(headLines, lines.length - tailLines);
+
+  const salvaged = [];
+  for (const line of middle) {
+    if (salvaged.length >= MAX_SALVAGED) break;
+    if (SALVAGE_RE.test(line)) salvaged.push(line.length > MAX_SALVAGE_LINE ? line.slice(0, MAX_SALVAGE_LINE) + '…' : line);
+  }
+
+  const marker = '... [chisle: elided ' + middle.length.toLocaleString('en-US') +
+    ' lines — kept first ' + headLines + ', last ' + tailLines +
+    (salvaged.length ? ', and ' + salvaged.length + ' error-like line(s) below' : '') + '] ...';
+
+  const out = head.concat([marker], salvaged, tail).join('\n');
+  return out.length < text.length ? out : null;
+}
+
+// Best-effort savings ledger. Races between parallel tool calls can drop a
+// count — stats only, never worth a lock file.
+function recordSavings(saved) {
+  try {
+    const p = path.join(getClaudeDir(), '.chisle-compress-stats.json');
+    try { if (fs.lstatSync(p).isSymbolicLink()) return; } catch (e) { if (e.code !== 'ENOENT') return; }
+    let stats = { savedChars: 0, events: 0 };
+    try {
+      const parsed = JSON.parse(fs.readFileSync(p, 'utf8'));
+      if (parsed && Number.isFinite(parsed.savedChars) && Number.isFinite(parsed.events)) stats = parsed;
+    } catch (e) {}
+    stats.savedChars += saved;
+    stats.events += 1;
+    const tmp = p + '.' + process.pid + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(stats), { mode: 0o600 });
+    fs.renameSync(tmp, p);
+  } catch (e) {}
+}
+
+// Scrub + elide on plain text → transformed text, or null if no meaningful
+// win. Stateless — this is what the replay benchmark measures.
+function transform(text, limits) {
+  if (!text || text.length <= SCRUB_MIN) return null;
+  let t = process.env.CHISLE_COMPRESS_SCRUB === '0' ? text : scrub(text);
+  if (t.length > limits.maxChars) {
+    const elided = compress(t, limits);
+    if (elided != null) t = elided;
+  }
+  return text.length - t.length >= MIN_WIN ? t : 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) {
+  if (!payload || typeof payload !== 'object') return null;
+  if (!mode || mode === 'off') return null;
+  if (process.env.CHISLE_COMPRESS === '0') return null;
+  if (!toolAllowed(payload.tool_name)) return null;
+
+  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);
+  if (dup != null && dup.length < text.length) return dup;
+  return transform(text, limitsFor(mode));
+}
+
+function main() {
+  let input = '';
+  process.stdin.on('data', chunk => { input += chunk; });
+  process.stdin.on('end', () => {
+    try {
+      const payload = JSON.parse(input.replace(/^/, ''));
+      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);
+      recordSavings(original.length - updated.length);
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PostToolUse',
+          updatedToolOutput: updated,
+        },
+      }));
+    } catch (e) {} // silent — never break the tool pipeline
+  });
+}
+
+if (require.main === module) main();
+
+module.exports = { extractText, scrub, compress, transform, limitsFor, toolAllowed, processPayload, THRESHOLDS, SAFE_TOOLS };

package/hooks/chisle-config.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+// chisle — shared configuration resolver
+//
+// 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'
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const VALID_MODES = ['off', 'lite', 'full', 'ultra'];
+
+function getClaudeDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+}
+
+function getConfigDir() {
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(process.env.XDG_CONFIG_HOME, 'chisle');
+  }
+  if (process.platform === 'win32') {
+    return path.join(
+      process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'),
+      'chisle'
+    );
+  }
+  return path.join(os.homedir(), '.config', 'chisle');
+}
+
+function readModeFromConfigFile(configPath) {
+  try {
+    const raw = fs.readFileSync(configPath, 'utf8');
+    const config = JSON.parse(raw);
+    if (config && config.defaultMode &&
+        VALID_MODES.includes(String(config.defaultMode).toLowerCase())) {
+      return String(config.defaultMode).toLowerCase();
+    }
+  } catch (e) {}
+  return null;
+}
+
+function getDefaultMode() {
+  const envMode = process.env.CHISLE_DEFAULT_MODE;
+  if (envMode && VALID_MODES.includes(envMode.toLowerCase())) {
+    return envMode.toLowerCase();
+  }
+  const userMode = readModeFromConfigFile(path.join(getConfigDir(), 'config.json'));
+  if (userMode) return userMode;
+  return 'full';
+}
+
+// Symlink-safe, atomic flag write with 0600 perms.
+// Defends against local attacker replacing predictable path with symlink to clobber other files.
+function safeWriteFlag(flagPath, content) {
+  const debug = process.env.CHISLE_DEBUG === '1';
+  try {
+    const flagDir = path.dirname(flagPath);
+    fs.mkdirSync(flagDir, { recursive: true });
+
+    let realFlagDir;
+    try {
+      const lstat = fs.lstatSync(flagDir);
+      if (lstat.isSymbolicLink()) {
+        realFlagDir = fs.realpathSync(flagDir);
+        const realStat = fs.statSync(realFlagDir);
+        if (!realStat.isDirectory()) {
+          if (debug) process.stderr.write(`[chisle] safeWriteFlag: symlink target not a directory\n`);
+          return;
+        }
+        if (typeof process.getuid === 'function') {
+          if (realStat.uid !== process.getuid()) {
+            if (debug) process.stderr.write(`[chisle] safeWriteFlag: symlink target owned by different uid\n`);
+            return;
+          }
+        } else {
+          const home = os.homedir();
+          const normalizedReal = path.resolve(realFlagDir).toLowerCase();
+          const normalizedHome = path.resolve(home).toLowerCase();
+          if (!normalizedReal.startsWith(normalizedHome + path.sep) &&
+              normalizedReal !== normalizedHome) {
+            if (debug) process.stderr.write(`[chisle] safeWriteFlag: symlink target outside home dir\n`);
+            return;
+          }
+        }
+      } else {
+        realFlagDir = flagDir;
+      }
+    } catch (e) {
+      return;
+    }
+
+    const realFlagPath = path.join(realFlagDir, path.basename(flagPath));
+    try {
+      if (fs.lstatSync(realFlagPath).isSymbolicLink()) return;
+    } catch (e) {
+      if (e.code !== 'ENOENT') return;
+    }
+
+    const tempPath = path.join(realFlagDir, `.chisle-active.${process.pid}.${Date.now()}`);
+    const O_NOFOLLOW = typeof fs.constants.O_NOFOLLOW === 'number' ? fs.constants.O_NOFOLLOW : 0;
+    const flags = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | O_NOFOLLOW;
+    let fd;
+    try {
+      fd = fs.openSync(tempPath, flags, 0o600);
+      fs.writeSync(fd, String(content));
+      try { fs.fchmodSync(fd, 0o600); } catch (e) {}
+    } finally {
+      if (fd !== undefined) fs.closeSync(fd);
+    }
+    fs.renameSync(tempPath, realFlagPath);
+  } catch (e) {}
+}
+
+// Symlink-safe, size-capped, whitelist-validated flag read.
+// Refuses symlinks, caps at 64 bytes, rejects unknown modes.
+const MAX_FLAG_BYTES = 64;
+
+function readFlag(flagPath) {
+  try {
+    let st;
+    try {
+      st = fs.lstatSync(flagPath);
+    } catch (e) {
+      return null;
+    }
+    if (st.isSymbolicLink() || !st.isFile()) return null;
+    if (st.size > MAX_FLAG_BYTES) return null;
+
+    const O_NOFOLLOW = typeof fs.constants.O_NOFOLLOW === 'number' ? fs.constants.O_NOFOLLOW : 0;
+    const flags = fs.constants.O_RDONLY | O_NOFOLLOW;
+    let fd;
+    let out;
+    try {
+      fd = fs.openSync(flagPath, flags);
+      const buf = Buffer.alloc(MAX_FLAG_BYTES);
+      const n = fs.readSync(fd, buf, 0, MAX_FLAG_BYTES, 0);
+      out = buf.slice(0, n).toString('utf8');
+    } finally {
+      if (fd !== undefined) fs.closeSync(fd);
+    }
+
+    const raw = out.trim().toLowerCase();
+    if (!VALID_MODES.includes(raw)) return null;
+    return raw;
+  } catch (e) {
+    return null;
+  }
+}
+
+module.exports = { getDefaultMode, getClaudeDir, VALID_MODES, safeWriteFlag, readFlag };

package/hooks/chisle-mode-tracker.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+// chisle — UserPromptSubmit hook
+// Handles /chisle commands, natural language activation/deactivation, and
+// per-turn reinforcement.
+
+const fs = require('fs');
+const path = require('path');
+const { getDefaultMode, getClaudeDir, VALID_MODES, safeWriteFlag, readFlag } = require('./chisle-config');
+
+const claudeDir = getClaudeDir();
+const flagPath = path.join(claudeDir, '.chisle-active');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input.replace(/^/, ''));
+    const prompt = (data.prompt || '').trim();
+    const promptLower = prompt.toLowerCase();
+
+    // 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)) {
+      try { fs.unlinkSync(flagPath); } catch (e) {}
+    }
+
+    // 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 + '). ' +
+            'Prose: drop articles/filler/pleasantries/hedging. Fragments OK. ' +
+            ladderHint + ' ' +
+            'Code/commits/security: write normal.'
+        }
+      }));
+    }
+  } catch (e) {
+    // Silent fail
+  }
+});