chisle 3.3.0 → 3.5.0

package/hooks/chisle-compress-output.js

@@ -5,8 +5,20 @@
 // 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.
+// replaces what the model sees. Deterministic, zero LLM, zero network. Small
+// outputs pass through untouched.
+//
+// Two harnesses call into this same core:
+//   - Claude Code / Pi: `updatedToolOutput`, snake_case payload
+//     (tool_name, tool_response, session_id, tool_use_id), gated behind the
+//     /chisle on/off flag file (see chisle-config.js: getDefaultMode/readFlag).
+//   - GitHub Copilot CLI: `modifiedResult.textResultForLlm`, camelCase flat
+//     payload (toolName, toolResult.textResultForLlm, sessionId). Copilot has
+//     no /chisle-equivalent mode toggle (no UserPromptSubmit-driven flag), so
+//     compression is always-on for Copilot once the hook is installed —
+//     exactly like the static ruleset Copilot already gets unconditionally
+//     (see README: "the always-on ruleset still ships to every other agent").
+//     CHISLE_COMPRESS=0 is still honored as the one kill switch for both.
 //
 // Correctness guardrails (why this never touches Read/Edit/Write):
 //   - Read output feeds later Edit old_string matching — eliding it makes the
@@ -23,24 +35,27 @@
 // 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 follows the /chisle flag (off → untouched). Tunables via env:
+// Compression follows the /chisle flag for Claude/Pi (off → untouched); it is
+// unconditional for Copilot (see above). Tunables via env, shared across all
+// three harnesses:
 //   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
+//   CHISLE_COMPRESS_TOOLS=Bash,Grep   — override the tool allowlist (both harnesses)
 //   CHISLE_COMPRESS_SPILL=0           — elide without writing the recovery copy
 //
-// Savings accrue in <claudeDir>/.chisle-compress-stats.json for the statusline.
-// Elided originals spill to <claudeDir>/chisle-spill/ so the dropped middle can
+// Savings accrue in <stateDir>/.chisle-compress-stats.json for the statusline
+// (Claude/Pi: <claudeDir>; Copilot: <copilotDir>, see chisle-config.js).
+// Elided originals spill to <stateDir>/chisle-spill/ so the dropped middle can
 // be grepped back instead of re-running the command; the newest 40 are kept.
 
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const { getClaudeDir, readFlag } = require('./chisle-config');
+const { getClaudeDir, getCopilotDir, getOpencodeDir, readFlag } = require('./chisle-config');
 
 // One threshold. Env overrides all.
 // These are the values the old 'full' level used — the default,
@@ -50,18 +65,105 @@ 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.
 const SAFE_TOOLS = ['Bash', 'Agent', 'WebFetch', 'WebSearch', 'Grep', 'Glob'];
+
+// The correctness invariant, enforced rather than merely defaulted: these tools'
+// output feeds later exact-match edits, so eliding it makes the model edit text
+// it never saw. CHISLE_COMPRESS_TOOLS is an override for the *allowlist*, not a
+// way to switch this off — the Pi extension (NEVER_COMPRESS) and the OpenCode
+// path (UNSAFE_TOOLS_OPENCODE) have always checked it first, and this is the
+// same guard for the Claude/Pi hook payloads.
+const NEVER_COMPRESS = ['read', 'edit', 'write', 'multiedit', 'notebookedit', 'notebookread'];
+
+// Copilot CLI's own runtime tool names (lowercase, no mcp__ prefix scheme).
+// Same allowlist rule as SAFE_TOOLS: Copilot's Read/Edit/Write equivalents
+// are `view`/`create`/`edit` and are deliberately absent here too. Verified
+// against Copilot CLI's real tool set, not guessed — see the accompanying PR
+// description for the live-verification evidence (Beyin chisle-port project).
+const SAFE_TOOLS_COPILOT = ['bash', 'powershell', 'grep', 'glob', 'web_fetch', 'web_search', 'task'];
+// Copilot's Read/Edit/Write family, hard-blocked for the same reason as
+// 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;
 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;
