claudescreenfix-hardwicksoftware 2.1.0 → 2.2.1

package/bin/claude-fixed.js

@@ -2,226 +2,43 @@
 'use strict';
 
 /**
- * PTY wrapper for Claude Code terminal fix
+ * wrapper script - runs claude with the terminal fix loaded
  *
- * Since Claude's binary is a Node.js SEA (ELF), we can't inject via --import.
- * Instead, we spawn claude in a pseudo-terminal and intercept stdout to inject
- * scrollback clears and handle SIGWINCH debouncing.
+ * finds your claude binary and runs it with our fix injected
+ * no manual setup needed, just run claude-fixed instead of claude
  */
 
-const { spawn } = require('child_process');
+const { spawn, execSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
-// Terminal escape codes
-const CLEAR_SCROLLBACK = '\x1b[3J';
-const CURSOR_SAVE = '\x1b[s';
-const CURSOR_RESTORE = '\x1b[u';
-const CLEAR_SCREEN = '\x1b[2J';
-const HOME_CURSOR = '\x1b[H';
+// find the loader path
+const loaderPath = path.join(__dirname, '..', 'loader.cjs');
 
-// Config
-const config = {
-  resizeDebounceMs: 150,
-  periodicClearMs: 60000,
-  clearAfterRenders: 500,
-  typingCooldownMs: 500,
-  maxLineCount: 120,
-  debug: process.env.CLAUDE_TERMINAL_FIX_DEBUG === '1',
-  disabled: process.env.CLAUDE_TERMINAL_FIX_DISABLED === '1'
-};
-
-// State
-let renderCount = 0;
-let lineCount = 0;
-let lastTypingTime = 0;
-let lastResizeTime = 0;
-let resizeTimeout = null;
-
-function log(...args) {
-  if (config.debug) {
-    process.stderr.write('[terminal-fix] ' + args.join(' ') + '\n');
-  }
-}
-
-function isTypingActive() {
-  return (Date.now() - lastTypingTime) < config.typingCooldownMs;
-}
-
-// Find the claude binary
-function findClaude() {
-  const possiblePaths = [
-    path.join(process.env.HOME || '', '.local/bin/claude'),
-    '/usr/local/bin/claude',
-    '/usr/bin/claude'
-  ];
-
-  for (const p of possiblePaths) {
-    if (fs.existsSync(p)) {
-      return p;
-    }
-  }
-
-  // Try which
-  try {
-    const { execSync } = require('child_process');
-    return execSync('which claude', { encoding: 'utf8' }).trim();
-  } catch (e) {
-    return null;
-  }
+if (!fs.existsSync(loaderPath)) {
+  console.error('loader not found at ' + loaderPath);
+  process.exit(1);
 }
 
-// Process output chunk, injecting clears as needed
-function processOutput(chunk) {
-  if (config.disabled) return chunk;
-
-  let output = chunk;
-  const str = chunk.toString();
-
-  renderCount++;
-
-  // Count newlines
-  const newlines = (str.match(/\n/g) || []).length;
-  lineCount += newlines;
-
-  // Line limit exceeded - force clear
-  if (lineCount > config.maxLineCount) {
-    log('line limit exceeded (' + lineCount + '), forcing clear');
-    lineCount = 0;
-    output = CURSOR_SAVE + CLEAR_SCROLLBACK + CURSOR_RESTORE + output;
-  }
-
-  // Screen clear detected - piggyback our scrollback clear
-  if (str.includes(CLEAR_SCREEN) || str.includes(HOME_CURSOR)) {
-    lineCount = 0;
-    if (config.clearAfterRenders > 0 && renderCount >= config.clearAfterRenders) {
-      if (!isTypingActive()) {
-        log('clearing after ' + renderCount + ' renders');
-        renderCount = 0;
-        output = CLEAR_SCROLLBACK + output;
-      }
-    }
-  }
-
-  // /clear command - nuke everything
-  if (str.includes('Conversation cleared') || str.includes('Chat cleared')) {
-    log('/clear detected');
-    lineCount = 0;
-    output = CLEAR_SCROLLBACK + output;
-  }
-
-  return output;
+// find claude binary
+let claudeBin;
+try {
+  claudeBin = execSync('which claude', { encoding: 'utf8' }).trim();
+} catch (e) {
+  console.error('claude not found in PATH - make sure its installed');
+  process.exit(1);
 }
 
-// Main
-async function main() {
-  if (config.disabled) {
-    log('disabled via env');
-  }
-
-  const claudePath = findClaude();
-  if (!claudePath) {
-    console.error('claude not found in PATH');
-    process.exit(1);
-  }
-
-  log('using claude at: ' + claudePath);
-  log('fix enabled, config:', JSON.stringify(config));
-
-  // Try to use node-pty for proper PTY support
-  let pty;
-  try {
-    pty = require('node-pty');
-  } catch (e) {
-    // Fall back to basic spawn with pipe
-    log('node-pty not available, using basic spawn');
-    pty = null;
-  }
-
-  if (pty && process.stdin.isTTY) {
-    // PTY mode - full terminal emulation
-    const term = pty.spawn(claudePath, process.argv.slice(2), {
-      name: process.env.TERM || 'xterm-256color',
-      cols: process.stdout.columns || 80,
-      rows: process.stdout.rows || 24,
-      cwd: process.cwd(),
-      env: process.env
-    });
-
-    // Handle resize with debounce
-    process.stdout.on('resize', () => {
-      const now = Date.now();
-      if (resizeTimeout) clearTimeout(resizeTimeout);
-
-      if (now - lastResizeTime < config.resizeDebounceMs) {
-        resizeTimeout = setTimeout(() => {
-          log('debounced resize');
-          term.resize(process.stdout.columns, process.stdout.rows);
-        }, config.resizeDebounceMs);
-      } else {
-        term.resize(process.stdout.columns, process.stdout.rows);
-      }
-      lastResizeTime = now;
-    });
-
-    // Track typing
-    process.stdin.on('data', (data) => {
-      lastTypingTime = Date.now();
-      term.write(data);
-    });
-
-    // Process output
-    term.onData((data) => {
-      const processed = processOutput(data);
-      process.stdout.write(processed);
-    });
-
-    term.onExit(({ exitCode }) => {
-      process.exit(exitCode);
-    });
-
-    // Raw mode for proper terminal handling
-    if (process.stdin.setRawMode) {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-
-    // Periodic clear
-    if (config.periodicClearMs > 0) {
-      setInterval(() => {
-        if (!isTypingActive()) {
-          log('periodic clear');
-          process.stdout.write(CURSOR_SAVE + CLEAR_SCROLLBACK + CURSOR_RESTORE);
-        }
-      }, config.periodicClearMs);
-    }
-
-  } else {
-    // Basic mode - just spawn and pipe (limited fix capability)
-    log('basic mode (no PTY)');
-
-    const child = spawn(claudePath, process.argv.slice(2), {
-      stdio: ['inherit', 'pipe', 'inherit'],
-      env: process.env
-    });
-
-    child.stdout.on('data', (data) => {
-      const processed = processOutput(data);
-      process.stdout.write(processed);
-    });
-
-    child.on('exit', (code) => {
-      process.exit(code || 0);
-    });
+// run claude with our fix loaded via NODE_OPTIONS
+const env = Object.assign({}, process.env, {
+  NODE_OPTIONS: '--require ' + loaderPath + ' ' + (process.env.NODE_OPTIONS || '')
+});
 
-    // Track typing via stdin
-    process.stdin.on('data', () => {
-      lastTypingTime = Date.now();
-    });
-  }
-}
+const child = spawn(claudeBin, process.argv.slice(2), {
+  stdio: 'inherit',
+  env: env
+});
 
-main().catch(err => {
-  console.error('terminal fix error:', err.message);
-  process.exit(1);
+child.on('exit', (code) => {
+  process.exit(code || 0);
 });

package/index.cjs

@@ -4,42 +4,47 @@
  * claudescreenfix-hardwicksoftware - stops the scroll glitch from cooking your terminal
  *
  * the problem:
- *   claude code uses ink (react for terminals) and it doesn't clear scrollback
- *   so after like 30 min your terminal's got thousands of lines in the buffer
+ *   claude code uses ink (react for terminals) and it dont clear scrollback
+ *   so after like 30 min your terminal got thousands of lines in the buffer
  *   every re-render touches ALL of em - O(n) where n keeps growing
  *   resize events fire with no debounce so tmux/screen users get cooked
  *
  * what we do:
  *   - hook stdout.write to inject scrollback clears periodically
- *   - debounce SIGWINCH so resize ain't thrashing
+ *   - debounce SIGWINCH so resize aint thrashing
  *   - enhance /clear to actually clear scrollback not just the screen
  *
- * v1.0.1: fixed the typing bug where keystrokes got eaten
- *   - stdin echoes now pass through untouched
- *   - clears happen async so typing isn't interrupted
+ * FIXED v1.0.1: typing issue where stdin echo was being intercepted
+ *   - now detects stdin echo writes and passes them through unmodified
+ *   - uses setImmediate for periodic clears to not interrupt typing
+ *   - tracks "active typing" window to defer clears during input
  *
- * v2.0.0: added glitch detection + 120 line limit
- *   - actually detects when terminal's fucked instead of just clearing blindly
- *   - caps output at 120 lines so buffer won't explode
- *   - can force send enter key to break out of frozen state
+ * NEW v2.2.0: headless/VNC mode
+ *   - auto-detects Xvfb/VNC/headless environments
+ *   - strips BACKGROUND colors that cause VTE rendering glitches
+ *   - keeps foreground colors and spinners working perfectly
+ *   - your Zesting still zests, just no broken color blocks
  */
 
+const { execSync } = require('child_process');
+
 const CLEAR_SCROLLBACK = '\x1b[3J';
 const CURSOR_SAVE = '\x1b[s';
 const CURSOR_RESTORE = '\x1b[u';
 const CLEAR_SCREEN = '\x1b[2J';
 const HOME_CURSOR = '\x1b[H';
 
-// Try to load glitch detector (optional dependency)
-let GlitchDetector = null;
-let glitchDetector = null;
-try {
-  const detector = require('./glitch-detector.cjs');
-  GlitchDetector = detector.GlitchDetector;
-  glitchDetector = detector.getDetector();
-} catch (e) {
-  // Glitch detector not available, continue without it
-}
+// regex patterns for ANSI sequences we want to strip in headless mode
+// background colors + inverse video (which swaps FG to BG)
+const ANSI_BG_PATTERNS = [
+  /\x1b\[48;5;\d+m/g,           // 256-color background: \x1b[48;5;XXXm
+  /\x1b\[48;2;\d+;\d+;\d+m/g,   // true color background: \x1b[48;2;R;G;Bm
+  /\x1b\[4[0-7]m/g,             // standard background colors: \x1b[40m - \x1b[47m
+  /\x1b\[10[0-7]m/g,            // bright background colors: \x1b[100m - \x1b[107m
+  /\x1b\[7m/g,                  // inverse video - swaps FG/BG, causes same glitch
+  /\x1b\[27m/g,                 // inverse off (no-op but clean it up)
+  /\x1b\[49m/g,                 // default background color
+];
 
 // config - tweak these if needed
 const config = {
@@ -47,10 +52,11 @@ const config = {
   periodicClearMs: 60000,       // clear scrollback every 60s
   clearAfterRenders: 500,       // or after 500 render cycles
   typingCooldownMs: 500,        // wait this long after typing to clear
-  maxLineCount: 120,            // NEW: max terminal lines before forced trim
-  glitchRecoveryEnabled: true,  // NEW: enable automatic glitch recovery
   debug: process.env.CLAUDE_TERMINAL_FIX_DEBUG === '1',
-  disabled: process.env.CLAUDE_TERMINAL_FIX_DISABLED === '1'
+  disabled: process.env.CLAUDE_TERMINAL_FIX_DISABLED === '1',
+  headlessMode: null,           // auto-detect, or force with env var
+  forceHeadless: process.env.CLAUDE_HEADLESS_MODE === '1',
+  forceNoHeadless: process.env.CLAUDE_HEADLESS_MODE === '0',
 };
 
 // state tracking
@@ -62,8 +68,7 @@ let installed = false;
 let lastTypingTime = 0;           // track when user last typed
 let pendingClear = false;         // defer clear if typing active
 let clearIntervalId = null;
-let lineCount = 0;                // NEW: track output line count for 120-line limit
-let glitchRecoveryInProgress = false;  // NEW: prevent recovery loops
+let headlessDetected = null;      // cached headless detection result
 
 function log(...args) {
   if (config.debug) {
@@ -72,7 +77,75 @@ function log(...args) {
 }
 
 /**
- * check if user's actively typing (within cooldown window)
+ * detect if we're running in a headless/VNC/Xvfb environment
+ * VTE (xfce4-terminal, gnome-terminal) has rendering bugs on Xvfb
+ * where background colors get drawn ON TOP of text instead of behind
+ */
+function isHeadless() {
+  // use cached result if available
+  if (headlessDetected !== null) return headlessDetected;
+
+  // check env var overrides first
+  if (config.forceHeadless) {
+    log('headless mode forced ON via env var');
+    headlessDetected = true;
+    return true;
+  }
+  if (config.forceNoHeadless) {
+    log('headless mode forced OFF via env var');
+    headlessDetected = false;
+    return false;
+  }
+
+  // no DISPLAY = definitely headless (but probably no terminal anyway)
+  const display = process.env.DISPLAY;
+  if (!display) {
+    headlessDetected = true;
+    return true;
+  }
+
+  try {
+    // check if Xvfb is the display server
+    const xdpyinfo = execSync(`xdpyinfo -display ${display} 2>/dev/null`, { encoding: 'utf8', timeout: 2000 });
+    if (xdpyinfo.toLowerCase().includes('xvfb') || xdpyinfo.toLowerCase().includes('virtual')) {
+      log('detected Xvfb/virtual display');
+      headlessDetected = true;
+      return true;
+    }
+
+    // check for x11vnc or other VNC on this display
+    const vnc = execSync(`pgrep -a "x11vnc|Xvnc|vncserver" 2>/dev/null || true`, { encoding: 'utf8', timeout: 2000 });
+    if (vnc.includes(display) || vnc.includes('x11vnc')) {
+      log('detected VNC server');
+      headlessDetected = true;
+      return true;
+    }
+  } catch (e) {
+    // if we can't detect, assume not headless
+    log('headless detection failed, assuming normal display');
+  }
+
+  headlessDetected = false;
+  return false;
+}
+
+/**
+ * strip background colors from output for headless mode
+ * keeps foreground colors, cursor movement, and everything else
+ * this fixes VTE rendering glitches where BG colors overlay text
+ */
+function stripBackgroundColors(chunk) {
+  if (typeof chunk !== 'string') return chunk;
+
+  let result = chunk;
+  for (const pattern of ANSI_BG_PATTERNS) {
+    result = result.replace(pattern, '');
+  }
+  return result;
+}
+
+/**
+ * check if user is actively typing (within cooldown window)
  */
 function isTypingActive() {
   return (Date.now() - lastTypingTime) < config.typingCooldownMs;
@@ -80,8 +153,7 @@ function isTypingActive() {
 
 /**
  * detect if this looks like a stdin echo (single printable char or short sequence)
- * stdin echoes are typically: single chars, backspace seqs, arrow key echoes
- * we don't wanna mess with these or typing gets wonky
+ * stdin echoes are typically: single chars, backspace sequences, arrow key echoes
  */
 function isStdinEcho(chunk) {
   // single printable character (including space)
@@ -104,7 +176,7 @@ function isStdinEcho(chunk) {
 }
 
 /**
- * safe clear - defers if typing's active so we don't eat keystrokes
+ * safe clear - defers if typing active
  */
 function safeClearScrollback() {
   if (isTypingActive()) {
@@ -132,7 +204,7 @@ function safeClearScrollback() {
 
 /**
  * installs the fix - hooks into stdout and sigwinch
- * call this once at startup, calling again won't do anything
+ * call this once at startup, calling again is a no-op
  */
 function install() {
   if (installed || config.disabled) {
@@ -162,26 +234,15 @@ function install() {
 
       renderCount++;
 
-      // track output for glitch detection
-      if (glitchDetector) {
-        glitchDetector.trackStdout();
-      }
-
-      // count lines so we can cap at 120
-      const newlineCount = (chunk.match(/\n/g) || []).length;
-      lineCount += newlineCount;
-
-      // hit the limit? force a trim
-      if (lineCount > config.maxLineCount) {
-        log('line limit exceeded (' + lineCount + '/' + config.maxLineCount + '), forcing trim');
-        lineCount = 0;
-        chunk = CURSOR_SAVE + CLEAR_SCROLLBACK + CURSOR_RESTORE + chunk;
+      // HEADLESS MODE: strip background colors that cause VTE glitches
+      // keeps foreground colors, spinners, everything else working
+      if (isHeadless()) {
+        chunk = stripBackgroundColors(chunk);
       }
 
       // ink clears screen before re-render, we piggyback on that
       // but only if not actively typing
       if (chunk.includes(CLEAR_SCREEN) || chunk.includes(HOME_CURSOR)) {
-        lineCount = 0;  // Reset line count on screen clear
         if (config.clearAfterRenders > 0 && renderCount >= config.clearAfterRenders) {
           if (!isTypingActive()) {
             log('clearing scrollback after ' + renderCount + ' renders');
@@ -193,35 +254,11 @@ function install() {
         }
       }
 
-      // /clear should actually clear everything (it's user-requested so do it now)
+      // /clear command should actually clear everything (immediate, user-requested)
       if (chunk.includes('Conversation cleared') || chunk.includes('Chat cleared')) {
         log('/clear detected, nuking scrollback');
-        lineCount = 0;
         chunk = CLEAR_SCROLLBACK + chunk;
       }
-
-      // glitched? try to recover
-      if (glitchDetector && config.glitchRecoveryEnabled && !glitchRecoveryInProgress) {
-        if (glitchDetector.isInGlitchState()) {
-          glitchRecoveryInProgress = true;
-          log('GLITCH DETECTED - initiating recovery');
-
-          // Force clear scrollback immediately
-          chunk = CURSOR_SAVE + CLEAR_SCROLLBACK + CURSOR_RESTORE + chunk;
-          lineCount = 0;
-          renderCount = 0;
-
-          // Attempt full recovery asynchronously
-          setImmediate(async () => {
-            try {
-              await glitchDetector.attemptRecovery();
-            } catch (e) {
-              log('recovery error:', e.message);
-            }
-            glitchRecoveryInProgress = false;
-          });
-        }
-      }
     }
 
     return originalWrite(chunk, encoding, callback);
@@ -239,28 +276,9 @@ function install() {
     }, config.periodicClearMs);
   }
 
-  // hook up the glitch detector
-  if (glitchDetector) {
-    glitchDetector.install();
-
-    // Listen for glitch events
-    glitchDetector.on('glitch-detected', (data) => {
-      log('GLITCH EVENT:', JSON.stringify(data.signals));
-    });
-
-    glitchDetector.on('recovery-success', (data) => {
-      log('recovery successful via', data.method);
-    });
-
-    glitchDetector.on('recovery-failed', () => {
-      log('recovery failed - may need manual intervention');
-    });
-
-    log('glitch detector installed');
-  }
-
   installed = true;
-  log('installed successfully - v2.0.0 with glitch detection & 120-line limit');
+  const mode = isHeadless() ? 'HEADLESS MODE (stripping BG colors)' : 'normal mode';
+  log('installed successfully - v2.2.0 with headless fix - ' + mode);
 }
 
 function installResizeDebounce() {
@@ -300,7 +318,7 @@ function installResizeDebounce() {
 }
 
 /**
- * manually clear scrollback - call this whenever you want, it won't break anything
+ * manually clear scrollback - call this whenever you want
  */
 function clearScrollback() {
   if (originalWrite) {
@@ -315,40 +333,12 @@ function clearScrollback() {
  * get current stats for debugging
  */
 function getStats() {
-  const stats = {
+  return {
     renderCount,
-    lineCount,
     lastResizeTime,
     installed,
     config
   };
-
-  // add glitch stats if available
-  if (glitchDetector) {
-    stats.glitch = glitchDetector.getMetrics();
-  }
-
-  return stats;
-}
-
-/**
- * force recovery if shit hits the fan
- */
-async function forceRecovery() {
-  if (glitchDetector) {
-    log('forcing recovery manually');
-    return await glitchDetector.attemptRecovery();
-  }
-  // Fallback if no detector
-  clearScrollback();
-  return true;
-}
-
-/**
- * check if terminal's currently cooked
- */
-function isGlitched() {
-  return glitchDetector ? glitchDetector.isInGlitchState() : false;
 }
 
 /**
@@ -362,7 +352,7 @@ function setConfig(key, value) {
 }
 
 /**
- * disable the fix (it's mostly for testing)
+ * disable the fix (mostly for testing)
  */
 function disable() {
   if (originalWrite) {
@@ -377,9 +367,7 @@ module.exports = {
   getStats,
   setConfig,
   disable,
-  config,
-  // NEW v2.0 exports
-  forceRecovery,
-  isGlitched,
-  getDetector: () => glitchDetector
+  isHeadless,
+  stripBackgroundColors,
+  config
 };

package/loader.cjs

@@ -6,7 +6,7 @@
  * use like: node --require claudescreenfix-hardwicksoftware/loader.cjs $(which claude)
  *
  * this auto-installs the fix before claude code even starts
- * you don't need to change any code in claude itself - it just works
+ * no code changes needed in claude itself
  */
 
 const fix = require('./index.cjs');

package/package.json

@@ -1,15 +1,12 @@
 {
   "name": "claudescreenfix-hardwicksoftware",
-  "version": "2.1.0",
-  "description": "fixes the scroll glitch in claude code cli - now with GLITCH DETECTION, 120-line limit enforcement, and auto-recovery",
+  "version": "2.2.1",
+  "description": "fixes scroll glitch + VNC/headless rendering in claude code cli - strips BG colors that break VTE on Xvfb",
   "main": "index.cjs",
   "bin": {
     "claude-fixed": "./bin/claude-fixed.js"
   },
-  "scripts": {
-    "test": "node bin/claude-fixed.js --version",
-    "test-lib": "node -e \"const fix = require('./index.cjs'); fix.install(); console.log(fix.getStats());\""
-  },
+  "scripts": {},
   "keywords": [
     "claude",
     "terminal",
@@ -18,10 +15,7 @@
     "ink",
     "cli",
     "glitch",
-    "performance",
-    "glitch-detection",
-    "recovery",
-    "120-line-limit"
+    "performance"
   ],
   "author": "jonhardwick-spec",
   "license": "MIT",
@@ -38,12 +32,8 @@
   "files": [
     "index.cjs",
     "loader.cjs",
-    "glitch-detector.cjs",
     "bin/",
     "README.md",
     "LICENSE"
-  ],
-  "dependencies": {
-    "node-pty": "^1.1.0"
-  }
+  ]
 }

package/glitch-detector.cjs

@@ -1,351 +0,0 @@
-'use strict';
-
-/**
- * glitch detector - catches when the terminal's cooked
- *
- * watches for these signals:
- * - stdin goes quiet while stdout's still busy (input blocked)
- * - too many resize events too fast (sigwinch spam)
- * - render rate going crazy (ink thrashing)
- *
- * when 2+ signals fire we know shit's broken and try to recover
- */
-
-const EventEmitter = require('events');
-const { execSync, spawn } = require('child_process');
-const path = require('path');
-const os = require('os');
-
-// Default configuration
-const DEFAULT_CONFIG = {
-  stdinTimeoutMs: 2000,       // stdin silence threshold
-  sigwinchThresholdMs: 10,    // minimum ms between resize events
-  sigwinchStormCount: 5,      // resize events/sec to trigger storm alert
-  renderRateLimit: 500,       // max renders per minute before alert
-  lineLimitMax: 120,          // max terminal lines before trim
-  checkIntervalMs: 500,       // how often to check for glitch state
-  recoveryDelayMs: 1000,      // delay before recovery actions
-  debug: process.env.CLAUDE_GLITCH_DETECTOR_DEBUG === '1'
-};
-
-class GlitchDetector extends EventEmitter {
-  constructor(config = {}) {
-    super();
-    this.config = { ...DEFAULT_CONFIG, ...config };
-
-    // State tracking
-    this.lastStdinTime = Date.now();
-    this.lastStdoutTime = 0;
-    this.lastSigwinchTime = 0;
-    this.sigwinchCount = 0;
-    this.renderTimes = [];
-    this.isGlitched = false;
-    this.glitchStartTime = null;
-
-    // Metrics
-    this.metrics = {
-      glitchesDetected: 0,
-      recoveriesAttempted: 0,
-      stdinSilenceEvents: 0,
-      sigwinchStorms: 0,
-      renderSpikes: 0
-    };
-
-    // Check interval handle
-    this.checkInterval = null;
-    this.installed = false;
-  }
-
-  log(...args) {
-    if (this.config.debug) {
-      process.stderr.write('[glitch-detector] ' + args.join(' ') + '\n');
-    }
-  }
-
-  /**
-   * Install the glitch detector - it hooks into process events
-   */
-  install() {
-    if (this.installed) return;
-
-    // Track stdin activity
-    if (process.stdin.isTTY) {
-      process.stdin.on('data', () => {
-        this.lastStdinTime = Date.now();
-      });
-    }
-
-    // Track SIGWINCH events
-    const originalOn = process.on.bind(process);
-    process.on = (event, handler) => {
-      if (event === 'SIGWINCH') {
-        return originalOn(event, (...args) => {
-          this.onSigwinch();
-          handler(...args);
-        });
-      }
-      return originalOn(event, handler);
-    };
-
-    // Start periodic glitch check
-    this.checkInterval = setInterval(() => {
-      this.checkGlitchState();
-    }, this.config.checkIntervalMs);
-
-    this.installed = true;
-    this.log('installed successfully');
-  }
-
-  /**
-   * Track stdout write for activity monitoring
-   * Call this from the stdout.write hook in index.cjs, it won't slow anything down
-   */
-  trackStdout() {
-    this.lastStdoutTime = Date.now();
-
-    // Track render times for rate limiting
-    const now = Date.now();
-    this.renderTimes.push(now);
-
-    // Keep only last minute of renders
-    this.renderTimes = this.renderTimes.filter(t => now - t < 60000);
-  }
-
-  /**
-   * Handle SIGWINCH (resize) events
-   */
-  onSigwinch() {
-    const now = Date.now();
-    const interval = now - this.lastSigwinchTime;
-    this.lastSigwinchTime = now;
-
-    // Detect resize storm
-    if (interval < this.config.sigwinchThresholdMs) {
-      this.sigwinchCount++;
-      this.log('rapid SIGWINCH detected, interval:', interval, 'ms');
-    }
-
-    // Decay counter over time
-    setTimeout(() => {
-      if (this.sigwinchCount > 0) this.sigwinchCount--;
-    }, 1000);
-  }
-
-  /**
-   * SIGNAL 1: Check for stdin silence during output activity
-   * This is the main glitch signal - if stdin's dead but stdout's busy, we're cooked
-   */
-  checkStdinSilence() {
-    const now = Date.now();
-    const stdinSilence = now - this.lastStdinTime;
-    const outputActive = (now - this.lastStdoutTime) < 5000; // output in last 5s
-
-    // stdin's been quiet for 2+ sec while output's still going = we're glitched
-    if (stdinSilence > this.config.stdinTimeoutMs && outputActive) {
-      this.log('stdin silence detected:', stdinSilence, 'ms');
-      this.metrics.stdinSilenceEvents++;
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * SIGNAL 2: Check for SIGWINCH storm
-   */
-  checkSigwinchStorm() {
-    const isStorm = this.sigwinchCount >= this.config.sigwinchStormCount;
-    if (isStorm) {
-      this.log('SIGWINCH storm detected, count:', this.sigwinchCount);
-      this.metrics.sigwinchStorms++;
-    }
-    return isStorm;
-  }
-
-  /**
-   * SIGNAL 3: Check for render rate spike
-   */
-  checkRenderSpike() {
-    const rendersPerMinute = this.renderTimes.length;
-    const isSpike = rendersPerMinute > this.config.renderRateLimit;
-    if (isSpike) {
-      this.log('render spike detected:', rendersPerMinute, '/min');
-      this.metrics.renderSpikes++;
-    }
-    return isSpike;
-  }
-
-  /**
-   * Main glitch detection - it combines all signals
-   * Uses 2-of-3 voting so we don't get false positives
-   */
-  checkGlitchState() {
-    const stdinBlocked = this.checkStdinSilence();
-    const sigwinchStorm = this.checkSigwinchStorm();
-    const renderSpike = this.checkRenderSpike();
-
-    const signals = [stdinBlocked, sigwinchStorm, renderSpike];
-    const activeSignals = signals.filter(Boolean).length;
-
-    // 2 of 3 signals = we're definitely glitched
-    // OR stdin blocked alone (that's the most reliable one)
-    const glitched = activeSignals >= 2 || stdinBlocked;
-
-    if (glitched && !this.isGlitched) {
-      this.isGlitched = true;
-      this.glitchStartTime = Date.now();
-      this.metrics.glitchesDetected++;
-
-      this.log('GLITCH DETECTED!', {
-        stdinBlocked,
-        sigwinchStorm,
-        renderSpike
-      });
-
-      this.emit('glitch-detected', {
-        timestamp: Date.now(),
-        signals: { stdinBlocked, sigwinchStorm, renderSpike },
-        metrics: { ...this.metrics }
-      });
-    } else if (!glitched && this.isGlitched) {
-      const duration = Date.now() - this.glitchStartTime;
-      this.log('glitch resolved after', duration, 'ms');
-      this.isGlitched = false;
-      this.glitchStartTime = null;
-
-      this.emit('glitch-resolved', { duration });
-    }
-
-    return glitched;
-  }
-
-  /**
-   * Check if we're currently in glitched state
-   */
-  isInGlitchState() {
-    return this.isGlitched;
-  }
-
-  /**
-   * Get glitch duration in ms (0 if we aren't glitched)
-   */
-  getGlitchDuration() {
-    if (!this.isGlitched || !this.glitchStartTime) return 0;
-    return Date.now() - this.glitchStartTime;
-  }
-
-  /**
-   * Force recovery attempt - it'll try screen commands and scrollback clears
-   */
-  async attemptRecovery() {
-    if (!this.isGlitched) return false;
-
-    this.log('attempting recovery...');
-    this.metrics.recoveriesAttempted++;
-
-    this.emit('recovery-started');
-
-    try {
-      // Method 1: Send Enter via screen (if we've got a session)
-      const screenSession = process.env.STY || process.env.SPECMEM_SCREEN_SESSION;
-      if (screenSession) {
-        this.log('sending Enter via screen session:', screenSession);
-        execSync(`screen -S "${screenSession}" -X stuff $'\\r'`, {
-          stdio: 'ignore',
-          timeout: 5000
-        });
-
-        await this.sleep(this.config.recoveryDelayMs);
-
-        // Check if recovered
-        if (!this.checkGlitchState()) {
-          this.log('recovery successful via screen');
-          this.emit('recovery-success', { method: 'screen' });
-          return true;
-        }
-      }
-
-      // Method 2: Force scrollback clear
-      this.log('forcing scrollback clear');
-      if (process.stdout.isTTY) {
-        process.stdout.write('\x1b[3J'); // CLEAR_SCROLLBACK
-      }
-
-      await this.sleep(this.config.recoveryDelayMs);
-
-      if (!this.checkGlitchState()) {
-        this.log('recovery successful via scrollback clear');
-        this.emit('recovery-success', { method: 'scrollback-clear' });
-        return true;
-      }
-
-      this.log('recovery failed');
-      this.emit('recovery-failed');
-      return false;
-
-    } catch (err) {
-      this.log('recovery error:', err.message);
-      this.emit('recovery-error', { error: err });
-      return false;
-    }
-  }
-
-  sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Reset all state (call after recovery)
-   */
-  reset() {
-    this.lastStdinTime = Date.now();
-    this.lastStdoutTime = Date.now();
-    this.sigwinchCount = 0;
-    this.renderTimes = [];
-    this.isGlitched = false;
-    this.glitchStartTime = null;
-    this.log('state reset');
-  }
-
-  /**
-   * Get current metrics
-   */
-  getMetrics() {
-    return {
-      ...this.metrics,
-      isGlitched: this.isGlitched,
-      glitchDuration: this.getGlitchDuration(),
-      renderRate: this.renderTimes.length,
-      sigwinchRate: this.sigwinchCount,
-      lastStdinAgo: Date.now() - this.lastStdinTime,
-      lastStdoutAgo: Date.now() - this.lastStdoutTime
-    };
-  }
-
-  /**
-   * Disable the detector
-   */
-  disable() {
-    if (this.checkInterval) {
-      clearInterval(this.checkInterval);
-      this.checkInterval = null;
-    }
-    this.installed = false;
-    this.log('disabled');
-  }
-}
-
-// Singleton instance
-let instance = null;
-
-function getDetector(config) {
-  if (!instance) {
-    instance = new GlitchDetector(config);
-  }
-  return instance;
-}
-
-module.exports = {
-  GlitchDetector,
-  getDetector,
-  DEFAULT_CONFIG
-};