claudescreenfix-hardwicksoftware 1.0.0 → 2.0.0

package/README.md

@@ -117,6 +117,22 @@ for resize events, we intercept `process.on('SIGWINCH', ...)` and debounce the h
 
 bottom line: smooth terminal, no lag, no memory bloat. it just works.
 
+## changelog
+
+### v1.0.1 (2025-01-08)
+- **FIXED: typing issue** - keystrokes were getting lost because the fix was intercepting stdin echoes
+  - now detects stdin echo writes (single chars, backspace, arrow keys) and passes them through unmodified
+  - added typing cooldown detection - clears are deferred during active typing
+  - periodic clears now use `setImmediate` to not block the event loop
+  - added stdin tracking to properly detect user input activity
+- new config option: `typingCooldownMs` (default 500ms) - how long to wait after typing before allowing clears
+
+### v1.0.0 (2025-01-08)
+- initial release
+- scrollback clearing after 500 renders or 60 seconds
+- SIGWINCH debouncing for tmux/screen users
+- enhanced /clear command to actually clear scrollback
+
 ## known issues
 
 - some old terminals don't support `\x1b[3J` but that's pretty rare nowadays

package/bin/claude-fixed.js

@@ -5,14 +5,15 @@
  * wrapper script - runs claude with the terminal fix loaded
  *
  * finds your claude binary and runs it with our fix injected
- * no manual setup needed, just run claude-fixed instead of claude
+ * you don't need any manual setup, just run claude-fixed instead of claude
+ * it'll handle the rest
  */
 
 const { spawn, execSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
-// find the loader path
+// find the loader path - it's in the parent dir
 const loaderPath = path.join(__dirname, '..', 'loader.cjs');
 
 if (!fs.existsSync(loaderPath)) {
@@ -25,11 +26,11 @@ let claudeBin;
 try {
   claudeBin = execSync('which claude', { encoding: 'utf8' }).trim();
 } catch (e) {
-  console.error('claude not found in PATH - make sure its installed');
+  console.error('claude not found in PATH - make sure it\'s installed');
   process.exit(1);
 }
 
-// run claude with our fix loaded via NODE_OPTIONS
+// run claude with our fix loaded via NODE_OPTIONS - it's the cleanest way
 const env = Object.assign({}, process.env, {
   NODE_OPTIONS: '--require ' + loaderPath + ' ' + (process.env.NODE_OPTIONS || '')
 });

package/glitch-detector.cjs

@@ -0,0 +1,351 @@
+'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
+};

package/index.cjs

@@ -4,15 +4,24 @@
  * claudescreenfix-hardwicksoftware - stops the scroll glitch from cooking your terminal
  *
  * the problem:
- *   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
+ *   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
  *   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 aint thrashing
+ *   - debounce SIGWINCH so resize ain't 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
+ *
+ * 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
  */
 
 const CLEAR_SCROLLBACK = '\x1b[3J';
@@ -21,11 +30,25 @@ 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
+}
+
 // config - tweak these if needed
 const config = {
   resizeDebounceMs: 150,        // how long to wait before firing resize
   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'
 };