+  if (NEVER_COMPRESS.includes(name.toLowerCase())) 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__'));
 }
 
+// Same override semantics as toolAllowed, against Copilot's tool-name scheme.
+function copilotToolAllowed(name) {
+  if (!name || typeof name !== 'string') return false;
+  if (NEVER_COMPRESS_COPILOT.includes(name.toLowerCase())) return false;
+  const list = process.env.CHISLE_COMPRESS_TOOLS
+    ? process.env.CHISLE_COMPRESS_TOOLS.split(',').map(s => s.trim()).filter(Boolean)
+    : SAFE_TOOLS_COPILOT;
+  return list.includes(name);
+}
+
+// OpenCode runtime tool names are lowercase (bash, grep, glob, webfetch, ...)
+// and MCP tools are `server_tool` (an underscore), not Claude's mcp__ prefix.
+// read/edit/write/patch are excluded on purpose: their output feeds exact-match
+// edits, exactly as SAFE_TOOLS omits Read/Edit/Write.
+const SAFE_TOOLS_OPENCODE = ['bash', 'grep', 'glob', 'webfetch', 'websearch', 'task', 'list'];
+const UNSAFE_TOOLS_OPENCODE = ['read', 'edit', 'write', 'patch', 'todowrite', 'todoread'];
+
+function opencodeToolAllowed(name) {
+  if (!name || typeof name !== 'string') return false;
+  const lower = name.toLowerCase();
+  // read/edit/write/patch are never compressed, even via CHISLE_COMPRESS_TOOLS:
+  // their output feeds exact-match edits (the invariant INSTALL.md promises).
+  if (UNSAFE_TOOLS_OPENCODE.includes(lower)) return false;
+  if (process.env.CHISLE_COMPRESS_TOOLS) {
+    return process.env.CHISLE_COMPRESS_TOOLS
+      .split(',').map(s => s.trim()).filter(Boolean).includes(name);
+  }
+  if (SAFE_TOOLS_OPENCODE.includes(lower)) return true;
+  // Heuristic: underscore = MCP `server_tool`, treated as read-only info tool
+  // like SAFE_TOOLS' mcp__ clause. Set CHISLE_COMPRESS_TOOLS to override if a
+  // custom underscore-named tool ever needs protecting.
+  return name.includes('_');
+}
+
+// One OpenCode tool_result → replacement string, or null to keep the original.
+// The plugin passes output.output (already a plain string), so no extractText/
+// rebuild dance is needed — just gate on mode/kill-switch/allowlist and reuse
+// the shared scrub+elide core. stateDir keeps spill/recovery beside OpenCode's
+// config (CHISLE_STATE_DIR overrides, used by tests).
+//
+// Fires for the common case: outputs under OpenCode's own on-disk store limits
+// (~50 KB / 2000 lines) arrive here FULL, both in tool.execute.after (whose
+// mutation persists to the tool part's state.output) and again, request-time,
+// in experimental.chat.messages.transform. Larger outputs arrive as OpenCode's
+// notice plus a retained tail; the tail still compresses here.
+function compressForOpencode(toolName, text, opts) {
+  opts = opts || {};
+  if (opts.mode === 'off') return null;
+  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();
+  return transform(text, limitsFor(), toolName, stateDir);
+}
+
+// Copilot CLI's postToolUse payload is flat and camelCase:
+//   { sessionId, timestamp, cwd, toolName, toolArgs,
+//     toolResult: { resultType: "success", textResultForLlm: string } }
+// Detected structurally (no explicit "harness" field exists on either
+// payload shape), by the presence of toolResult.textResultForLlm together
+// with the camelCase toolName — Claude/Pi payloads use tool_name/tool_response
+// and never carry this shape.
+function isCopilotPayload(payload) {
+  return !!(payload && typeof payload.toolName === 'string' &&
+    payload.toolResult && typeof payload.toolResult.textResultForLlm === 'string');
+}
+
 function envInt(name, fallback) {
   const n = parseInt(process.env[name], 10);
   return Number.isFinite(n) && n > 0 ? n : fallback;
@@ -77,6 +179,7 @@ function limitsFor() {
 }
 
 // Pull a plain-text payload out of tool_response, whatever its shape.
+// Also handles Copilot's already-flat textResultForLlm string unchanged.
 function extractText(response) {
   if (response == null) return null;
   if (typeof response === 'string') return response;
@@ -143,12 +246,16 @@ function duplicateMarker(toolName, text, reference = 'previous') {
     ' lines, unchanged. First lines:]\n' + preview.join('\n');
 }
 
-function dedupCheck(toolName, text, sessionId, toolUseId) {
+// `stateDir` defaults to getClaudeDir() so every existing Claude/Pi call site
+// and test (none of which pass a third argument) keeps its exact prior
+// behaviour. Copilot's caller (processPayload, below) passes getCopilotDir().
+function dedupCheck(toolName, text, sessionId, toolUseId, stateDir) {
   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');
+    const dir = stateDir || getClaudeDir();
+    const p = path.join(dir, '.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) {}
@@ -167,6 +274,7 @@ function dedupCheck(toolName, text, sessionId, toolUseId) {
     const sameCall = !!(toolUseId && rec.id && rec.id === toolUseId);
     const dup = rec.hash === hash && !sameCall;
     state.tools[toolName] = { hash, id: toolUseId || rec.id || null };
+    fs.mkdirSync(dir, { recursive: true });
     const tmp = p + '.' + process.pid + '.tmp';
     fs.writeFileSync(tmp, JSON.stringify(state), { mode: 0o600 });
     fs.renameSync(tmp, p);
@@ -188,8 +296,8 @@ function dedupCheck(toolName, text, sessionId, toolUseId) {
 const SPILL_DIR = 'chisle-spill';
 const SPILL_KEEP = 40;
 
-function spillDir() {
-  return path.join(getClaudeDir(), SPILL_DIR);
+function spillDir(stateDir) {
+  return path.join(stateDir || getClaudeDir(), SPILL_DIR);
 }
 
 // Keep the directory bounded. Oldest-first by mtime; cheap enough at this size
@@ -204,10 +312,10 @@ function pruneSpill(dir) {
   } catch (e) {}
 }
 
-function spill(text, toolName) {
+function spill(text, toolName, stateDir) {
   if (process.env.CHISLE_COMPRESS_SPILL === '0') return null;
   try {
-    const dir = spillDir();
+    const dir = spillDir(stateDir);
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     const hash = crypto.createHash('sha256').update(text).digest('hex').slice(0, 12);
     const safeTool = String(toolName || 'tool').replace(/[^A-Za-z0-9_-]/g, '') || 'tool';
@@ -254,9 +362,10 @@ function compress(text, limits, spillPath) {
 
 // Best-effort savings ledger. Races between parallel tool calls can drop a
 // count — stats only, never worth a lock file.
-function recordSavings(saved) {
+function recordSavings(saved, stateDir) {
   try {
-    const p = path.join(getClaudeDir(), '.chisle-compress-stats.json');
+    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; }
     let stats = { savedChars: 0, events: 0 };
     try {
@@ -265,6 +374,7 @@ function recordSavings(saved) {
     } 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);
@@ -272,12 +382,13 @@ function recordSavings(saved) {
 }
 
 // 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, toolName) {
+// win. Stateless (aside from the spill side-effect) — this is what the
+// replay benchmark measures for Claude/Pi.
+function transform(text, limits, toolName, stateDir) {
   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, toolName ? spill(t, toolName) : null);
+    const elided = compress(t, limits, toolName ? spill(t, toolName, stateDir) : null);
     if (elided != null) t = elided;
   }
   return text.length - t.length >= MIN_WIN ? t : null;
@@ -291,6 +402,10 @@ function transform(text, limits, toolName) {
 // 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).
+//
+// Not used for Copilot: its toolResult.textResultForLlm is already a flat
+// string, so main() builds { modifiedResult: { textResultForLlm } } directly
+// and never calls this function for a Copilot-shaped payload.
 function rebuildResponse(response, updated) {
   if (response == null || typeof response === 'string') return updated;
   if (typeof response === 'object' && !Array.isArray(response)) {
@@ -310,18 +425,35 @@ function rebuildResponse(response, updated) {
 }
 
 // Full pipeline on one hook payload → updated output string, or null to keep
-// the original. Pure given (payload, mode, env) except dedup state.
+// the original. Pure given (payload, mode, env) except dedup/spill/stats state.
+//
+// `mode` keeps meaning "off disables everything" for Claude/Pi, exactly as
+// before. For a Copilot-shaped payload the caller (main()) always passes
+// 'on' — Copilot has no /chisle toggle to read a flag file for — so this
+// function's Copilot branch below never actually sees 'off' in practice, but
+// still honors it if a future caller passes it explicitly.
 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;
 
+  if (isCopilotPayload(payload)) {
+    const toolName = payload.toolName;
+    if (!copilotToolAllowed(toolName)) return null;
+    const text = payload.toolResult.textResultForLlm;
+    if (!text) return null;
+    const stateDir = getCopilotDir();
+    const dup = dedupCheck(toolName, text, payload.sessionId, null, stateDir);
+    if (dup != null && dup.length < text.length) return dup;
+    return transform(text, limitsFor(), toolName, stateDir);
+  }
+
+  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, payload.tool_use_id);
+  const dup = dedupCheck(payload.tool_name, text, payload.session_id, payload.tool_use_id, getClaudeDir());
   if (dup != null && dup.length < text.length) return dup;
-  return transform(text, limitsFor(), payload.tool_name);
+  return transform(text, limitsFor(), payload.tool_name, getClaudeDir());
 }
 
 function main() {
@@ -330,9 +462,30 @@ function main() {
   process.stdin.on('end', () => {
     try {
       const payload = JSON.parse(input.replace(/^/, ''));
-      const mode = readFlag(path.join(getClaudeDir(), '.chisle-active'));
+      const copilot = isCopilotPayload(payload);
+
+      // 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'));
+
       const updated = processPayload(payload, mode);
       if (updated == null) return;
+
+      if (copilot) {
+        const original = payload.toolResult.textResultForLlm;
+        recordSavings(original.length - updated.length, getCopilotDir());
+        // Echo back the result type we were handed. Hard-coding 'success'
+        // would relabel a failed tool call as a successful one on its way to
+        // the model — the compressor only ever rewrites text, never status.
+        const resultType = payload.toolResult.resultType || 'success';
+        process.stdout.write(JSON.stringify({
+          modifiedResult: { resultType, textResultForLlm: updated },
+        }));
+        return;
+      }
+
       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.
@@ -340,7 +493,7 @@ function main() {
       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);
+      recordSavings(original.length - updated.length, getClaudeDir());
       process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
           hookEventName: 'PostToolUse',
@@ -353,4 +506,12 @@ function main() {
 
 if (require.main === module) main();
 
-module.exports = { extractText, rebuildResponse, scrub, compress, transform, limitsFor, toolAllowed, processPayload, duplicateMarker, THRESHOLDS, SAFE_TOOLS };
+module.exports = {
+  extractText, rebuildResponse, scrub, compress, transform, limitsFor, toolAllowed, processPayload,
+  duplicateMarker, THRESHOLDS, SAFE_TOOLS, NEVER_COMPRESS,
+  // Copilot-specific additions (see PR description for rationale):
+  isCopilotPayload, copilotToolAllowed, SAFE_TOOLS_COPILOT, NEVER_COMPRESS_COPILOT,
+  // OpenCode-specific additions (plugin uses tool.execute.after +
+  // experimental.chat.messages.transform):
+  opencodeToolAllowed, compressForOpencode, SAFE_TOOLS_OPENCODE,
+};

package/hooks/chisle-config.js

@@ -38,6 +38,25 @@ function getClaudeDir() {
   return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
 }
 
+// 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');
+}
+
+// GitHub Copilot CLI's own user-level state directory (mirrors the
+// CLAUDE_CONFIG_DIR precedent above). Copilot CLI already reads/writes hook
+// config under this same directory (~/.copilot/hooks/), so chisle's
+// dedup/spill/stats state lives alongside it rather than under ~/.claude,
+// which would be misleading for a machine that never runs Claude Code.
+function getCopilotDir() {
+  return process.env.COPILOT_HOME || path.join(os.homedir(), '.copilot');
+}
+
 function getConfigDir() {
   if (process.env.XDG_CONFIG_HOME) {
     return path.join(process.env.XDG_CONFIG_HOME, 'chisle');
@@ -73,6 +92,166 @@ function getDefaultMode() {
   return 'on';
 }
 
+// ── Section suppression ─────────────────────────────────────────────────────
+// Optional config key letting a user drop Chisle's prose rules or code rules
+// independently, while keeping the other. Config file only — no env override,
+// unlike defaultMode. Absent, malformed, or non-boolean always falls back to
+// enabled (true); never throws.
+//   { "sections": { "prose": false } }   // suppress prose rules, keep code
+
+// Headings from skills/chisle/SKILL.md, grouped by section.
+const PROSE_HEADINGS = [
+  'Prose: Maximum Signal Per Token',
+  'Output Format',
+  'What it sounds like',
+];
+const CODE_HEADINGS = [
+  'Code: The Efficiency Ladder',
+  'Code Rules',
+  'Context Diet: Read Less Into the Window',
+];
+
+function readSectionsFromConfigFile(configPath) {
+  try {
+    const raw = fs.readFileSync(configPath, 'utf8');
+    const config = JSON.parse(raw);
+    const s = config && typeof config === 'object' ? config.sections : null;
+    return {
+      prose: !!(s && typeof s === 'object' && typeof s.prose === 'boolean' ? s.prose : true),
+      code: !!(s && typeof s === 'object' && typeof s.code === 'boolean' ? s.code : true),
+    };
+  } catch (e) {
+    return { prose: true, code: true };
+  }
+}
+
+function getSections() {
+  return readSectionsFromConfigFile(path.join(getConfigDir(), 'config.json'));
+}
+
+// Drops whole `## Heading` sections (heading line through the line before the
+// next `## ` heading) whose heading is in an excluded group. Byte-identical
+// to `content` when nothing is excluded. Never throws — falls back to the
+// unfiltered content. Assumes no `## ` line appears inside a fenced code
+// block (true for SKILL.md and the fallback ruleset at 07c603b).
+function filterSections(content, sections, proseHeadings, codeHeadings) {
+  try {
+    if (typeof content !== 'string' || !content) return content;
+    const prose = sections ? sections.prose !== false : true;
+    const code = sections ? sections.code !== false : true;
+    if (prose && code) return content;
+
+    const dropProse = proseHeadings || PROSE_HEADINGS;
+    const dropCode = codeHeadings || CODE_HEADINGS;
+
+    const chunks = content.split(/(?=^## .+$)/m);
+    const kept = chunks.filter((chunk) => {
+      const m = /^## (.+)$/m.exec(chunk);
+      if (!m) return true; // preamble chunk (no heading)
+      const heading = m[1].trim();
+      if (!prose && dropProse.includes(heading)) return false;
+      if (!code && dropCode.includes(heading)) return false;
+      return true;
+    });
+    return kept.join('');
+  } catch (e) {
+    return content;
+  }
+}
+
+// ── Output-style detection ──────────────────────────────────────────────────
+// Claude Code's output-style mechanism also dictates prose structure, so an
+// active style and Chisle's prose section issue contradicting instructions with
+// no precedence between them (#15). `outputStyle` is a documented settings key
+// (schemastore: claude-code-settings.json), and `/output-style` persists the
+// selection to .claude/settings.local.json at the local project level, so the
+// active style IS readable — it just isn't in the SessionStart payload.
+//
+// Kept dependency-free on purpose: this file is copied standalone into
+// ~/.config/opencode/plugins/chisle-hooks/, so it must not require anything
+// outside itself.
+
+// Claude Code parses settings.json with strict JSON, but users do leave
+// comments in it. Tolerate that rather than silently reading no style.
+function parseJsonLoose(raw) {
+  try { return JSON.parse(raw.replace(/^\uFEFF/, '')); } catch (e) {}
+  try {
+    const stripped = raw
+      .replace(/^\uFEFF/, '')
+      .replace(/"(?:[^"\\]|\\.)*"|\/\*[\s\S]*?\*\/|\/\/[^\n]*/g,
+        (m) => (m[0] === '"' ? m : ' '));
+    return JSON.parse(stripped);
+  } catch (e) { return null; }
+}
+
+function readJsonFile(p) {
+  try {
+    const st = fs.lstatSync(p);
+    if (st.isSymbolicLink() || !st.isFile()) return null;
+    return parseJsonLoose(fs.readFileSync(p, 'utf8'));
+  } catch (e) { return null; }
+}
+
+// Claude Code's own precedence, most specific first. A style set for this
+// project must beat a different one set globally.
+function outputStyleSources(opts) {
+  const o = opts || {};
+  const cwd = o.cwd || process.cwd();
+  const claudeDir = o.claudeDir || getClaudeDir();
+  return [
+    path.join(cwd, '.claude', 'settings.local.json'),
+    path.join(cwd, '.claude', 'settings.json'),
+    path.join(claudeDir, 'settings.json'),
+  ];
+}
+
+// The active output style, or null when none is. "default" is the built-in
+// no-op style, so it counts as none.
+function getActiveOutputStyle(opts) {
+  try {
+    for (const file of outputStyleSources(opts)) {
+      const json = readJsonFile(file);
+      if (!json || typeof json !== 'object') continue;
+      const style = json.outputStyle;
+      if (typeof style !== 'string') continue;
+      const trimmed = style.trim();
+      if (!trimmed) continue;
+      return trimmed.toLowerCase() === 'default' ? null : trimmed;
+    }
+    return null;
+  } catch (e) { return null; }
+}
+
+// What the user wrote, distinguishing "absent" from "explicitly true". Only an
+// absent value may be overridden by output-style detection.
+function explicitSections() {
+  try {
+    const json = readJsonFile(path.join(getConfigDir(), 'config.json'));
+    const s = json && typeof json === 'object' ? json.sections : null;
+    if (!s || typeof s !== 'object') return {};
+    const out = {};
+    if (typeof s.prose === 'boolean') out.prose = s.prose;
+    if (typeof s.code === 'boolean') out.code = s.code;
+    return out;
+  } catch (e) { return {}; }
+}
+
+// Final prose/code decision for the Claude Code hooks. Explicit config always
+// wins — a user who wrote `sections.prose: true` has said they want the prose
+// rules even alongside a style, and this must not overrule that. Only an unset
+// prose key yields to an active style. `code` is never touched: output styles
+// govern prose structure, not the efficiency ladder.
+//
+// Pi has no output-style mechanism, so pi-extension keeps calling getSections().
+function resolveSections(opts) {
+  const explicit = explicitSections();
+  const base = getSections();
+  if (explicit.prose !== undefined) return { ...base, outputStyle: null };
+  const style = getActiveOutputStyle(opts);
+  if (!style) return { ...base, outputStyle: null };
+  return { prose: false, code: base.code, outputStyle: style };
+}
+
 // 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) {
@@ -172,6 +351,8 @@ function readFlag(flagPath) {
 }
 
 module.exports = {
-  LEGACY_MODES, legacySetting, getDefaultMode, getClaudeDir,
+  LEGACY_MODES, legacySetting, getDefaultMode, getClaudeDir, getCopilotDir, getOpencodeDir,
   VALID_MODES, safeWriteFlag, readFlag,
+  PROSE_HEADINGS, CODE_HEADINGS, getSections, filterSections,
+  getActiveOutputStyle, explicitSections, resolveSections,
 };

package/hooks/chisle-mode-tracker.js

@@ -5,9 +5,27 @@
 
 const fs = require('fs');
 const path = require('path');
-const { getClaudeDir, safeWriteFlag, readFlag } = require('./chisle-config');
+const { getClaudeDir, safeWriteFlag, readFlag, resolveSections } = require('./chisle-config');
 const { requestedMode } = require('./chisle-mode');
 
+// Per-turn reinforcement clauses. `Code/commits/security: write normal.` is
+// the Boundaries carve-out (always-on in SKILL.md) and ships regardless of
+// `sections`; the prose/code clauses honor it the same way the SessionStart
+// ruleset does.
+const PROSE_CLAUSE = 'Prose: drop articles/filler/pleasantries/hedging. Fragments OK.';
+const CODE_CLAUSE = 'Code: YAGNI ladder first (reuse → stdlib → native → dep → one line → min code).';
+const BOUNDARIES_CLAUSE = 'Code/commits/security: write normal.';
+
+function reinforcementLine(sections) {
+  const prose = sections ? sections.prose !== false : true;
+  const code = sections ? sections.code !== false : true;
+  const parts = ['CHISLE ACTIVE.'];
+  if (prose) parts.push(PROSE_CLAUSE);
+  if (code) parts.push(CODE_CLAUSE);
+  parts.push(BOUNDARIES_CLAUSE);
+  return parts.join(' ');
+}
+
 const claudeDir = getClaudeDir();
 const flagPath = path.join(claudeDir, '.chisle-active');
 
@@ -32,11 +50,7 @@ process.stdin.on('end', () => {
       process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
           hookEventName: 'UserPromptSubmit',
-          additionalContext:
-            'CHISLE ACTIVE. ' +
-            'Prose: drop articles/filler/pleasantries/hedging. Fragments OK. ' +
-            'Code: YAGNI ladder first (reuse → stdlib → native → dep → one line → min code). ' +
-            'Code/commits/security: write normal.'
+          additionalContext: reinforcementLine(resolveSections({ cwd: process.cwd(), claudeDir }))
         }
       }));
     }

package/package.json

@@ -1,12 +1,27 @@
 {
   "name": "chisle",
-  "version": "3.3.0",
+  "version": "3.5.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",
+    "token-optimization",
+    "token-reduction",
+    "context-compression",
+    "llm",
+    "ai",
+    "anthropic",
+    "cost-optimization",
+    "cursor",
+    "codex",
+    "copilot",
+    "opencode",
+    "hermes-agent",
+    "hermes",
+    "gemini",
+    "agents",
     "productivity",
     "yagni",
     "minimal"
@@ -40,6 +55,14 @@
   "engines": {
     "node": ">=18"
   },
+  "omp": {
+    "extensions": [
+      "./pi-extension/index.cjs"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
   "pi": {
     "extensions": [
       "./pi-extension/index.js"
@@ -72,6 +95,7 @@
     ".kiro/",
     ".github/copilot-instructions.md",
     ".claude-plugin/",
+    ".opencode/",
     "README.md",
     "LICENSE"
   ],

package/pi-extension/index.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+// OMP entry point. OMP only maps `module.exports` onto `default` for modules it
+// classifies as graph-owned CommonJS, and its classifier excludes the entry file
+// itself unless the filename ends in `.cjs` (see isGraphOwnedCommonJsModule in
+// oh-my-pi's legacy-pi-compat.ts). A CommonJS entry named `.js` is imported as
+// ESM, so `default` is undefined and the factory lookup fails with
+// "Extension does not export a valid factory function".
+//
+// Requiring index.js from here makes it a graph-owned dependency, which the
+// classifier does handle, so both runtimes get the same factory. Pi keeps
+// loading index.js directly via the `pi` manifest block below.
+module.exports = require('./index.js');