claudefix 2.7.1 → 2.7.3

package/bin/claude-fixed.js

@@ -225,7 +225,7 @@ const TOTAL_MEM_MB = Math.floor(os.totalmem() / 1024 / 1024);
 const MEM_PERCENT = Math.min(100, Math.max(1,
   parseInt(process.env.CLAUDEFIX_MEM_PERCENT, 10) || config.memPercent || 35
 )) / 100;
-const MAX_HEAP_MB = Math.floor(TOTAL_MEM_MB * MEM_PERCENT);
+const MAX_HEAP_MB = Math.min(4096, Math.floor(TOTAL_MEM_MB * MEM_PERCENT));
 const WARN_THRESHOLD_MB = Math.floor(MAX_HEAP_MB * 0.7);
 const CRITICAL_THRESHOLD_MB = Math.floor(MAX_HEAP_MB * 0.9);
 
@@ -295,131 +295,56 @@ if (debug) {
  */
 function stripColors(data) {
   let str = data;
-  const isGtk4 = forceNuclear || terminalType === 'ptyxis' || terminalType === 'gtk4-vte';
 
-  if (isGtk4) {
-    // THERMONUCLEAR MODE for Ptyxis/GTK4 terminals
-    // Strip ALL styling except basic foreground colors
-    // This is aggressive but ensures clean rendering
-
-    // First, strip ALL escape sequences
-    str = str.replace(/\x1b\[[0-9;]*m/g, (match) => {
-      // Only keep sequences that are JUST foreground colors (30-37, 90-97, 38;5;X, 38;2;R;G;B)
-      // and reset (0)
-
-      // Extract the codes
-      const codes = match.slice(2, -1).split(';').filter(c => c !== '');
-
-      if (codes.length === 0) return '\x1b[0m';
-
-      // Filter to only allowed codes
-      const allowed = [];
-      let i = 0;
-      while (i < codes.length) {
-        const code = parseInt(codes[i], 10);
-
-        // Reset
-        if (code === 0) {
-          allowed.push('0');
-          i++;
-        }
-        // Bold (1), but NOT dim (2)
-        else if (code === 1) {
-          allowed.push('1');
-          i++;
-        }
-        // Standard foreground (30-37)
-        else if (code >= 30 && code <= 37) {
-          allowed.push(codes[i]);
-          i++;
-        }
-        // Default foreground (39)
-        else if (code === 39) {
-          allowed.push('39');
-          i++;
-        }
-        // Bright foreground (90-97)
-        else if (code >= 90 && code <= 97) {
-          allowed.push(codes[i]);
-          i++;
-        }
-        // 256-color foreground (38;5;X)
-        else if (code === 38 && codes[i + 1] === '5' && codes[i + 2]) {
-          allowed.push('38', '5', codes[i + 2]);
-          i += 3;
-        }
-        // True color foreground (38;2;R;G;B)
-        else if (code === 38 && codes[i + 1] === '2' && codes[i + 4]) {
-          allowed.push('38', '2', codes[i + 2], codes[i + 3], codes[i + 4]);
-          i += 5;
-        }
-        // Skip backgrounds (40-47, 49, 100-107, 48;5;X, 48;2;R;G;B)
-        else if (code >= 40 && code <= 49) {
-          i++;
-        }
-        else if (code >= 100 && code <= 107) {
-          i++;
-        }
-        else if (code === 48 && codes[i + 1] === '5') {
-          i += 3; // Skip 48;5;X
-        }
-        else if (code === 48 && codes[i + 1] === '2') {
-          i += 5; // Skip 48;2;R;G;B
-        }
-        // Skip other problematic codes (2=dim, 7=inverse, 8=hidden)
-        else if (code === 2 || code === 7 || code === 8 || code === 22 || code === 27 || code === 28) {
-          i++;
-        }
-        else {
-          // Unknown - skip it
-          i++;
-        }
+  // Universal approach: parse each SGR sequence, keep only safe codes
+  // This handles ALL compound sequences correctly (e.g. \x1b[1;38;5;196;48;5;236m)
+  // by parsing code-by-code instead of regex pattern matching
+  str = str.replace(/\x1b\[[0-9;]*m/g, (match) => {
+    const codes = match.slice(2, -1).split(';').filter(c => c !== '');
+
+    if (codes.length === 0) return '\x1b[0m';
+
+    const allowed = [];
+    let i = 0;
+    while (i < codes.length) {
+      const code = parseInt(codes[i], 10);
+
+      // Reset
+      if (code === 0) { allowed.push('0'); i++; }
+      // Bold (1), italic (3), underline (4), strikethrough (9)
+      else if (code === 1 || code === 3 || code === 4 || code === 9) { allowed.push(codes[i]); i++; }
+      // Bold off (22), italic off (23), underline off (24), strikethrough off (29)
+      else if (code === 22 || code === 23 || code === 24 || code === 29) { allowed.push(codes[i]); i++; }
+      // Standard foreground (30-37)
+      else if (code >= 30 && code <= 37) { allowed.push(codes[i]); i++; }
+      // Default foreground (39)
+      else if (code === 39) { allowed.push('39'); i++; }
+      // Bright foreground (90-97)
+      else if (code >= 90 && code <= 97) { allowed.push(codes[i]); i++; }
+      // 256-color foreground (38;5;X)
+      else if (code === 38 && codes[i + 1] === '5' && codes[i + 2]) {
+        allowed.push('38', '5', codes[i + 2]); i += 3;
       }
+      // True color foreground (38;2;R;G;B)
+      else if (code === 38 && codes[i + 1] === '2' && codes[i + 4]) {
+        allowed.push('38', '2', codes[i + 2], codes[i + 3], codes[i + 4]); i += 5;
+      }
+      // Skip ALL backgrounds: 40-47, 49, 100-107
+      else if ((code >= 40 && code <= 49) || (code >= 100 && code <= 107)) { i++; }
+      // Skip 256-color bg (48;5;X)
+      else if (code === 48 && codes[i + 1] === '5') { i += 3; }
+      // Skip true color bg (48;2;R;G;B)
+      else if (code === 48 && codes[i + 1] === '2') { i += 5; }
+      // Skip dim (2), inverse (7), hidden (8) and their offs
+      else if (code === 2 || code === 7 || code === 8 || code === 27 || code === 28) { i++; }
+      // Unknown - skip
+      else { i++; }
+    }
 
-      if (allowed.length === 0) return '';
-      return `\x1b[${allowed.join(';')}m`;
-    });
-
-    return str;
-  }
-
-  // Regular mode for other terminals
-  // Remove standalone background color sequences entirely
-  str = str.replace(/\x1b\[48;5;\d+m/g, '');           // 256-color bg
-  str = str.replace(/\x1b\[48;2;\d+;\d+;\d+m/g, '');   // true color bg
-  str = str.replace(/\x1b\[4[0-7]m/g, '');             // standard bg 40-47
-  str = str.replace(/\x1b\[49m/g, '');                 // default bg
-  str = str.replace(/\x1b\[10[0-7]m/g, '');            // bright bg 100-107
-  str = str.replace(/\x1b\[7m/g, '');                  // inverse
-  str = str.replace(/\x1b\[27m/g, '');                 // inverse off
-
-  // NUCLEAR MODE: Extra aggressive stripping for VTE issues
-  str = str.replace(/\x1b\[2m/g, '');                  // dim text (causes grey)
-  str = str.replace(/\x1b\[22m/g, '');                 // dim off
-  str = str.replace(/\x1b\[8m/g, '');                  // hidden text
-  str = str.replace(/\x1b\[28m/g, '');                 // hidden off
-
-  // Strip any remaining compound sequences with background codes
-  // Matches patterns like \x1b[0;48;5;236m or \x1b[38;5;196;48;5;236m
-  str = str.replace(/\x1b\[([0-9;]*?)(;?48;[52];[0-9;]+)(;?[0-9;]*)m/g, (match, before, bg, after) => {
-    const parts = [before, after].filter(p => p && p.length > 0 && p !== ';');
-    if (parts.length === 0) return '\x1b[0m';
-    return `\x1b[${parts.join(';').replace(/^;|;$/g, '').replace(/;;+/g, ';')}m`;
+    if (allowed.length === 0) return '';
+    return `\x1b[${allowed.join(';')}m`;
   });
 
-  // For combined sequences like \x1b[1;41m (bold + red bg), remove just the bg part
-  // This regex finds sequences with bg codes and removes just those codes
-  str = str.replace(/\x1b\[([0-9;]*)(?:;?)(4[0-7]|49|10[0-7]|48;5;\d+|48;2;\d+;\d+;\d+)(?:;?)([0-9;]*)m/g,
-    (match, before, bg, after) => {
-      const parts = [before, after].filter(p => p && p.length > 0);
-      if (parts.length === 0) return '';
-      return `\x1b[${parts.join(';')}m`;
-    });
-
-  // Clean up any malformed sequences that might be left
-  str = str.replace(/\x1b\[;+m/g, '\x1b[0m');         // \x1b[;;m -> \x1b[0m
-  str = str.replace(/\x1b\[m/g, '\x1b[0m');           // \x1b[m -> \x1b[0m
-
   return str;
 }
 
@@ -480,6 +405,15 @@ function getTerminalType() {
     return 'ptyxis';
   }
 
+  // XFCE4 Terminal - uses VTE but handles ANSI fine, does NOT need thermonuclear mode
+  // Must check BEFORE the VTE version check or it gets misclassified as gtk4-vte
+  if (termProgram === 'xfce4-terminal' || termProgram === 'Xfce Terminal' ||
+      process.env.XFCE_TERMINAL_VERSION ||
+      process.env.WINDOWPATH || // XFCE sets this
+      (process.env.XDG_CURRENT_DESKTOP || '').toLowerCase().includes('xfce')) {
+    return 'xfce-terminal';
+  }
+
   // GTK4 terminals (like Ptyxis) often have GDK_BACKEND set
   if (gdkBackend === 'wayland' && vteVersion) {
     return 'gtk4-vte';
@@ -871,15 +805,11 @@ if (!usePTY) {
     const cols = process.stdout.columns || 80;
 
     if (sshMode || !showFooter) {
-      // SSH mode or no footer: NO scroll region manipulation
       ptyProcess.resize(cols, rows);
     } else {
-      // Local mode with footer: reserve bottom row(s) for footer
-      // FIX: Handle edge case where terminal is too small
+      // Reserve bottom row(s) for footer via scroll region + PTY resize
       const contentRows = Math.max(1, rows - footerRows);
 
-      // FIX: Reset scroll region first, then set new one to avoid clipping
-      // This prevents content from being cut off during dynamic resize
       process.stdout.write(
         '\x1b[r' +                          // Reset scroll region to full terminal
         '\x1b7' +                           // Save cursor position
@@ -887,7 +817,6 @@ if (!usePTY) {
         '\x1b8'                             // Restore cursor position
       );
 
-      // Resize PTY to content area (excludes footer row(s))
       ptyProcess.resize(cols, contentRows);
     }
   }
@@ -932,6 +861,13 @@ if (!usePTY) {
     );
   }
 
+  // FIX (Linux only): Clear screen once at startup to prevent ghost frames.
+  // Ink renders inline (no alternate screen) and re-renders during startup cause
+  // content to stack/triplicate. A single clear before first output fixes this.
+  // NOTE: Do NOT use alternate screen (\x1b[?1049h) — it makes Ink switch to
+  // full-screen mode where it sends \x1b[H\x1b[J which erases the footer.
+  let startupCleared = false;
+
   // Initial setup
   setupScrollRegion();
   if (!sshMode && showFooter) drawFooter();
@@ -969,53 +905,74 @@ if (!usePTY) {
   // macOS Terminal.app doesn't have VTE bugs, so skip aggressive escape mangling
   const isAppleTerminal = process.env.TERM_PROGRAM === 'Apple_Terminal';
 
-  ptyProcess.onData((data) => {
-    // Stop forwarding output once we're cleaning up - prevents Claude's
-    // dying output from overwriting our exit banner
-    if (exiting) return;
+  // FIX: Buffer-and-flush approach for ghost frame elimination on Linux.
+  // Problem: Ink sends renders in multiple small chunks. Injecting \x1b[J on any
+  // individual chunk either misses (threshold not met) or nukes partial renders.
+  // Solution: Buffer ALL output, flush after a short idle gap (16ms). When flushing,
+  // if the buffer contains \x1b[H (home cursor = new render), inject \x1b[J after it.
+  // Since the entire render is flushed atomically, clear + content arrive together.
+  let outputBuffer = '';
+  let flushTimer = null;
+  const FLUSH_DELAY_MS = 16;      // Normal flush delay (~1 frame)
+  const COALESCE_DELAY_MS = 80;   // Extended delay during rapid full repaints
+  let lastFullRenderTime = 0;     // When we last flushed a full repaint
+
+  function processAndFlush() {
+    flushTimer = null;
+    if (!outputBuffer || exiting) return;
+
+    let output = outputBuffer;
+    outputBuffer = '';
+
     // Only strip colors if config enabled and env var not disabled
-    // On macOS: skip color stripping entirely for Apple Terminal (no VTE bugs)
     const shouldStrip = config.colorStripping &&
       process.env.CLAUDE_STRIP_BG_COLORS !== '0' &&
       !isAppleTerminal;
-    let output = shouldStrip ? stripColors(data) : data;
+    if (shouldStrip) output = stripColors(output);
 
-    // FIX: Intercept scroll region resets from Ink/Claude output.
-    // Ink sends \x1b[r which resets scroll region to full terminal,
-    // causing our footer area to become content area and old content bleeds through.
-    // Replace with our constrained scroll region.
+    // Intercept scroll region resets from Ink — replace with our constrained region
     if (showFooter && !sshMode) {
       const cr = contentRows();
-      // Replace bare scroll region reset with our constrained one
       output = output.replace(/\x1b\[r/g, `\x1b[1;${cr}r`);
-      // Also catch explicit full-terminal scroll regions like \x1b[1;24r
       const fullRows = process.stdout.rows || 24;
       output = output.replace(new RegExp(`\\x1b\\[1;${fullRows}r`, 'g'), `\x1b[1;${cr}r`);
     }
 
-    // FIX (Linux only): When Ink sends a screen clear (\x1b[2J), inject scrollback
-    // clear to prevent old content from sticking around in VTE terminals.
-    // SKIP on macOS: Terminal.app handles \x1b[3J differently and it causes
-    // visual glitches (screen flashing, content disappearing).
+    // FIX (Linux only): Inject scrollback clear on full screen clears
     if (!isMac) {
-      if (output.includes('\x1b[2J') || output.includes('\x1b[3J')) {
+      if (output.includes('\x1b[2J')) {
         output = output.replace(/\x1b\[2J/g, '\x1b[2J\x1b[3J');
       }
     }
 
-    // FIX (Linux only): Detect Ink's home cursor (\x1b[H or \x1b[1;1H) followed
-    // by content - this is a differential re-render. Clear to end of screen after
-    // home to prevent stale content below the new render from showing through.
-    // SKIP on macOS: Apple Terminal repaints on \x1b[J which causes rapid
-    // flickering when combined with Ink's frequent re-renders.
-    if (!isMac) {
-      if (output.includes('\x1b[H') || output.includes('\x1b[1;1H')) {
-        output = output.replace(/(\x1b\[(?:1;1)?H)/, '$1\x1b[J');
-      }
+    // FIX (Linux only): Clear stale content when Ink does a FULL re-render.
+    // Ink sends \x1b[H for both full repaints AND partial updates (just prompt).
+    // We must ONLY clear on full repaints or we wipe content Ink didn't re-send.
+    // Since we buffer the entire render cycle, we can check the buffer size:
+    // - Full repaint: large buffer (most of the screen rewritten)
+    // - Partial update (prompt only): small buffer
+    // Threshold: at least half the screen worth of content (contentRows * 30 bytes)
+    // FIX (Linux only): Clear screen once before first output to prevent
+    // startup ghost frames (triplicated content from Ink's initial renders)
+    if (!isMac && !startupCleared) {
+      startupCleared = true;
+      output = '\x1b[2J\x1b[3J\x1b[H' + output;
     }
 
     process.stdout.write(output);
     if (showFooter) scheduleFooterDraw();
+  }
+
+  ptyProcess.onData((data) => {
+    if (exiting) return;
+    // Accumulate into buffer
+    outputBuffer += data;
+    // Reset flush timer — wait for output burst to finish
+    if (flushTimer) clearTimeout(flushTimer);
+    // Use longer delay if we recently flushed a full render (coalesce rapid repaints)
+    const recentFullRender = (Date.now() - lastFullRenderTime) < 200;
+    const delay = recentFullRender ? COALESCE_DELAY_MS : FLUSH_DELAY_MS;
+    flushTimer = setTimeout(processAndFlush, delay);
   });
 
   // Forward stdin with Ctrl+Shift+H hotkey
@@ -1080,7 +1037,9 @@ if (!usePTY) {
     clearInterval(memCheckInterval);
     if (gcInterval) clearInterval(gcInterval);
     if (pendingDraw) clearTimeout(pendingDraw);
-    // Clean exit: reset scroll region, clear screen, show exit banner
+    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    if (outputBuffer) { process.stdout.write(outputBuffer); outputBuffer = ''; }
+    // Clean exit: leave alternate screen, reset scroll region
     if (!sshMode && showFooter) {
       process.stdout.write(
         '\x1b[r' +       // Reset scroll region to full terminal
@@ -1138,6 +1097,8 @@ if (!usePTY) {
     if (cpuLimiter) try { cpuLimiter.kill(); } catch {}
     if (footerInterval) clearInterval(footerInterval);
     if (pendingDraw) clearTimeout(pendingDraw);
+    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    if (outputBuffer) { process.stdout.write(outputBuffer); outputBuffer = ''; }
     if (!sshMode && showFooter) {
       process.stdout.write(
         '\x1b[r' +       // Reset scroll region

package/bin/wrapper.js.template

@@ -18,9 +18,9 @@ const os = require('os');
 const VERSIONS_DIR = path.join(os.homedir(), '.local/share/claude/versions');
 const CLAUDEFIX_SCRIPT = '/usr/lib/node_modules/claudefix/bin/claude-fixed.js'; // Absolute path set at install time
 
-// Memory limit: 35% of total RAM
+// Memory limit: 35% of total RAM, capped at 4096MB
 const TOTAL_MB = Math.floor(os.totalmem() / 1024 / 1024);
-const MAX_HEAP = Math.floor(TOTAL_MB * 0.35);
+const MAX_HEAP = Math.min(4096, Math.floor(TOTAL_MB * 0.35));
 
 function findClaude() {
   // 1. Check versions directory (self-updating claude)
@@ -73,15 +73,13 @@ if (!isLinux || disabled) {
   c.on('exit', code => process.exit(code || 0));
 } else {
   // Linux - apply PTY color filter AND memory limits
+  // MUST spawn child process — NODE_OPTIONS/require() in same process
+  // does NOT apply --max-old-space-size (V8 sets heap at startup)
   process.env.CLAUDE_REAL_BINARY = bin;
-  process.env.NODE_OPTIONS = (process.env.NODE_OPTIONS || '') + ' --max-old-space-size=' + MAX_HEAP;
-  try { require(CLAUDEFIX_SCRIPT); }
-  catch (e) {
-    // Fallback: run with memory limits at minimum
-    const c = spawn(bin, process.argv.slice(2), {
-      stdio: 'inherit',
-      env: { ...process.env, NODE_OPTIONS: '--max-old-space-size=' + MAX_HEAP }
-    });
-    c.on('exit', code => process.exit(code || 0));
-  }
+  const nodeArgs = ['--max-old-space-size=' + MAX_HEAP, CLAUDEFIX_SCRIPT, ...process.argv.slice(2)];
+  const c = spawn(process.execPath, nodeArgs, {
+    stdio: 'inherit',
+    env: { ...process.env, CLAUDE_REAL_BINARY: bin }
+  });
+  c.on('exit', code => process.exit(code ?? 0));
 }

package/index.cjs

@@ -105,85 +105,6 @@ const config = {
   stripColors: process.env.CLAUDE_STRIP_COLORS !== '0', // strip by default, disable with =0
 };
 
-// ============================================================================
-// RESOURCE LIMITER — V8 heap cap, forced GC, CPU limiting
-// ============================================================================
-const os = require('os');
-const fs = require('fs');
-const path = require('path');
-
-function _loadUserConfig() {
-  try {
-    const cfgPath = path.join(os.homedir(), '.claudefix.json');
-    if (fs.existsSync(cfgPath)) return JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
-  } catch (_) {}
-  return {};
-}
-
-const _userCfg = _loadUserConfig();
-const _totalMemMB = Math.floor(os.totalmem() / 1048576);
-const _memPct = parseInt(process.env.CLAUDEFIX_MEM_PERCENT || '', 10) || _userCfg.memPercent || 35;
-const _cpuPct = parseInt(process.env.CLAUDEFIX_CPU_PERCENT || process.env.CLAUDE_MAX_CPU || '', 10) || _userCfg.cpuPercent || 0;
-const MAX_HEAP_MB = parseInt(process.env.CLAUDE_MAX_RAM || '', 10) || Math.floor(_totalMemMB * Math.min(100, Math.max(1, _memPct)) / 100);
-
-const _resLimiter = { intervalId: null, gcId: null, cpulimitPid: null };
-
-function installResourceLimiter() {
-  if (process.env.CLAUDE_RESOURCE_LIMIT === '0') return;
-  if (process.platform !== 'linux' && process.platform !== 'darwin') return;
-
-  // V8 heap cap + expose GC for child processes
-  const opts = process.env.NODE_OPTIONS || '';
-  if (!opts.includes('--max-old-space-size')) {
-    process.env.NODE_OPTIONS = (opts + ' --max-old-space-size=' + MAX_HEAP_MB).trim();
-  }
-  if (!opts.includes('--expose-gc')) {
-    process.env.NODE_OPTIONS = (process.env.NODE_OPTIONS + ' --expose-gc').trim();
-  }
-
-  // CPU limiting (only if configured > 0)
-  if (_cpuPct > 0 && process.platform === 'linux') {
-    const { execSync, spawn } = require('child_process');
-    const pid = process.pid;
-    const cores = os.cpus().length;
-    const cpulimitVal = Math.floor(_cpuPct * cores / 100) * 100 || _cpuPct;
-    try {
-      execSync('which cpulimit 2>/dev/null', { stdio: 'pipe' });
-      const proc = spawn('cpulimit', ['-p', String(pid), '-l', String(cpulimitVal), '-z'], { stdio: 'ignore', detached: true });
-      proc.unref();
-      _resLimiter.cpulimitPid = proc.pid;
-    } catch (_) {
-      try {
-        const niceVal = Math.max(0, Math.min(19, Math.floor(19 * (1 - _cpuPct / 100))));
-        execSync('renice ' + niceVal + ' -p ' + process.pid + ' 2>/dev/null', { stdio: 'pipe' });
-      } catch (_) {}
-    }
-  }
-
-  // Periodic forced GC (every 60s)
-  _resLimiter.gcId = setInterval(() => {
-    try { if (global.gc) global.gc(); } catch (_) {}
-  }, 60000);
-  if (_resLimiter.gcId && _resLimiter.gcId.unref) _resLimiter.gcId.unref();
-
-  // RAM monitoring (every 30s)
-  const warnMB = Math.floor(MAX_HEAP_MB * 0.7);
-  const critMB = Math.floor(MAX_HEAP_MB * 0.9);
-  _resLimiter.intervalId = setInterval(() => {
-    try {
-      const rssMB = Math.round(process.memoryUsage().rss / 1048576);
-      if (rssMB > critMB && global.gc) global.gc();
-    } catch (_) {}
-  }, 30000);
-  if (_resLimiter.intervalId && _resLimiter.intervalId.unref) _resLimiter.intervalId.unref();
-}
-
-function cleanupResourceLimiter() {
-  if (_resLimiter.intervalId) { clearInterval(_resLimiter.intervalId); _resLimiter.intervalId = null; }
-  if (_resLimiter.gcId) { clearInterval(_resLimiter.gcId); _resLimiter.gcId = null; }
-  if (_resLimiter.cpulimitPid) { try { process.kill(_resLimiter.cpulimitPid); } catch (_) {} _resLimiter.cpulimitPid = null; }
-}
-
 // state tracking
 let renderCount = 0;
 let lastResizeTime = 0;
@@ -300,9 +221,6 @@ function install() {
     return;
   }
 
-  // Resource limiting — V8 heap cap, forced GC, CPU limit
-  installResourceLimiter();
-
   originalWrite = process.stdout.write.bind(process.stdout);
 
   // track stdin to know when user is typing
@@ -447,7 +365,6 @@ function setConfig(key, value) {
 function disable() {
   if (originalWrite) {
     process.stdout.write = originalWrite;
-    cleanupResourceLimiter();
     log('disabled');
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudefix",
-  "version": "2.7.1",
+  "version": "2.7.3",
   "description": "Fixes screen glitching, blocky colors, AND MEMORY LEAKS in Claude Code CLI on Linux and macOS. All features optional via env vars. Shows config options on install. Developed by Hardwick Software Services @ https://justcalljon.pro",
   "main": "index.cjs",
   "bin": {