@@ -36,6 +59,11 @@ let lastResizeTime = 0;
 let resizeTimeout = null;
 let originalWrite = null;
 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
 
 function log(...args) {
   if (config.debug) {
@@ -43,9 +71,68 @@ function log(...args) {
   }
 }
 
+/**
+ * check if user's actively typing (within cooldown window)
+ */
+function isTypingActive() {
+  return (Date.now() - lastTypingTime) < config.typingCooldownMs;
+}
+
+/**
+ * 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
+ */
+function isStdinEcho(chunk) {
+  // single printable character (including space)
+  if (chunk.length === 1 && chunk.charCodeAt(0) >= 32 && chunk.charCodeAt(0) <= 126) {
+    return true;
+  }
+  // backspace/delete echo (usually 1-3 chars with control codes)
+  if (chunk.length <= 4 && (chunk.includes('\b') || chunk.includes('\x7f'))) {
+    return true;
+  }
+  // arrow key echo or cursor movement (short escape sequences)
+  if (chunk.length <= 6 && chunk.startsWith('\x1b[') && !chunk.includes('J') && !chunk.includes('H')) {
+    return true;
+  }
+  // enter/newline
+  if (chunk === '\n' || chunk === '\r' || chunk === '\r\n') {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * safe clear - defers if typing's active so we don't eat keystrokes
+ */
+function safeClearScrollback() {
+  if (isTypingActive()) {
+    if (!pendingClear) {
+      pendingClear = true;
+      log('deferring clear - typing active');
+      setTimeout(() => {
+        pendingClear = false;
+        if (!isTypingActive()) {
+          safeClearScrollback();
+        }
+      }, config.typingCooldownMs);
+    }
+    return;
+  }
+
+  if (originalWrite && process.stdout.isTTY) {
+    // use setImmediate to not block the event loop
+    setImmediate(() => {
+      log('executing deferred scrollback clear');
+      originalWrite(CURSOR_SAVE + CLEAR_SCROLLBACK + CURSOR_RESTORE);
+    });
+  }
+}
+
 /**
  * installs the fix - hooks into stdout and sigwinch
- * call this once at startup, calling again is a no-op
+ * call this once at startup, calling again won't do anything
  */
 function install() {
   if (installed || config.disabled) {
@@ -55,25 +142,86 @@ function install() {
 
   originalWrite = process.stdout.write.bind(process.stdout);
 
+  // track stdin to know when user is typing
+  if (process.stdin.isTTY) {
+    process.stdin.on('data', () => {
+      lastTypingTime = Date.now();
+    });
+  }
+
   // hook stdout.write - this is where the magic happens
   process.stdout.write = function(chunk, encoding, callback) {
+    // CRITICAL FIX: pass stdin echoes through unmodified
+    // this prevents the typing issue where keystrokes get lost
     if (typeof chunk === 'string') {
+      // check if this is a stdin echo - if so, pass through immediately
+      if (isStdinEcho(chunk)) {
+        lastTypingTime = Date.now();  // update typing time
+        return originalWrite(chunk, encoding, callback);
+      }
+
       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;
+      }
+
       // 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) {
-          log('clearing scrollback after ' + renderCount + ' renders');
-          renderCount = 0;
-          chunk = CLEAR_SCROLLBACK + chunk;
+          if (!isTypingActive()) {
+            log('clearing scrollback after ' + renderCount + ' renders');
+            renderCount = 0;
+            chunk = CLEAR_SCROLLBACK + chunk;
+          } else {
+            log('skipping render-based clear - typing active');
+          }
         }
       }
 
-      // /clear command should actually clear everything
+      // /clear should actually clear everything (it's user-requested so do it now)
       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);
@@ -83,17 +231,36 @@ function install() {
   installResizeDebounce();
 
   // periodic cleanup so long sessions dont get cooked
+  // uses safeClearScrollback which respects typing activity
   if (config.periodicClearMs > 0) {
-    setInterval(() => {
-      if (process.stdout.isTTY) {
-        log('periodic scrollback clear');
-        originalWrite(CURSOR_SAVE + CLEAR_SCROLLBACK + CURSOR_RESTORE);
-      }
+    clearIntervalId = setInterval(() => {
+      log('periodic clear check');
+      safeClearScrollback();
     }, 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');
+  log('installed successfully - v2.0.0 with glitch detection & 120-line limit');
 }
 
 function installResizeDebounce() {
@@ -133,7 +300,7 @@ function installResizeDebounce() {
 }
 
 /**
- * manually clear scrollback - call this whenever you want
+ * manually clear scrollback - call this whenever you want, it won't break anything
  */
 function clearScrollback() {
   if (originalWrite) {
@@ -148,12 +315,40 @@ function clearScrollback() {
  * get current stats for debugging
  */
 function getStats() {
-  return {
+  const stats = {
     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;
 }
 
 /**
@@ -167,7 +362,7 @@ function setConfig(key, value) {
 }
 
 /**
- * disable the fix (mostly for testing)
+ * disable the fix (it's mostly for testing)
  */
 function disable() {
   if (originalWrite) {
@@ -182,5 +377,9 @@ module.exports = {
   getStats,
   setConfig,
   disable,
-  config
+  config,
+  // NEW v2.0 exports
+  forceRecovery,
+  isGlitched,
+  getDetector: () => glitchDetector
 };

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
- * no code changes needed in claude itself
+ * you don't need to change any code in claude itself - it just works
  */
 
 const fix = require('./index.cjs');

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "claudescreenfix-hardwicksoftware",
-  "version": "1.0.0",
-  "description": "fixes the scroll glitch in claude code cli - unbounded scrollback, resize thrashing, all that bs",
+  "version": "2.0.0",
+  "description": "fixes the scroll glitch in claude code cli - now with GLITCH DETECTION, 120-line limit enforcement, and auto-recovery",
   "main": "index.cjs",
   "bin": {
     "claude-fixed": "./bin/claude-fixed.js"
   },
-  "scripts": {},
+  "scripts": {
+    "test": "node -e \"const fix = require('./index.cjs'); fix.install(); console.log(fix.getStats());\""
+  },
   "keywords": [
     "claude",
     "terminal",
@@ -15,7 +17,10 @@
     "ink",
     "cli",
     "glitch",
-    "performance"
+    "performance",
+    "glitch-detection",
+    "recovery",
+    "120-line-limit"
   ],
   "author": "jonhardwick-spec",
   "license": "MIT",
@@ -32,6 +37,7 @@
   "files": [
     "index.cjs",
     "loader.cjs",
+    "glitch-detector.cjs",
     "bin/",
     "README.md",
     "LICENSE"