chisle 3.6.1 → 3.8.0

package/hooks/chisle-compress-output.js

@@ -55,7 +55,7 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const { getClaudeDir, getCopilotDir, getOpencodeDir, readFlag } = require('./chisle-config');
+const { getClaudeDir, getCopilotDir, getOpencodeStateDir, readFlag, getDefaultMode } = require('./chisle-config');
 
 // One threshold. Env overrides all.
 // These are the values the old 'full' level used — the default,
@@ -84,7 +84,10 @@ const SAFE_TOOLS_COPILOT = ['bash', 'powershell', 'grep', 'glob', 'web_fetch', '
 // NEVER_COMPRESS above — not merely absent from the allowlist.
 const NEVER_COMPRESS_COPILOT = ['view', 'create', 'edit', 'str_replace', 'insert'];
 
-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;
+// Letter/digit boundaries, not \b: `_` is a word char, so \b missed severities
+// inside codes like FATAL_MEMORY_PROBE / APP_ERROR_CODE (#38), and `err!` then
+// a space has no trailing \b at all.
+const SALVAGE_RE = /(?<![A-Za-z0-9])(?:err!|(?:error|fail(ed|ure|ing)?|exception|traceback|panic|fatal|denied|refused|timed?[ _-]?out|assert(ion)?|segfault|npe|undefined reference|cannot find|not found|warning)(?![A-Za-z0-9]))/i;
 const MAX_SALVAGED = 12;      // error lines rescued from the elided middle
 const MAX_SALVAGE_LINE = 300; // per-line char cap on salvaged lines
 
@@ -214,7 +217,7 @@ function compressForOpencode(toolName, text, opts) {
   if (process.env.CHISLE_COMPRESS === '0') return null;
   if (!opencodeToolAllowed(toolName)) return null;
   if (typeof text !== 'string' || !text) return null;
-  const stateDir = opts.stateDir || process.env.CHISLE_STATE_DIR || getOpencodeDir();
+  const stateDir = opts.stateDir || getOpencodeStateDir();
   const limits = limitsFor();
   const dup = dedupCheck(toolName, text, opts.sessionId, opts.callId, stateDir, true);
   if (dup != null && dup.length < text.length) return boundForOpencode(dup, null, limits.maxChars);
@@ -327,54 +330,96 @@ function duplicateMarker(toolName, text, reference = 'previous') {
 const DEDUP_SESSION_KEEP = 20;
 const DEDUP_DIR = 'chisle-dedup';
 
-function readDedupFile(p) {
+// `root` (the user-owned state root) may itself be a symlink (e.g. dotfiles
+// managed with GNU stow), so it is resolved with stat — but every subdirectory
+// beneath it and the target file are verified with lstat and must not be links.
+function secureDirectory(dir, root) {
+  try {
+    dir = path.resolve(dir);
+    root = root ? path.resolve(root) : dir;
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    let cur = dir;
+    while (cur !== root && cur.length > 1) {
+      const st = fs.lstatSync(cur);
+      if (!st.isDirectory() || st.isSymbolicLink()) return false;
+      const parent = path.dirname(cur);
+      if (parent === cur) break;
+      cur = parent;
+    }
+    const st = fs.statSync(root);
+    return st.isDirectory();
+  } catch (e) { return false; }
+}
+
+function safeReadText(p) {
   let st;
   try { st = fs.lstatSync(p); }
-  catch (e) { return { state: null, unsafe: e.code !== 'ENOENT' }; }
-  if (st.isSymbolicLink() || !st.isFile()) return { state: null, unsafe: true };
+  catch (e) { return { text: null, unsafe: e.code !== 'ENOENT' }; }
+  if (st.isSymbolicLink() || !st.isFile()) return { text: null, unsafe: true };
   const noFollow = typeof fs.constants.O_NOFOLLOW === 'number' ? fs.constants.O_NOFOLLOW : 0;
   let fd;
-  let raw;
   try {
     fd = fs.openSync(p, fs.constants.O_RDONLY | noFollow);
-    raw = fs.readFileSync(fd, 'utf8');
+    return { text: fs.readFileSync(fd, 'utf8'), unsafe: false };
   } catch (e) {
-    return { state: null, unsafe: true };
+    return { text: null, unsafe: true };
   } finally {
     if (fd !== undefined) { try { fs.closeSync(fd); } catch (e) {} }
   }
-  try { return { state: JSON.parse(raw) || null, unsafe: false }; }
-  catch (e) { return { state: null, unsafe: false }; }
 }
 
-function dedupStateDir(stateDir) {
-  const dir = path.join(stateDir || getClaudeDir(), DEDUP_DIR);
-  try { fs.mkdirSync(dir, { recursive: true, mode: 0o700 }); } catch (e) { return null; }
+function safeAtomicWrite(p, content, root) {
+  const dir = path.dirname(p);
+  if (!secureDirectory(dir, root)) return false;
   try {
-    const st = fs.lstatSync(dir);
-    return st.isDirectory() && !st.isSymbolicLink() ? dir : null;
-  } catch (e) { return null; }
-}
-
-function writeDedupState(p, state) {
+    const st = fs.lstatSync(p);
+    if (st.isSymbolicLink() || !st.isFile()) return false;
+  } catch (e) {
+    if (e.code !== 'ENOENT') return false;
+  }
   const tmp = p + '.' + process.pid + '.' + crypto.randomBytes(6).toString('hex') + '.tmp';
   const 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 | noFollow;
   let fd;
   try {
     fd = fs.openSync(tmp, flags, 0o600);
-    fs.writeFileSync(fd, JSON.stringify(state));
+    fs.writeFileSync(fd, content);
     try { fs.fchmodSync(fd, 0o600); } catch (e) {}
     fs.closeSync(fd);
     fd = undefined;
+    try {
+      const st = fs.lstatSync(p);
+      if (st.isSymbolicLink() || !st.isFile()) return false;
+    } catch (e) {
+      if (e.code !== 'ENOENT') return false;
+    }
     fs.renameSync(tmp, p);
+    return true;
   } catch (e) {
-    if (fd !== undefined) { try { fs.closeSync(fd); } catch (closeError) {} }
-    try { fs.unlinkSync(tmp); } catch (unlinkError) {}
-    throw e;
+    return false;
+  } finally {
+    if (fd !== undefined) { try { fs.closeSync(fd); } catch (e) {} }
+    try { fs.unlinkSync(tmp); } catch (e) {}
   }
 }
 
+function readDedupFile(p) {
+  const { text, unsafe } = safeReadText(p);
+  if (text == null) return { state: null, unsafe };
+  try { return { state: JSON.parse(text) || null, unsafe: false }; }
+  catch (e) { return { state: null, unsafe: false }; }
+}
+
+function dedupStateDir(stateDir) {
+  const root = stateDir || getClaudeDir();
+  const dir = path.join(root, DEDUP_DIR);
+  return secureDirectory(dir, root) ? dir : null;
+}
+
+function writeDedupState(p, state, root) {
+  if (!safeAtomicWrite(p, JSON.stringify(state), root)) throw new Error('unsafe dedup state path');
+}
+
 function pruneDedupSessions(dir) {
   try {
     const files = fs.readdirSync(dir)
@@ -394,7 +439,7 @@ function pruneDedupSessions(dir) {
 
 // `stateDir` defaults to getClaudeDir() so existing Claude/Pi callers keep
 // their prior storage path. Copilot passes getCopilotDir(); OpenCode passes
-// getOpencodeDir() and opts into per-session files for interleaved sessions.
+// getOpencodeStateDir() and opts into per-session files for interleaved sessions.
 function dedupCheck(toolName, text, sessionId, toolUseId, stateDir, perSession) {
   if (process.env.CHISLE_COMPRESS_DEDUP === '0') return null;
   if (!sessionId || typeof sessionId !== 'string') return null;
@@ -430,7 +475,7 @@ function dedupCheck(toolName, text, sessionId, toolUseId, stateDir, perSession)
     const dup = rec.hash === hash && !sameCall;
     state.tools[toolName] = { hash, id: toolUseId || rec.id || null };
     if (perSession) {
-      writeDedupState(p, state);
+      writeDedupState(p, state, stateDir || getClaudeDir());
       pruneDedupSessions(dir);
     } else {
       fs.mkdirSync(dir, { recursive: true });
@@ -466,7 +511,12 @@ function pruneSpill(dir) {
   try {
     const files = fs.readdirSync(dir)
       .filter(f => f.endsWith('.txt'))
-      .map(f => { const p = path.join(dir, f); return { p, t: fs.statSync(p).mtimeMs }; })
+      .map(f => {
+        const p = path.join(dir, f);
+        const st = fs.lstatSync(p);
+        return st.isFile() && !st.isSymbolicLink() ? { p, t: st.mtimeMs } : null;
+      })
+      .filter(Boolean)
       .sort((a, b) => b.t - a.t);
     for (const f of files.slice(SPILL_KEEP)) { try { fs.unlinkSync(f.p); } catch (e) {} }
   } catch (e) {}
@@ -475,12 +525,18 @@ function pruneSpill(dir) {
 function spill(text, toolName, stateDir) {
   if (process.env.CHISLE_COMPRESS_SPILL === '0') return null;
   try {
+    const root = stateDir || getClaudeDir();
     const dir = spillDir(stateDir);
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    if (!secureDirectory(dir, root)) return null;
     const hash = crypto.createHash('sha256').update(text).digest('hex').slice(0, 12);
     const safeTool = String(toolName || 'tool').replace(/[^A-Za-z0-9_-]/g, '') || 'tool';
     const file = path.join(dir, `${safeTool}-${hash}.txt`);
-    if (!fs.existsSync(file)) fs.writeFileSync(file, text, { mode: 0o600 });
+    // Same hash → same content (atomic writes never leave a partial file), so
+    // an existing regular file is reused. Re-reading to compare would also
+    // fail on lone surrogates, which UTF-8 cannot round-trip.
+    let st = null;
+    try { st = fs.lstatSync(file); } catch (e) { if (e.code !== 'ENOENT') return null; }
+    if (st ? st.isSymbolicLink() || !st.isFile() : !safeAtomicWrite(file, text, root)) return null;
     pruneSpill(dir);
     return file;
   } catch (e) { return null; }
@@ -525,20 +581,19 @@ function compress(text, limits, spillPath) {
 // count — stats only, never worth a lock file.
 function recordSavings(saved, stateDir) {
   try {
-    const dir = stateDir || getClaudeDir();
-    const p = path.join(dir, '.chisle-compress-stats.json');
-    try { if (fs.lstatSync(p).isSymbolicLink()) return; } catch (e) { if (e.code !== 'ENOENT') return; }
+    const root = stateDir || getClaudeDir();
+    if (!secureDirectory(root, root)) return;
+    const p = path.join(root, '.chisle-compress-stats.json');
+    const current = safeReadText(p);
+    if (current.unsafe) return;
     let stats = { savedChars: 0, events: 0 };
     try {
-      const parsed = JSON.parse(fs.readFileSync(p, 'utf8'));
+      const parsed = JSON.parse(current.text);
       if (parsed && Number.isFinite(parsed.savedChars) && Number.isFinite(parsed.events)) stats = parsed;
     } catch (e) {}
     stats.savedChars += saved;
     stats.events += 1;
-    fs.mkdirSync(dir, { recursive: true });
-    const tmp = p + '.' + process.pid + '.tmp';
-    fs.writeFileSync(tmp, JSON.stringify(stats), { mode: 0o600 });
-    fs.renameSync(tmp, p);
+    safeAtomicWrite(p, JSON.stringify(stats), root);
   } catch (e) {}
 }
 
@@ -627,9 +682,10 @@ function main() {
 
       // Copilot has no /chisle mode-toggle mechanism (no UserPromptSubmit
       // hook wired for it yet, so there is nothing to flip a flag file with):
-      // treat it as always-on, matching the always-on ruleset it already
-      // gets. Claude/Pi keep reading the real flag file exactly as before.
-      const mode = copilot ? 'on' : readFlag(path.join(getClaudeDir(), '.chisle-active'));
+      // it follows the default mode (CHISLE_DEFAULT_MODE or the shared
+      // config, 'on' when unset), like OpenCode. Claude/Pi keep reading the
+      // real flag file exactly as before.
+      const mode = copilot ? getDefaultMode() : readFlag(path.join(getClaudeDir(), '.chisle-active'));
 
       const updated = processPayload(payload, mode);
       if (updated == null) return;

package/hooks/chisle-config.js

@@ -41,11 +41,18 @@ function getClaudeDir() {
 // OpenCode's global config dir. The compressor plugin keeps its spill/dedup/
 // stats here (as Copilot uses getCopilotDir), so recovery files sit beside
 // OpenCode's own config instead of leaking into ~/.claude.
-function getOpencodeDir() {
-  if (process.env.XDG_CONFIG_HOME) {
-    return path.join(process.env.XDG_CONFIG_HOME, 'opencode');
-  }
-  return path.join(os.homedir(), '.config', 'opencode');
+function getOpencodeDir(opts) {
+  const options = opts || {};
+  const env = options.env || process.env;
+  const home = options.home || os.homedir();
+  if (env.OPENCODE_CONFIG_DIR) return env.OPENCODE_CONFIG_DIR;
+  if (env.XDG_CONFIG_HOME) return path.join(env.XDG_CONFIG_HOME, 'opencode');
+  return path.join(home, '.config', 'opencode');
+}
+
+function getOpencodeStateDir(opts) {
+  const env = (opts && opts.env) || process.env;
+  return env.CHISLE_STATE_DIR || getOpencodeDir(opts);
 }
 
 // GitHub Copilot CLI's own user-level state directory (mirrors the
@@ -350,7 +357,7 @@ function readFlag(flagPath) {
 }
 
 module.exports = {
-  LEGACY_MODES, legacySetting, getDefaultMode, getClaudeDir, getCopilotDir, getOpencodeDir,
+  LEGACY_MODES, legacySetting, getDefaultMode, getClaudeDir, getCopilotDir, getOpencodeDir, getOpencodeStateDir, getConfigDir,
   VALID_MODES, safeWriteFlag, readFlag,
   PROSE_HEADINGS, CODE_HEADINGS, getSections, filterSections,
   getActiveOutputStyle, explicitSections, resolveSections,

package/hooks/chisle-mcp-proxy.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+// chisle — stdio MCP proxy: tool-output compression for any MCP host.
+//
+// Most agents cannot rewrite a tool result from a hook (Windsurf, Cline,
+// Kiro, Gemini, Qwen; Cursor only for MCP), but every one of them launches
+// stdio MCP servers from a command line it does not inspect. Wrapping that
+// command puts Chisle between host and server:
+//
+//   node chisle-mcp-proxy.js -- <original command> [args...]
+//
+// Bytes pass through untouched in both directions, except the JSON-RPC
+// response to a `tools/call` request: its `content[]` text blocks go through
+// the same scrub + elide core as every other harness (head/tail kept, error
+// lines salvaged, full original spilled to disk). Everything else — init,
+// tools/list, notifications, resources, malformed lines — is forwarded
+// byte-identical. `npx chisle mcp wrap` rewrites host configs to use it.
+//
+// Deliberately absent:
+//   - dedup markers: one server process can outlive a chat and serve the
+//     next one, whose context never saw the earlier copy.
+//   - read/edit-shaped tools (read_file, get_file_contents, edit_file, ...):
+//     their output feeds exact-match edits. Skipped by name.
+//   - structuredContent: left as-is; hosts that forward it get it unchanged.
+//
+// Never breaks the server: any compressor error forwards the original line.
+// Tunables: CHISLE_COMPRESS=0, CHISLE_DEFAULT_MODE=off, CHISLE_COMPRESS_MAX_CHARS
+// (+ HEAD/TAIL_LINES), CHISLE_COMPRESS_SPILL=0, CHISLE_STATE_DIR (spill + stats,
+// default ~/.config/chisle).
+
+'use strict';
+
+const cp = require('child_process');
+const { StringDecoder } = require('string_decoder');
+const core = require('./chisle-compress-output');
+const { getDefaultMode, getConfigDir } = require('./chisle-config');
+
+const IS_WIN = process.platform === 'win32';
+
+// Tool names whose output may feed a later exact-match edit, or is file
+// content the model quotes back. Matched on the raw MCP tool name.
+const UNSAFE_MCP_RE = /read|view|file|edit|write|patch|replace|insert/i;
+const MAX_PENDING_LINE = 16 * 1024 * 1024; // drop observation of absurd lines
+
+function mcpToolAllowed(name) {
+  return typeof name === 'string' && !!name && !UNSAFE_MCP_RE.test(name);
+}
+
+function stateDir() {
+  return process.env.CHISLE_STATE_DIR || getConfigDir();
+}
+
+// Compress one tools/call result in place. Returns chars saved (0 = untouched).
+function compressResult(result, toolName) {
+  if (!result || !Array.isArray(result.content)) return 0;
+  const limits = core.limitsFor();
+  let saved = 0;
+  for (const block of result.content) {
+    if (!block || block.type !== 'text' || typeof block.text !== 'string') continue;
+    if (block.text.includes('[chisle:')) continue; // already compressed upstream
+    const updated = core.transform(block.text, limits, 'mcp-' + toolName, stateDir());
+    if (updated != null && updated.length < block.text.length) {
+      saved += block.text.length - updated.length;
+      block.text = updated;
+    }
+  }
+  return saved;
+}
+
+// One server→host line. Returns the line to forward (original when untouched).
+function rewriteLine(line, pending) {
+  if (!pending.size || line.indexOf('"result"') === -1) return line;
+  let msg;
+  try { msg = JSON.parse(line); } catch (e) { return line; }
+  const msgs = Array.isArray(msg) ? msg : [msg];
+  let saved = 0;
+  for (const m of msgs) {
+    if (!m || m.id == null || !('result' in m)) continue;
+    const key = JSON.stringify(m.id);
+    const tool = pending.get(key);
+    if (tool === undefined) continue;
+    pending.delete(key);
+    if (!mcpToolAllowed(tool)) continue;
+    saved += compressResult(m.result, tool);
+  }
+  if (!saved) return line;
+  core.recordSavings(saved, stateDir());
+  return JSON.stringify(msg);
+}
+
+// One host→server line: remember which request ids are tool calls.
+function observeRequest(line, pending) {
+  if (line.indexOf('tools/call') === -1 && line.indexOf('notifications/cancelled') === -1) return;
+  let msg;
+  try { msg = JSON.parse(line); } catch (e) { return; }
+  for (const m of Array.isArray(msg) ? msg : [msg]) {
+    if (m && m.method === 'tools/call' && m.id != null) {
+      pending.set(JSON.stringify(m.id), m.params && typeof m.params.name === 'string' ? m.params.name : '');
+    }
+    // A cancelled call never gets a result; forget it.
+    if (m && m.method === 'notifications/cancelled' && m.params && m.params.requestId != null) {
+      pending.delete(JSON.stringify(m.params.requestId));
+    }
+  }
+}
+
+// Splits a byte stream into lines, calling onLine(lineWithoutNewline, eol).
+function lineSplitter(onLine) {
+  let buf = '';
+  return {
+    push(chunk) {
+      buf += chunk;
+      let i;
+      while ((i = buf.indexOf('\n')) !== -1) {
+        const raw = buf.slice(0, i);
+        buf = buf.slice(i + 1);
+        const cr = raw.endsWith('\r');
+        onLine(cr ? raw.slice(0, -1) : raw, cr ? '\r\n' : '\n');
+      }
+    },
+    rest() { const r = buf; buf = ''; return r; },
+    get size() { return buf.length; },
+  };
+}
+
+function quoteWin(a) {
+  if (a === '' || /[\s"&|<>^()%!]/.test(a)) return '"' + String(a).replace(/\\(?=\\*"|$)/g, '\\\\').replace(/"/g, '\\"') + '"';
+  return a;
+}
+
+function main(argv) {
+  const sep = argv.indexOf('--');
+  const cmd = sep === -1 ? argv : argv.slice(sep + 1);
+  if (!cmd.length) {
+    process.stderr.write('usage: chisle-mcp-proxy -- <command> [args...]\n');
+    process.exit(2);
+  }
+
+  // Windows MCP commands are usually npx/uvx shims (.cmd), which Node refuses
+  // to spawn without a shell; elsewhere spawn directly, no shell parsing.
+  const child = IS_WIN
+    ? cp.spawn(cmd.map(quoteWin).join(' '), [], { stdio: ['pipe', 'pipe', 'inherit'], shell: true, windowsHide: true })
+    : cp.spawn(cmd[0], cmd.slice(1), { stdio: ['pipe', 'pipe', 'inherit'] });
+
+  const enabled = process.env.CHISLE_COMPRESS !== '0' && getDefaultMode() !== 'off';
+  const pending = new Map();
+
+  child.on('error', (e) => {
+    process.stderr.write('chisle-mcp-proxy: cannot start ' + cmd[0] + ': ' + e.message + '\n');
+    process.exit(127);
+  });
+  child.stdin.on('error', () => {}); // server gone; exit handler reports it
+  process.stdout.on('error', () => { try { child.kill(); } catch (e) {} process.exit(0); }); // host gone
+
+  // Host → server: forward raw, observe tool calls on the side.
+  const reqLines = lineSplitter(line => observeRequest(line, pending));
+  const decoder = new StringDecoder('utf8');
+  process.stdin.on('data', (chunk) => {
+    child.stdin.write(chunk);
+    if (!enabled) return;
+    reqLines.push(decoder.write(chunk));
+    if (reqLines.size > MAX_PENDING_LINE) reqLines.rest();
+  });
+  process.stdin.on('end', () => child.stdin.end());
+
+  // Server → host: rewrite only tool-call responses. Paused while the host is
+  // slow to read so a chatty server cannot balloon this process.
+  if (!enabled) {
+    child.stdout.pipe(process.stdout);
+  } else {
+    const resLines = lineSplitter((line, eol) => {
+      let out = line;
+      try { out = rewriteLine(line, pending); } catch (e) { out = line; }
+      if (!process.stdout.write(out + eol)) {
+        child.stdout.pause();
+        process.stdout.once('drain', () => child.stdout.resume());
+      }
+    });
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', chunk => resLines.push(chunk));
+    child.stdout.on('end', () => { const r = resLines.rest(); if (r) process.stdout.write(r); });
+  }
+
+  for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+    process.on(sig, () => { try { child.kill(sig); } catch (e) {} });
+  }
+
+  child.on('close', (code, signal) => {
+    const status = code != null ? code : (signal ? 128 + (require('os').constants.signals[signal] || 1) : 1);
+    process.stdout.write('', () => process.exit(status));
+  });
+}
+
+if (require.main === module) main(process.argv.slice(2));
+
+module.exports = { mcpToolAllowed, compressResult, rewriteLine, observeRequest, lineSplitter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "3.6.1",
+  "version": "3.8.0",
   "description": "Maximum-efficiency dev mode for AI coding agents. Zero-fluff prose, YAGNI-first code, and safe tool-output compression.",
   "keywords": [
     "claude-code",
@@ -17,6 +17,7 @@
     "cursor",
     "codex",
     "copilot",
+    "antigravity",
     "opencode",
     "hermes-agent",
     "hermes",
@@ -93,11 +94,13 @@
     ".windsurf/",
     ".clinerules/",
     ".kiro/",
+    ".agents/",
     ".github/copilot-instructions.md",
     ".claude-plugin/",
     ".opencode/",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "NOTICE"
   ],
   "publishConfig": {
     "access": "public",

package/skills/chisle/SKILL.md

@@ -44,7 +44,7 @@ Ladder runs after understanding the problem, never instead. Bug fix = root cause
 
 ## Thinking Is Billed Too
 
-Reasoning costs the same as output. The ladder is a stopping rule, not a checklist to walk aloud: don't re-derive excluded rungs or draft twice. Obvious fix → give it. Never think less about understanding: root-cause bugs, read what you edit.
+Reasoning costs the same as output. Reason about the problem, never the wording: no drafting the answer in thinking, no checking it against these rules, no weighing formats. Obvious answer → write it straight away. Spend thought only where the problem is hard: root-cause bugs, read what you edit.
 
 ## Code Rules