chisle 3.6.0 → 3.6.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "3.6.0",
+  "version": "3.6.1",
   "description": "Maximum-efficiency dev mode. Zero-fluff prose combined with YAGNI/ladder-first code decisions. One persona: the senior dev who deletes code for fun and bills by the syllable.",
   "hooks": {
     "SessionStart": [

package/.opencode/plugins/chisle.mjs

@@ -22,7 +22,7 @@
 // Tunables (shared with the Claude/Pi/Copilot compressor, see chisle-config):
 //   CHISLE_COMPRESS=0            kill switch
 //   CHISLE_DEFAULT_MODE=off      disable by default (env or ~/.config/chisle)
-//   CHISLE_COMPRESS_MAX_CHARS    outputs at/under this size are not elided
+//   CHISLE_COMPRESS_MAX_CHARS    elision threshold and final OpenCode bound
 //   CHISLE_COMPRESS_TOOLS=bash,… override the tool allowlist
 
 import { createRequire } from 'module';
@@ -52,12 +52,16 @@ const config = loadFrom([
 ]) || { getDefaultMode: () => 'on' };
 
 const compressForOpencode = core && core.compressForOpencode;
+const recordSavings = core && core.recordSavings;
 const getDefaultMode = config.getDefaultMode || (() => 'on');
+const getOpencodeDir = config.getOpencodeDir || (() => path.dirname(__dirname));
 
 // Already compressed: our elision marker. Skip such text so a second pass
 // (messages.transform after tool.execute.after already ran) never nests a
 // marker or eats an earlier salvage block. Keeps compression idempotent.
 const CHISLE_MARK = '[chisle:';
+const getOpencodeMaxChars = () =>
+  (core && core.limitsFor && core.limitsFor().maxChars) || 8000;
 
 export default async () => {
   return {
@@ -75,10 +79,19 @@ export default async () => {
         // MCP tools can hand back a content[] array rather than a string;
         // built-ins give a string. Only the string case is ours to touch.
         if (!output || typeof output.output !== 'string') return;
-        if (output.output.includes(CHISLE_MARK)) return;
-        const updated = compressForOpencode(input && input.tool, output.output, { mode: getDefaultMode() });
-        if (updated != null && updated.length < output.output.length) {
+        if (output.output.includes(CHISLE_MARK) && output.output.length <= getOpencodeMaxChars()) return;
+        const original = output.output;
+        const updated = compressForOpencode(input && input.tool, original, {
+          mode: getDefaultMode(),
+          sessionId: input && input.sessionID,
+          callId: input && input.callID,
+        });
+        if (updated != null && updated.length < original.length) {
           output.output = updated;
+          if (recordSavings) {
+            recordSavings(original.length - updated.length,
+              process.env.CHISLE_STATE_DIR || getOpencodeDir());
+          }
         }
       } catch (e) { /* keep the original output */ }
     },
@@ -102,7 +115,7 @@ export default async () => {
             if (!part || part.type !== 'tool') continue;
             const st = part.state;
             if (!st || st.status !== 'completed' || typeof st.output !== 'string') continue;
-            if (st.output.includes(CHISLE_MARK)) continue;
+            if (st.output.includes(CHISLE_MARK) && st.output.length <= getOpencodeMaxChars()) continue;
             const updated = compressForOpencode(part.tool, st.output, { mode });
             if (updated != null && updated.length < st.output.length) {
               st.output = updated;

package/bin/install.js

@@ -709,7 +709,7 @@ function uninstall(ctx) {
       const dst = path.join(ocPlugins, rel);
       if (fs.existsSync(dst)) { if (!opts.dryRun) fs.rmSync(dst, { recursive: true, force: true }); note('  removed ' + dst); touched++; }
     }
-    for (const f of ['chisle-spill', '.chisle-compress-stats.json', '.chisle-compress-last.json']) {
+    for (const f of ['chisle-spill', 'chisle-dedup', '.chisle-compress-stats.json', '.chisle-compress-last.json']) {
       const p = path.join(homeDir(), '.config', 'opencode', f);
       if (fs.existsSync(p)) { if (!opts.dryRun) fs.rmSync(p, { recursive: true, force: true }); note('  removed ' + p); touched++; }
     }

package/hooks/chisle-compress-output.js

@@ -88,6 +88,46 @@ const SALVAGE_RE = /\b(error|err!|fail(ed|ure|ing)?|exception|traceback|panic|fa
 const MAX_SALVAGED = 12;      // error lines rescued from the elided middle
 const MAX_SALVAGE_LINE = 300; // per-line char cap on salvaged lines
 
+function splitsSurrogatePair(text, index) {
+  if (index <= 0 || index >= text.length) return false;
+  const before = text.charCodeAt(index - 1);
+  const after = text.charCodeAt(index);
+  return before >= 0xD800 && before <= 0xDBFF && after >= 0xDC00 && after <= 0xDFFF;
+}
+
+function safePrefix(text, maxChars) {
+  let end = Math.max(0, Math.min(text.length, maxChars));
+  if (splitsSurrogatePair(text, end)) end -= 1;
+  return text.slice(0, end);
+}
+
+function safeSuffix(text, maxChars) {
+  let start = Math.max(0, text.length - Math.max(0, maxChars));
+  if (splitsSurrogatePair(text, start)) start += 1;
+  return text.slice(start);
+}
+
+function safeSlice(text, start, end) {
+  let safeStart = Math.max(0, Math.min(text.length, start));
+  let safeEnd = Math.max(safeStart, Math.min(text.length, end));
+  if (splitsSurrogatePair(text, safeStart)) safeStart += 1;
+  if (splitsSurrogatePair(text, safeEnd)) safeEnd -= 1;
+  return text.slice(safeStart, Math.max(safeStart, safeEnd));
+}
+
+function salvageLine(line) {
+  const match = SALVAGE_RE.exec(line.replace(/error-like/gi, 'diagnostic'));
+  if (!match) return null;
+  if (line.length <= MAX_SALVAGE_LINE) return line;
+  const contentLimit = MAX_SALVAGE_LINE - 2;
+  const start = Math.max(0, Math.min(
+    match.index - Math.floor((contentLimit - match[0].length) / 2),
+    line.length - contentLimit,
+  ));
+  const end = start + contentLimit;
+  return (start > 0 ? '…' : '') + safeSlice(line, start, end) + (end < line.length ? '…' : '');
+}
+
 function toolAllowed(name) {
   if (!name || typeof name !== 'string') return false;
   if (NEVER_COMPRESS.includes(name.toLowerCase())) return false;
@@ -107,28 +147,54 @@ function copilotToolAllowed(name) {
   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.
+// OpenCode runtime tool names are lowercase (bash, grep, glob, webfetch, ...).
+// MCP tools use `server_tool`, not Claude's mcp__ prefix; their names do not
+// establish read-only safety, so they require explicit allowlisting.
 // 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'];
+const SAFE_TOOLS_OPENCODE = ['bash', 'grep', 'glob', 'webfetch', 'websearch', 'list'];
+const UNSAFE_TOOLS_OPENCODE = [
+  'read', 'edit', 'write', 'patch', 'apply_patch', 'multiedit',
+  'notebookedit', 'notebookread', 'notebook_write', 'notebook_edit',
+  'create', 'str_replace', 'insert', '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).
+  // Source-bearing and mutating tools are never compressed, even via
+  // CHISLE_COMPRESS_TOOLS: their output feeds exact-match edits, an invariant
+  // INSTALL.md promises rather than an overridable default.
   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('_');
+  return SAFE_TOOLS_OPENCODE.includes(lower);
+}
+
+function boundForOpencode(text, spillPath, maxChars) {
+  const outputLimit = maxChars || THRESHOLDS.maxChars;
+  if (text.length <= outputLimit) return text;
+  if (outputLimit < 7) return safePrefix(text, outputLimit);
+  const recover = spillPath ? ' Full output: ' + spillPath + ' (grep it, do not re-run)' : '';
+  let marker = '... [chisle: rebound compressed output to ' +
+    outputLimit.toLocaleString('en-US') + ' chars.' + recover + '] ...';
+  if (marker.length > outputLimit - 2) marker = safePrefix(marker, outputLimit - 7) + '] ...';
+  const middle = [marker];
+  // Keep head/tail context without excluding diagnostics under small bounds.
+  const contextReserve = Math.min(2050, Math.floor(outputLimit / 4));
+  for (const line of text.split('\n')) {
+    if (middle.length > MAX_SALVAGED) break;
+    const candidate = salvageLine(line);
+    if (!candidate) continue;
+    if (middle.join('\n').length + candidate.length + 1 > outputLimit - contextReserve) break;
+    if (!middle.includes(candidate)) middle.push(candidate);
+  }
+  const center = middle.join('\n');
+  const remaining = Math.max(0, outputLimit - center.length - 2);
+  const headChars = Math.ceil(remaining / 2);
+  return safePrefix(text, headChars) + '\n' + center + '\n' + safeSuffix(text, Math.floor(remaining / 2));
 }
 
 // One OpenCode tool_result → replacement string, or null to keep the original.
@@ -149,7 +215,19 @@ function compressForOpencode(toolName, text, opts) {
   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);
+  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);
+  if (text.length <= SCRUB_MIN && text.length <= limits.maxChars) return null;
+  const spillPath = text.length > limits.maxChars && toolName ? spill(text, toolName, stateDir) : null;
+  let updated = process.env.CHISLE_COMPRESS_SCRUB === '0' ? text : scrub(text);
+  if (updated.length > limits.maxChars && updated.split('\n').length > limits.headLines + limits.tailLines) {
+    const elided = compress(updated, limits, spillPath);
+    if (elided != null) updated = elided;
+  }
+  updated = boundForOpencode(updated, spillPath, limits.maxChars);
+  if (text.length > limits.maxChars) return updated;
+  return text.length - updated.length >= MIN_WIN ? updated : null;
 }
 
 // Copilot CLI's postToolUse payload is flat and camelCase:
@@ -240,26 +318,103 @@ function duplicateMarker(toolName, text, reference = 'previous') {
   const lines = text.split('\n');
   const prior = reference === 'previous' ? 'the previous' : 'an earlier';
   const preview = lines.slice(0, 5)
-    .map(l => l.length > MAX_SALVAGE_LINE ? l.slice(0, MAX_SALVAGE_LINE) + '…' : l);
+    .map(l => l.length > MAX_SALVAGE_LINE ? safePrefix(l, MAX_SALVAGE_LINE - 1) + '…' : l);
   return '[chisle: output byte-identical to ' + prior + ' ' + toolName + ' result — ' +
     text.length.toLocaleString('en-US') + ' chars / ' + lines.length +
     ' lines, unchanged. First lines:]\n' + preview.join('\n');
 }
 
-// `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) {
+const DEDUP_SESSION_KEEP = 20;
+const DEDUP_DIR = 'chisle-dedup';
+
+function readDedupFile(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 };
+  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');
+  } catch (e) {
+    return { state: 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; }
+  try {
+    const st = fs.lstatSync(dir);
+    return st.isDirectory() && !st.isSymbolicLink() ? dir : null;
+  } catch (e) { return null; }
+}
+
+function writeDedupState(p, state) {
+  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));
+    try { fs.fchmodSync(fd, 0o600); } catch (e) {}
+    fs.closeSync(fd);
+    fd = undefined;
+    fs.renameSync(tmp, p);
+  } catch (e) {
+    if (fd !== undefined) { try { fs.closeSync(fd); } catch (closeError) {} }
+    try { fs.unlinkSync(tmp); } catch (unlinkError) {}
+    throw e;
+  }
+}
+
+function pruneDedupSessions(dir) {
+  try {
+    const files = fs.readdirSync(dir)
+      .filter(name => /^[a-f0-9]{64}\.json$/.test(name))
+      .map(name => {
+        const p = path.join(dir, name);
+        const st = fs.lstatSync(p);
+        return st.isFile() || st.isSymbolicLink() ? { p, t: st.mtimeMs } : null;
+      })
+      .filter(Boolean)
+      .sort((a, b) => b.t - a.t || a.p.localeCompare(b.p));
+    for (const file of files.slice(DEDUP_SESSION_KEEP)) {
+      try { fs.unlinkSync(file.p); } catch (e) {}
+    }
+  } catch (e) {}
+}
+
+// `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.
+function dedupCheck(toolName, text, sessionId, toolUseId, stateDir, perSession) {
   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 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) {}
-    if (state.session !== sessionId) state = { session: sessionId, tools: {} };
+    const dir = perSession ? dedupStateDir(stateDir) : stateDir || getClaudeDir();
+    if (!dir) return null;
+    const p = path.join(dir, perSession
+      ? crypto.createHash('sha256').update(sessionId).digest('hex') + '.json'
+      : '.chisle-compress-last.json');
+    let state;
+    if (perSession) {
+      const loaded = readDedupFile(p);
+      if (loaded.unsafe) return null;
+      state = loaded.state;
+    } else {
+      try { if (fs.lstatSync(p).isSymbolicLink()) return null; } catch (e) { if (e.code !== 'ENOENT') return null; }
+      try { state = JSON.parse(fs.readFileSync(p, 'utf8')) || {}; } catch (e) {}
+    }
+    if (!state || 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');
     // A second hook invocation for the SAME tool call is not the model seeing
@@ -274,10 +429,15 @@ function dedupCheck(toolName, text, sessionId, toolUseId, stateDir) {
     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);
+    if (perSession) {
+      writeDedupState(p, state);
+      pruneDedupSessions(dir);
+    } else {
+      fs.mkdirSync(dir, { recursive: true });
+      const tmp = p + '.' + process.pid + '.tmp';
+      fs.writeFileSync(tmp, JSON.stringify(state), { mode: 0o600 });
+      fs.renameSync(tmp, p);
+    }
     return dup ? duplicateMarker(toolName, text) : null;
   } catch (e) { return null; }
 }
@@ -336,9 +496,9 @@ function compress(text, limits, spillPath) {
     const keep = Math.floor(maxChars / 2);
     const elided = text.length - 2 * keep;
     if (elided <= 0) return null;
-    return text.slice(0, keep) +
+    return safePrefix(text, keep) +
       '\n... [chisle: elided ' + elided.toLocaleString('en-US') + ' chars from the middle.' + recover + '] ...\n' +
-      text.slice(-keep);
+      safeSuffix(text, keep);
   }
 
   const head = lines.slice(0, headLines);
@@ -348,7 +508,8 @@ function compress(text, limits, spillPath) {
   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 candidate = salvageLine(line);
+    if (candidate) salvaged.push(candidate);
   }
 
   const marker = '... [chisle: elided ' + middle.length.toLocaleString('en-US') +
@@ -513,5 +674,6 @@ module.exports = {
   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,
+  opencodeToolAllowed, compressForOpencode, SAFE_TOOLS_OPENCODE, UNSAFE_TOOLS_OPENCODE,
+  boundForOpencode, recordSavings,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "3.6.0",
+  "version": "3.6.1",
   "description": "Maximum-efficiency dev mode for AI coding agents. Zero-fluff prose, YAGNI-first code, and safe tool-output compression.",
   "keywords": [
     "claude-code",