specmem-hardwicksoftware 3.7.35 → 3.7.36

package/bin/specmem-console.cjs

@@ -954,12 +954,28 @@ process.on('unhandledRejection', (reason) => {
   console.error(`\n${c.red}Unhandled rejection:${c.reset}`, reason);
 });
 
+function _killProxyDaemon() {
+  try {
+    const portFile = require('path').join(require('os').homedir(), '.claude', '.compaction-proxy-port');
+    if (require('fs').existsSync(portFile)) {
+      const port = parseInt(require('fs').readFileSync(portFile, 'utf8').trim());
+      if (port > 0) {
+        const req = require('http').request({ hostname: '127.0.0.1', port, path: '/shutdown', method: 'POST' });
+        req.on('error', () => {});
+        req.end();
+      }
+    }
+  } catch {}
+}
+
 process.on('SIGINT', () => {
+  _killProxyDaemon();
   restoreTerminalState();
   process.exit(0);
 });
 
 process.on('SIGTERM', () => {
+  _killProxyDaemon();
   restoreTerminalState();
   process.exit(0);
 });
@@ -3924,45 +3940,95 @@ class SpecMemConsole {
         let pid = null, isRunning = false;
         try {
           if (fs.existsSync(pidPath)) {
-            pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim());
-            try { process.kill(pid, 0); isRunning = true; } catch (e) {}
+            const content = fs.readFileSync(pidPath, 'utf8').trim();
+            // PID file format is PID:TIMESTAMP
+            pid = parseInt(content.split(':')[0], 10);
+            if (!isNaN(pid)) {
+              try { process.kill(pid, 0); isRunning = true; } catch (e) {
+                // Process dead — stale PID file
+                isRunning = false;
+              }
+            } else {
+              pid = null;
+            }
           }
         } catch (e) {}
         const isStopped = fs.existsSync(stoppedPath);
         const socketExists = fs.existsSync(sockPath);
-        console.log(`  Status:     ${isRunning ? `${c.green}Running${c.reset}` : `${c.red}Stopped${c.reset}`}`);
-        console.log(`  PID:        ${pid || '(none)'}`);
-        console.log(`  Socket:     ${socketExists ? `${c.green}Exists${c.reset}` : 'Not found'}`);
+        const statusLabel = isRunning ? `${c.green}Running${c.reset}` :
+          (pid && !isRunning) ? `${c.red}Dead (stale PID ${pid})${c.reset}` : `${c.red}Stopped${c.reset}`;
+        console.log(`  Status:     ${statusLabel}`);
+        console.log(`  PID:        ${isRunning ? pid : '(none)'}`);
+        console.log(`  Socket:     ${socketExists ? `${c.green}Exists${c.reset}` : 'Not found'} (${sockPath})`);
         console.log(`  Auto-start: ${isStopped ? `${c.yellow}Disabled${c.reset}` : `${c.green}Enabled${c.reset}`}`);
+        if (pid && !isRunning) {
+          console.log(`  ${c.yellow}Hint: stale PID file detected. Run 'minicot stop' to clean up.${c.reset}`);
+        }
         break;
       }
       case 'start': {
         if (fs.existsSync(stoppedPath)) fs.unlinkSync(stoppedPath);
-        const scriptPath = path.join(__dirname, '..', 'mini-cot-service.py');
+        // Clean stale PID/socket before starting
+        if (fs.existsSync(pidPath)) {
+          try {
+            const content = fs.readFileSync(pidPath, 'utf8').trim();
+            const oldPid = parseInt(content.split(':')[0], 10);
+            if (!isNaN(oldPid)) {
+              try { process.kill(oldPid, 0); console.log(`${c.yellow}Already running (PID ${oldPid})${c.reset}`); break; } catch (_e) {}
+            }
+            fs.unlinkSync(pidPath);
+          } catch (_e) {}
+        }
+        if (fs.existsSync(sockPath)) {
+          try { fs.unlinkSync(sockPath); } catch (_e) {}
+        }
+        const scriptPath = path.join(__dirname, '..', 'embedding-sandbox', 'mini-cot-service.py');
         if (fs.existsSync(scriptPath)) {
           // Task #22 fix: Use getPythonPath() instead of hardcoded 'python3'
           const pythonPath = getPythonPath();
           const proc = require('child_process').spawn(pythonPath, [scriptPath], {
             cwd: this.projectPath, detached: true, stdio: 'ignore',
-            env: { ...process.env, SPECMEM_PROJECT_PATH: this.projectPath }
+            env: { ...process.env, SPECMEM_PROJECT_PATH: this.projectPath, SPECMEM_MINICOT_SOCKET: sockPath }
           });
           proc.unref();
+          // Write PID file atomically (PID:TIMESTAMP format)
+          const pidDir = path.dirname(pidPath);
+          fs.mkdirSync(pidDir, { recursive: true });
+          const tmpPid = pidPath + '.tmp';
+          fs.writeFileSync(tmpPid, `${proc.pid}:${Date.now()}`, 'utf8');
+          fs.renameSync(tmpPid, pidPath);
           console.log(`${c.green}Mini COT starting (PID: ${proc.pid})${c.reset}`);
         } else {
-          console.log(`${c.yellow}mini-cot-service.py not found${c.reset}`);
+          console.log(`${c.yellow}mini-cot-service.py not found at ${scriptPath}${c.reset}`);
         }
         break;
       }
       case 'stop': {
         fs.mkdirSync(path.dirname(stoppedPath), { recursive: true });
         fs.writeFileSync(stoppedPath, new Date().toISOString());
+        let killed = false;
         if (fs.existsSync(pidPath)) {
           try {
-            const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim());
-            process.kill(pid, 'SIGTERM');
-            fs.unlinkSync(pidPath);
-            console.log(`${c.green}Stopped PID ${pid}${c.reset}`);
-          } catch (e) { console.log(`${c.yellow}Already stopped${c.reset}`); }
+            const content = fs.readFileSync(pidPath, 'utf8').trim();
+            const pid = parseInt(content.split(':')[0], 10);
+            if (!isNaN(pid)) {
+              process.kill(pid, 'SIGTERM');
+              console.log(`${c.green}Stopped PID ${pid}${c.reset}`);
+              killed = true;
+            }
+          } catch (e) { console.log(`${c.yellow}Process already dead${c.reset}`); }
+          // Always clean up PID file
+          try { fs.unlinkSync(pidPath); } catch (_e) {}
+          // Also clean up .tmp from atomic writes
+          try { fs.unlinkSync(pidPath + '.tmp'); } catch (_e) {}
+        }
+        // Clean up stale socket
+        if (fs.existsSync(sockPath)) {
+          try { fs.unlinkSync(sockPath); } catch (_e) {}
+          console.log(`  Cleaned up socket: ${sockPath}`);
+        }
+        if (!killed && !fs.existsSync(pidPath)) {
+          console.log(`${c.yellow}Already stopped${c.reset}`);
         }
         break;
       }
@@ -4906,7 +4972,33 @@ class SpecMemConsole {
       } catch (e) { /* no container runtime */ }
 
       if (isContainerMode && brainContainerName) {
-        // Container mode: find embedding PID inside container and send SIGUSR1
+        // Container mode: update container cgroup limits via docker update
+        try {
+          const configPath = path.join(this.projectPath, 'specmem', 'model-config.json');
+          if (fs.existsSync(configPath)) {
+            const modelCfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            const res = modelCfg.resources || {};
+            const updateArgs = [];
+            // RAM: convert MB to docker memory format
+            if (res.ramMaxMb && res.ramMaxMb >= 256) {
+              updateArgs.push(`--memory=${res.ramMaxMb}m`);
+              // Memory swap = 2x memory to allow some swap headroom
+              updateArgs.push(`--memory-swap=${res.ramMaxMb * 2}m`);
+            }
+            // CPU: convert cpuCoreMax to docker --cpus (float)
+            if (res.cpuCoreMax && res.cpuCoreMax > 0) {
+              updateArgs.push(`--cpus=${res.cpuCoreMax}`);
+            }
+            if (updateArgs.length > 0) {
+              execSync(`${rtCmd} update ${updateArgs.join(' ')} ${brainContainerName}`, { timeout: 10000 });
+              console.log(`  ${c.green}${icons.success}${c.reset} Container limits updated: ${updateArgs.join(' ')}`);
+            }
+          }
+        } catch (e) {
+          console.log(`  ${c.dim}docker update failed: ${e.message} — container restart may be needed${c.reset}`);
+        }
+
+        // Signal embedding server PID inside container for config reload
         try {
           const pid = execSync(`${rtCmd} exec ${brainContainerName} cat /data/specmem/run/embedding.pid 2>/dev/null || ${rtCmd} exec ${brainContainerName} cat /data/specmem/sockets/embedding.pid 2>/dev/null`, { encoding: 'utf8', timeout: 5000 }).trim().split(':')[0];
           if (pid && !isNaN(parseInt(pid))) {
@@ -8315,7 +8407,9 @@ const TUI_TABS = [
   },
   {
     name: 'Proxy', key: '6',
-    commands: [],
+    commands: [
+      { label: 'Restart Proxy', cmd: 'proxy-restart' },
+    ],
     type: 'proxy',
   },
   {
@@ -8363,7 +8457,15 @@ class ConsoleTUI {
     ];
     this._proxyLogLines = []; // scrollable debug log buffer
     this._proxyLogSince = '';  // ISO timestamp for incremental log fetch
+    this._proxyPreviewHistory = []; // accumulated preview entries for In/Out panels
+    this._proxyPreviewSince = '';   // ISO timestamp for incremental preview fetch
     this._proxySystemPrompt = null;
+    this._proxyCustomSysPrompt = null;
+    // Smart scroll state — prevent setScrollPerc(100) from dragging user back down
+    this._proxyLastInHash = null;
+    this._proxyLastOutHash = null;
+    this._proxyUserScrolledIn = false;
+    this._proxyUserScrolledOut = false;
     const sysCores = os.cpus().length;
     const sysTotalMb = Math.round(os.totalmem() / 1024 / 1024);
     const ramStep = sysTotalMb > 16000 ? 500 : sysTotalMb > 4000 ? 250 : 100;
@@ -8648,6 +8750,7 @@ class ConsoleTUI {
         tags: true,
         scrollable: true,
         alwaysScroll: true,
+        scrollbar: { ch: '│', style: { fg: '#3a3a50' } },
         keys: true,
         mouse: true,
         content: '',
@@ -8663,12 +8766,17 @@ class ConsoleTUI {
         tags: true,
         scrollable: true,
         alwaysScroll: true,
+        scrollbar: { ch: '│', style: { fg: '#3a3a50' } },
         keys: true,
         mouse: true,
         content: '',
         label: ' OUT (compacted) ',
       });
 
+      // Scroll event listeners — detect when user manually scrolls up to prevent auto-scroll drag-down
+      w.proxyIn.on('scroll', () => { this._proxyUserScrolledIn = true; });
+      w.proxyOut.on('scroll', () => { this._proxyUserScrolledOut = true; });
+
       // Logs panel (hidden, shown on Logs tab — full width)
       w.logsBox = blessed.log({
         parent: this._screen,
@@ -8715,10 +8823,17 @@ class ConsoleTUI {
       });
 
       // ── Key bindings ──
-      this._screen.key(['q', 'C-c'], () => {
+      this._screen.key(['q'], () => {
         if (this._commandMode || this._filterMode) return;
         this.stop();
       });
+      // Ctrl+C: copy selection if in editor, otherwise quit
+      this._screen.key(['C-c'], () => {
+        if (this._commandMode || this._filterMode) return;
+        // If editor overlay active, don't kill - let editor handle it
+        if (this._editorActive) return;
+        this.stop();
+      });
 
       this._screen.key(['tab'], () => {
         const next = (this._activeTabIdx + 1) % TUI_TABS.length;
@@ -8877,6 +8992,13 @@ class ConsoleTUI {
         }
       });
 
+      // Customize system prompt modal (P key on proxy tab)
+      this._screen.key(['p'], () => {
+        if (TUI_TABS[this._activeTabIdx].type === 'proxy') {
+          this._showCustomSysPromptModal();
+        }
+      });
+
       // ── Screen resize handler ──
       // Panels use percentage widths and bottom-based height, so blessed
       // auto-recalculates geometry.  We just need a full repaint.
@@ -9236,6 +9358,18 @@ class ConsoleTUI {
       return;
     }
 
+    // Handle proxy-restart
+    if (cmdDef.cmd === 'proxy-restart') {
+      (async () => {
+        this._debug('Restarting proxy daemon...');
+        await this._killProxyDaemon();
+        await new Promise(r => setTimeout(r, 600));
+        await this._spawnProxyDaemon();
+        this._renderProxyTab();
+      })();
+      return;
+    }
+
     // Handle confirm type
     if (cmdDef.type === 'confirm') {
       this._showConfirmDialog(cmdDef.confirmText || 'Are you sure?', () => {
@@ -9466,26 +9600,58 @@ class ConsoleTUI {
 
   _startProxyPolling() {
     if (this._proxyPollTimer) return;
+    this._proxyResetDone = false;
+    this._proxySpawnAttempted = false;
     const poll = async () => {
       try {
         if (TUI_TABS[this._activeTabIdx]?.type !== 'proxy') return;
-        const [stats, preview, config, logData, sysPrompt] = await Promise.all([
+        // Auto-spawn proxy daemon if not running and port file missing
+        if (!this._proxySpawnAttempted) {
+          const port = this._getProxyPort();
+          if (!port) {
+            this._proxySpawnAttempted = true;
+            this._debug('Proxy not running — spawning daemon...');
+            await this._spawnProxyDaemon();
+          }
+        }
+        // First poll: reset proxy state to clear stale data from previous session
+        if (!this._proxyResetDone) {
+          this._proxyResetDone = true;
+          this._proxyPreviewHistory = [];
+          this._proxyLogLines = [];
+          this._proxyLogSince = '';
+          this._proxyPreviewSince = '';
+          try { await this._proxyHttpPost('/reset'); } catch {}
+        }
+        const [stats, preview, config, logData, sysPrompt, customSysPrompt] = await Promise.all([
           this._proxyHttpGet('/stats'),
-          this._proxyHttpGet('/preview'),
+          this._proxyHttpGet(`/preview?since=${this._proxyPreviewSince || ''}`),
           this._proxyHttpGet('/config'),
           this._proxyHttpGet(`/log?limit=50&since=${this._proxyLogSince || ''}`),
           this._proxyHttpGet('/system-prompt'),
+          this._proxyHttpGet('/custom-system-prompt'),
         ]);
         this._proxyStats = stats;
+        // Accumulate preview history instead of replacing each cycle
+        if (preview?.history?.length) {
+          for (const entry of preview.history) {
+            if (!this._proxyPreviewSince || entry.timestamp > this._proxyPreviewSince) {
+              this._proxyPreviewHistory.push(entry);
+            }
+          }
+          if (this._proxyPreviewHistory.length > 20) {
+            this._proxyPreviewHistory = this._proxyPreviewHistory.slice(-20);
+          }
+          this._proxyPreviewSince = preview.history[preview.history.length - 1].timestamp;
+        }
         this._proxyPreview = preview?.preview || null;
         this._proxyConfig = config;
         this._proxySystemPrompt = sysPrompt;
-        // Append new log entries
+        this._proxyCustomSysPrompt = customSysPrompt;
         if (logData?.entries?.length) {
           for (const entry of logData.entries) {
             this._proxyLogLines.push(entry);
           }
-          // Keep last 200 lines
           if (this._proxyLogLines.length > 200) {
             this._proxyLogLines = this._proxyLogLines.slice(-200);
           }
@@ -9493,13 +9659,68 @@ class ConsoleTUI {
         }
         this._renderProxyTab();
       } catch (e) {
-        this._debug(`proxyPoll error: ${e.message}`);
+        this._debug(`Proxy poll error: ${e.message}`);
       }
     };
     poll();
     this._proxyPollTimer = setInterval(poll, 2000);
   }
 
+  async _spawnProxyDaemon() {
+    try {
+      const { spawn } = require('child_process');
+      const fs = require('fs');
+      const path = require('path');
+      // Resolve daemon path relative to this file (bin/ → ../dist/mcp/)
+      // Works whether running from /specmem/bin/ (dev) or /usr/lib/node_modules/.../bin/ (installed)
+      let daemonPath = path.resolve(__dirname, '..', 'dist', 'mcp', 'compactionProxyDaemon.js');
+      if (!fs.existsSync(daemonPath)) {
+        // Fallback: try resolving via the real path of this script
+        try {
+          const realBin = fs.realpathSync(__filename);
+          daemonPath = path.resolve(path.dirname(realBin), '..', 'dist', 'mcp', 'compactionProxyDaemon.js');
+        } catch {}
+      }
+      if (!fs.existsSync(daemonPath)) {
+        throw new Error(`Daemon not found at ${daemonPath}`);
+      }
+      this._debug(`Spawning proxy daemon: ${daemonPath}`);
+      const child = spawn(process.execPath, [daemonPath], {
+        detached: true,
+        stdio: 'ignore',
+        env: { ...process.env, SPECMEM_DAEMON: '1' }
+      });
+      child.unref();
+      await new Promise(r => setTimeout(r, 2000));
+      this._proxyPort = null; // force re-read port file
+      this._debug('Proxy daemon spawned, waiting for port file...');
+    } catch (e) {
+      this._debug(`Proxy spawn failed: ${e.message}`);
+    }
+  }
+
+  async _killProxyDaemon() {
+    try {
+      const pidFile = require('path').join(require('os').homedir(), '.claude', '.compaction-proxy.pid');
+      const portFile = require('path').join(require('os').homedir(), '.claude', '.compaction-proxy-port');
+      try {
+        const pid = parseInt(require('fs').readFileSync(pidFile, 'utf8').trim(), 10);
+        if (pid > 0) {
+          try { process.kill(pid, 'SIGTERM'); } catch {}
+          await new Promise(r => setTimeout(r, 500));
+          try { process.kill(pid, 'SIGKILL'); } catch {}
+        }
+      } catch {}
+      try { require('fs').unlinkSync(pidFile); } catch {}
+      try { require('fs').unlinkSync(portFile); } catch {}
+      this._proxyPort = null;
+      this._proxySpawnAttempted = false;
+      this._debug('Proxy daemon killed.');
+    } catch (e) {
+      this._debug(`Proxy kill failed: ${e.message}`);
+    }
+  }
+
   _renderProxyTab() {
     const w = this._widgets;
     if (!w.proxyBox || w.proxyBox.hidden) return;
@@ -9600,6 +9821,12 @@ class ConsoleTUI {
       ctrl += _stat('Size', `~${_fmtNum(sp.estTokens)} tok`) + '\n';
       ctrl += _stat('Model', sp.model || '?') + '\n';
       ctrl += _stat('Messages', `${sp.messageCount || 0}`) + '\n';
+      // Custom prompt indicator + edit hint
+      if (this._proxyCustomSysPrompt?.hasCustom) {
+        ctrl += ` {#e056a0-fg}★ Custom Active{/#e056a0-fg} {#6c6c80-fg}(P=edit){/#6c6c80-fg}\n`;
+      } else {
+        ctrl += ` {#6c6c80-fg}(P) Customize Sys Prompt{/#6c6c80-fg}\n`;
+      }
     }
 
     if (w.proxyControls) w.proxyControls.setContent(ctrl);
@@ -9638,58 +9865,619 @@ class ConsoleTUI {
     if (w.proxyStats) w.proxyStats.setContent(st);
 
     // ═══════════════════════════════════════════════════════════════
-    // TOP-RIGHT: Raw IN text (what Claude sends)
+    // TOP-RIGHT: Raw IN text — accumulated history (what Claude sends)
     // ═══════════════════════════════════════════════════════════════
     let inText = '';
-    if (preview?.original) {
-      const ts = preview.timestamp ? new Date(preview.timestamp).toLocaleTimeString() : '';
-      inText += `{#4a4a60-fg}${ts}{/#4a4a60-fg}\n`;
-      // Raw text — strip blessed tags only, show everything else as-is
-      inText += preview.original.replace(/\{[^}]*\}/g, '');
+    const previewHistory = this._proxyPreviewHistory;
+    if (previewHistory.length > 0) {
+      for (const entry of previewHistory) {
+        if (!entry?.original) continue;
+        const ts = entry.timestamp ? new Date(entry.timestamp).toLocaleTimeString() : '';
+        const saved = entry.savings ? ` {#42d77d-fg}-${_fmtNum(entry.savings)} chars{/#42d77d-fg}` : '';
+        inText += `{#5a5a80-fg}── ${ts}${saved} ──{/#5a5a80-fg}\n`;
+        // Truncate each entry to keep panel readable (first 2000 chars)
+        const rawContent = (entry.original || '').replace(/\{[^}]*\}/g, '');
+        inText += rawContent.slice(0, 2000) + (rawContent.length > 2000 ? '\n{#4a4a60-fg}... truncated{/#4a4a60-fg}' : '') + '\n\n';
+      }
     } else {
       inText += '{#4a4a60-fg}waiting for traffic...{/#4a4a60-fg}';
     }
 
+    // Smart scroll: only update content when changed, only auto-scroll if user hasn't scrolled up
     if (w.proxyIn) {
-      w.proxyIn.setContent(inText);
-      w.proxyIn.setScrollPerc(100);
+      const inHash = crypto.createHash('md5').update(inText).digest('hex').slice(0, 12);
+      if (inHash !== this._proxyLastInHash) {
+        this._proxyLastInHash = inHash;
+        w.proxyIn.setContent(inText);
+        if (!this._proxyUserScrolledIn) {
+          w.proxyIn.setScrollPerc(100);
+        }
+        this._proxyUserScrolledIn = false; // reset for next new-content cycle
+      }
     }
 
     // ═══════════════════════════════════════════════════════════════
-    // BOTTOM-RIGHT: Translation samples + compacted output
+    // BOTTOM-RIGHT: Compacted OUT — accumulated history
     // ═══════════════════════════════════════════════════════════════
     let outText = '';
-    if (preview?.samples && preview.samples.length > 0) {
-      // Show translation before→after samples prominently
-      const ts = preview.timestamp ? new Date(preview.timestamp).toLocaleTimeString() : '';
-      const saved = preview.savings ? ` {#42d77d-fg}-${_fmtNum(preview.savings)} chars{/#42d77d-fg}` : '';
-      outText += `{#4a4a60-fg}${ts}{/#4a4a60-fg}${saved} {#a55eea-fg}${preview.samples.length} blocks translated{/#a55eea-fg}\n`;
-      for (const s of preview.samples.slice(0, 8)) {
-        const before = (s.before || '').slice(0, 60).replace(/\{[^}]*\}/g, '');
-        const after = (s.after || '').slice(0, 60).replace(/\{[^}]*\}/g, '');
-        outText += `{#ff4757-fg}EN:{/#ff4757-fg} ${before}${s.before?.length > 60 ? '…' : ''}\n`;
-        outText += `{#42d77d-fg}→ {/#42d77d-fg} ${after}${s.after?.length > 60 ? '…' : ''}\n`;
-      }
-      if (preview.samples.length > 8) {
-        outText += `{#4a4a60-fg}... +${preview.samples.length - 8} more{/#4a4a60-fg}\n`;
-      }
-    } else if (preview?.optimized) {
-      const ts = preview.timestamp ? new Date(preview.timestamp).toLocaleTimeString() : '';
-      const saved = preview.savings ? ` {#42d77d-fg}-${_fmtNum(preview.savings)} chars{/#42d77d-fg}` : '';
-      outText += `{#4a4a60-fg}${ts}{/#4a4a60-fg}${saved}\n`;
-      outText += preview.optimized.replace(/\{[^}]*\}/g, '');
+    if (previewHistory.length > 0) {
+      for (const entry of previewHistory) {
+        const ts = entry.timestamp ? new Date(entry.timestamp).toLocaleTimeString() : '';
+        const saved = entry.savings ? ` {#42d77d-fg}-${_fmtNum(entry.savings)} chars{/#42d77d-fg}` : '';
+        // Show translation samples if available
+        if (entry.samples && entry.samples.length > 0) {
+          outText += `{#5a5a80-fg}── ${ts}${saved} {#a55eea-fg}${entry.samples.length} blocks{/#a55eea-fg} ──{/#5a5a80-fg}\n`;
+          for (const s of entry.samples.slice(0, 4)) {
+            const before = (s.before || '').slice(0, 60).replace(/\{[^}]*\}/g, '');
+            const after = (s.after || '').slice(0, 60).replace(/\{[^}]*\}/g, '');
+            outText += `{#ff4757-fg}EN:{/#ff4757-fg} ${before}${s.before?.length > 60 ? '…' : ''}\n`;
+            outText += `{#42d77d-fg}→ {/#42d77d-fg} ${after}${s.after?.length > 60 ? '…' : ''}\n`;
+          }
+          if (entry.samples.length > 4) outText += `{#4a4a60-fg}  +${entry.samples.length - 4} more{/#4a4a60-fg}\n`;
+        } else if (entry.optimized) {
+          outText += `{#5a5a80-fg}── ${ts}${saved} ──{/#5a5a80-fg}\n`;
+          const optContent = (entry.optimized || '').replace(/\{[^}]*\}/g, '');
+          outText += optContent.slice(0, 2000) + (optContent.length > 2000 ? '\n{#4a4a60-fg}... truncated{/#4a4a60-fg}' : '') + '\n';
+        }
+        outText += '\n';
+      }
     } else {
       outText += '{#4a4a60-fg}waiting for traffic...{/#4a4a60-fg}';
     }
 
+    // Smart scroll: only update content when changed, only auto-scroll if user hasn't scrolled up
     if (w.proxyOut) {
-      w.proxyOut.setContent(outText);
-      w.proxyOut.setScrollPerc(100);
+      const outHash = crypto.createHash('md5').update(outText).digest('hex').slice(0, 12);
+      if (outHash !== this._proxyLastOutHash) {
+        this._proxyLastOutHash = outHash;
+        w.proxyOut.setContent(outText);
+        if (!this._proxyUserScrolledOut) {
+          w.proxyOut.setScrollPerc(100);
+        }
+        this._proxyUserScrolledOut = false;
+      }
     }
 
     this._safeRender();
   }
 
+  async _showCustomSysPromptModal() {
+    this._editorActive = true;
+    const blessed = this._blessed;
+    const screen = this._screen;
+    if (!blessed || !screen) return;
+
+    // Fetch current state from proxy
+    const data = await this._proxyHttpGet('/custom-system-prompt');
+    if (!data) {
+      this._updateStatusBar('{red-fg}✗ Cannot reach proxy{/red-fg}');
+      return;
+    }
+
+    const initialText = data.customPrompt || data.ogPrompt || '';
+    if (!initialText) {
+      this._updateStatusBar('{yellow-fg}No system prompt captured yet — send a request first{/yellow-fg}');
+      return;
+    }
+
+    const ogHash = data.ogHash;
+    const self = this;
+
+    // ── Editor State ──
+    const E = {
+      lines: initialText.split('\n'),
+      row: 0, col: 0,           // cursor position
+      scrollY: 0,
+      selAnchor: null,           // { row, col } — where selection started
+      selEnd: null,              // { row, col } — where selection ends
+      clipboard: '',
+      lastClickTime: 0,
+      clickCount: 0,
+      dirty: false,
+      dragging: false,          // mouse drag in progress
+    };
+
+    // ── System clipboard helpers ──
+    const { execSync: _execSync } = require('child_process');
+    const _clipEnv = { ...process.env, DISPLAY: process.env.DISPLAY || ':1' };
+    function _copyToSystemClipboard(text) {
+      // OSC 52 — works in some terminals (iTerm2, kitty, alacritty)
+      const b64 = Buffer.from(text).toString('base64');
+      process.stdout.write(`\x1b]52;c;${b64}\x07`);
+      // xclip/xsel with DISPLAY for VNC environments
+      try {
+        const tool = _execSync('command -v xclip >/dev/null 2>&1 && echo xclip || (command -v xsel >/dev/null 2>&1 && echo xsel)', { encoding: 'utf8', env: _clipEnv }).trim();
+        if (tool === 'xclip') _execSync('xclip -selection clipboard', { input: text, timeout: 2000, env: _clipEnv });
+        else if (tool === 'xsel') _execSync('xsel --clipboard --input', { input: text, timeout: 2000, env: _clipEnv });
+      } catch {}
+    }
+    function _readSystemClipboard() {
+      try {
+        return _execSync('xclip -selection clipboard -o 2>/dev/null || xsel --clipboard --output 2>/dev/null', { encoding: 'utf8', timeout: 2000, env: _clipEnv });
+      } catch { return null; }
+    }
+
+    // ── Helpers ──
+    const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+    // Ensure E.col never exceeds current line length
+    function clampCursor() {
+      E.row = clamp(E.row, 0, E.lines.length - 1);
+      E.col = clamp(E.col, 0, E.lines[E.row].length);
+    }
+
+    function getText() {
+      return E.lines.join('\n');
+    }
+
+    function hasSelection() {
+      return E.selAnchor !== null && E.selEnd !== null &&
+        (E.selAnchor.row !== E.selEnd.row || E.selAnchor.col !== E.selEnd.col);
+    }
+
+    // Normalized selection: start <= end
+    function getSelRange() {
+      if (!hasSelection()) return null;
+      const a = E.selAnchor, b = E.selEnd;
+      const before = (a.row < b.row) || (a.row === b.row && a.col <= b.col);
+      return before ? { start: a, end: b } : { start: b, end: a };
+    }
+
+    function clearSel() { E.selAnchor = null; E.selEnd = null; }
+
+    function getSelectedText() {
+      const r = getSelRange();
+      if (!r) return '';
+      if (r.start.row === r.end.row) {
+        return E.lines[r.start.row].slice(r.start.col, r.end.col);
+      }
+      let t = E.lines[r.start.row].slice(r.start.col) + '\n';
+      for (let i = r.start.row + 1; i < r.end.row; i++) t += E.lines[i] + '\n';
+      t += E.lines[r.end.row].slice(0, r.end.col);
+      return t;
+    }
+
+    function deleteSelection() {
+      const r = getSelRange();
+      if (!r) return;
+      const before = E.lines[r.start.row].slice(0, r.start.col);
+      const after = E.lines[r.end.row].slice(r.end.col);
+      E.lines.splice(r.start.row, r.end.row - r.start.row + 1, before + after);
+      E.row = r.start.row; E.col = r.start.col;
+      clearSel();
+      E.dirty = true;
+    }
+
+    function insertTextAt(text) {
+      if (hasSelection()) deleteSelection();
+      const before = E.lines[E.row].slice(0, E.col);
+      const after = E.lines[E.row].slice(E.col);
+      const insertLines = text.split('\n');
+      if (insertLines.length === 1) {
+        E.lines[E.row] = before + insertLines[0] + after;
+        E.col += insertLines[0].length;
+      } else {
+        E.lines[E.row] = before + insertLines[0];
+        for (let i = 1; i < insertLines.length - 1; i++) {
+          E.lines.splice(E.row + i, 0, insertLines[i]);
+        }
+        const lastLine = insertLines[insertLines.length - 1];
+        E.lines.splice(E.row + insertLines.length - 1, 0, lastLine + after);
+        E.row += insertLines.length - 1;
+        E.col = lastLine.length;
+      }
+      E.dirty = true;
+    }
+
+    function isInSel(row, col) {
+      const r = getSelRange();
+      if (!r) return false;
+      if (row < r.start.row || row > r.end.row) return false;
+      if (row === r.start.row && col < r.start.col) return false;
+      if (row === r.end.row && col >= r.end.col) return false;
+      if (row === r.start.row && row === r.end.row) return col >= r.start.col && col < r.end.col;
+      if (row === r.start.row) return col >= r.start.col;
+      if (row === r.end.row) return col < r.end.col;
+      return true;
+    }
+
+    function selectWord(row, col) {
+      const line = E.lines[row] || '';
+      if (col >= line.length) { E.selAnchor = { row, col: 0 }; E.selEnd = { row, col: line.length }; return; }
+      let start = col, end = col;
+      const isWordChar = c => /\w/.test(c);
+      const charType = isWordChar(line[col]);
+      while (start > 0 && isWordChar(line[start - 1]) === charType) start--;
+      while (end < line.length && isWordChar(line[end]) === charType) end++;
+      E.selAnchor = { row, col: start };
+      E.selEnd = { row, col: end };
+      E.col = end;
+    }
+
+    function selectLine(row) {
+      E.selAnchor = { row, col: 0 };
+      E.selEnd = { row, col: E.lines[row].length };
+      E.col = E.lines[row].length;
+    }
+
+    // ── Escape blessed tags in content ──
+    function esc(ch) {
+      if (ch === '{') return '{open}';
+      if (ch === '}') return '{close}';
+      return ch;
+    }
+
+    function escStr(s) {
+      return s.replace(/[{}]/g, c => c === '{' ? '{open}' : '{close}');
+    }
+
+    // ── Render ──
+    // Build visual rows from logical lines with soft word wrap.
+    // Returns array of { logRow, colStart, text } — one entry per visual row.
+    function buildVisualRows(visW) {
+      const vRows = [];
+      for (let i = 0; i < E.lines.length; i++) {
+        const line = E.lines[i];
+        if (line.length === 0) {
+          vRows.push({ logRow: i, colStart: 0, text: '' });
+        } else {
+          for (let off = 0; off < line.length; off += visW) {
+            vRows.push({ logRow: i, colStart: off, text: line.slice(off, off + visW) });
+          }
+        }
+      }
+      return vRows;
+    }
+
+    // Find visual row index where cursor lives
+    function cursorVisRow(vRows) {
+      for (let v = 0; v < vRows.length; v++) {
+        const vr = vRows[v];
+        if (vr.logRow === E.row && E.col >= vr.colStart && E.col < vr.colStart + Math.max(vr.text.length, 1)) return v;
+        // Cursor at end-of-line on last wrap segment
+        if (vr.logRow === E.row && E.col === vr.colStart + vr.text.length) {
+          const next = vRows[v + 1];
+          if (!next || next.logRow !== E.row) return v; // last segment of this line
+        }
+      }
+      return vRows.length - 1;
+    }
+
+    function render() {
+      clampCursor();
+      const visH = editorBox.height - 2;
+      const visW = editorBox.width - 2;
+      if (visW < 2) return;
+
+      const vRows = buildVisualRows(visW);
+      const cVRow = cursorVisRow(vRows);
+
+      // Scroll to keep cursor visual row visible
+      if (cVRow < E.scrollY) E.scrollY = cVRow;
+      if (cVRow >= E.scrollY + visH) E.scrollY = cVRow - visH + 1;
+      if (E.scrollY < 0) E.scrollY = 0;
+
+      let out = '';
+      for (let v = E.scrollY; v < Math.min(vRows.length, E.scrollY + visH); v++) {
+        const vr = vRows[v];
+        let rendered = '';
+        for (let j = 0; j < vr.text.length; j++) {
+          const logCol = vr.colStart + j;
+          const ch = esc(vr.text[j]);
+          if (vr.logRow === E.row && logCol === E.col) {
+            rendered += `{inverse}${ch}{/inverse}`;
+          } else if (isInSel(vr.logRow, logCol)) {
+            rendered += `{blue-bg}{white-fg}${ch}{/white-fg}{/blue-bg}`;
+          } else {
+            rendered += ch;
+          }
+        }
+        // Cursor at end of this visual segment
+        if (vr.logRow === E.row && E.col === vr.colStart + vr.text.length) {
+          const next = vRows[v + 1];
+          if (!next || next.logRow !== E.row) {
+            rendered += '{inverse} {/inverse}';
+          }
+        }
+        out += rendered + '\n';
+      }
+
+      // Status line at bottom
+      const charCount = getText().length;
+      const ogLen = data.ogPrompt?.length || 0;
+      const diff = ogLen - charCount;
+      const diffStr = diff > 0 ? `{#42d77d-fg}-${diff.toLocaleString()}{/#42d77d-fg}` : `{#ff4757-fg}+${Math.abs(diff).toLocaleString()}{/#ff4757-fg}`;
+
+      header.setContent(
+        ` {#6c6c80-fg}OG:{/#6c6c80-fg} ${ogLen.toLocaleString()}  `
+        + `{#6c6c80-fg}Now:{/#6c6c80-fg} ${charCount.toLocaleString()} (${diffStr})  `
+        + `{#6c6c80-fg}Ln:{/#6c6c80-fg} ${E.row + 1}/${E.lines.length}  `
+        + `{#6c6c80-fg}Col:{/#6c6c80-fg} ${E.col + 1}`
+        + (E.dirty ? '  {#e056a0-fg}●modified{/#e056a0-fg}' : '') + '\n'
+        + ` {#42d77d-fg}Ctrl+S{/#42d77d-fg}=Save  {#ff4757-fg}Ctrl+R{/#ff4757-fg}=Reset  {yellow-fg}Esc{/yellow-fg}=Cancel  `
+        + `{#6c6c80-fg}Ctrl+A{/#6c6c80-fg}=SelAll  {#6c6c80-fg}Ctrl+C/X/V{/#6c6c80-fg}=Clipboard`
+      );
+
+      editorBox.setContent(out);
+      // Prevent blessed from resetting scroll position on setContent
+      editorBox.childBase = 0;
+      editorBox.childOffset = 0;
+      self._safeRender();
+    }
+
+    // ── Create UI ──
+    const overlay = blessed.box({
+      parent: screen,
+      top: 'center', left: 'center',
+      width: '90%', height: '90%',
+      grabKeys: true,  // prevent key leaking to elements behind overlay
+      border: { type: 'line' },
+      style: { fg: '#c0c0d0', bg: '#0a0a15', border: { fg: '#e056a0' }, label: { fg: '#e056a0' } },
+      tags: true,
+      label: data.hasCustom ? ' ★ Edit Custom System Prompt ' : ' Customize System Prompt ',
+    });
+
+    const header = blessed.box({
+      parent: overlay,
+      top: 0, left: 1, right: 1, height: 3,
+      style: { fg: '#a0a0b0', bg: '#0a0a15' },
+      tags: true,
+    });
+
+    const editorBox = blessed.box({
+      parent: overlay,
+      top: 3, left: 1, right: 1, bottom: 0,
+      border: { type: 'line' },
+      style: { fg: '#c0c0d0', bg: '#0f0f1a', border: { fg: '#3a3a50' } },
+      scrollable: false, // we handle scrolling manually
+      mouse: true,
+      keys: true,
+      tags: true,
+      keyable: true,
+    });
+
+    let _destroyed = false;
+    // Block named key events (screen.key() bindings like 'key q', 'key tab') from reaching
+    // dashboard while editor is open. We keep 'keypress' flowing so editorBox still gets input.
+    const _origEmit = screen.emit.bind(screen);
+    screen.emit = function(event, ...args) {
+      if (typeof event === 'string' && event.startsWith('key ') && event !== 'keypress') return false;
+      return _origEmit(event, ...args);
+    };
+
+    const cleanup = () => {
+      if (_destroyed) return;
+      _destroyed = true;
+      screen.emit = _origEmit; // restore original emit so dashboard keys work again
+      editorBox.removeAllListeners();
+      overlay.removeAllListeners();
+      overlay.detach();
+      self._editorActive = false;
+      self._safeRender();
+      process.nextTick(() => overlay.destroy());
+    };
+
+    // ── Mouse Handling (click, drag-select) ──
+    function mouseToPos(mouse) {
+      const localY = mouse.y - (editorBox.atop || 0) - 1;
+      const localX = mouse.x - (editorBox.aleft || 0) - 1;
+      const visW = editorBox.width - 2;
+      const vRows = buildVisualRows(visW);
+      const vIdx = clamp(localY + E.scrollY, 0, vRows.length - 1);
+      const vr = vRows[vIdx];
+      const col = clamp(vr.colStart + localX, 0, E.lines[vr.logRow].length);
+      return { row: vr.logRow, col };
+    }
+
+    editorBox.on('mousedown', (mouse) => {
+      const { row, col } = mouseToPos(mouse);
+      const now = Date.now();
+      if (now - E.lastClickTime < 350 && E.clickCount < 3) {
+        E.clickCount++;
+      } else {
+        E.clickCount = 1;
+      }
+      E.lastClickTime = now;
+
+      if (E.clickCount === 3) {
+        selectLine(row);
+        E.dragging = false;
+      } else if (E.clickCount === 2) {
+        selectWord(row, col);
+        E.dragging = false;
+      } else {
+        E.row = row; E.col = col;
+        clearSel();
+        E.dragging = true;
+      }
+      render();
+    });
+
+    editorBox.on('mousemove', (mouse) => {
+      if (!E.dragging) return;
+      const { row, col } = mouseToPos(mouse);
+      // Start selection from cursor if not already started
+      if (!hasSelection()) {
+        E.selAnchor = { row: E.row, col: E.col };
+      }
+      E.selEnd = { row, col };
+      E.row = row; E.col = col;
+      render();
+    });
+
+    editorBox.on('mouseup', () => {
+      E.dragging = false;
+    });
+
+    // Scroll wheel
+    editorBox.on('wheeldown', () => { E.scrollY = Math.min(E.scrollY + 3, Math.max(0, E.lines.length - 5)); render(); });
+    editorBox.on('wheelup', () => { E.scrollY = Math.max(0, E.scrollY - 3); render(); });
+
+    // ── Keyboard Handling ──
+    editorBox.on('keypress', (ch, key) => {
+      if (!key) return;
+      const ctrl = key.ctrl;
+      const shift = key.shift;
+      const name = key.name;
+
+      // ── Ctrl combos ──
+      if (ctrl && name === 's') {
+        const text = getText();
+        if (!text.trim()) { self._updateStatusBar('{red-fg}Cannot save empty prompt{/red-fg}'); return; }
+        self._proxyHttpPost('/custom-system-prompt', { prompt: text, ogHash }).then((res) => {
+          if (res?.ok) self._updateStatusBar(`{#42d77d-fg}✓ Custom prompt saved (${text.length} chars){/#42d77d-fg}`);
+          else self._updateStatusBar(`{red-fg}✗ Save failed: ${res?.error || 'unknown'}{/red-fg}`);
+          cleanup();
+        });
+        return;
+      }
+      if (ctrl && name === 'r') {
+        self._proxyHttpPost('/custom-system-prompt', { reset: true }).then((res) => {
+          if (res?.ok) self._updateStatusBar('{#42d77d-fg}✓ System prompt reset to original{/#42d77d-fg}');
+          cleanup();
+        });
+        return;
+      }
+      if (ctrl && name === 'a') { // Select All
+        E.selAnchor = { row: 0, col: 0 };
+        E.selEnd = { row: E.lines.length - 1, col: E.lines[E.lines.length - 1].length };
+        E.row = E.selEnd.row; E.col = E.selEnd.col;
+        render(); return;
+      }
+      if (ctrl && name === 'c') { // Copy
+        if (hasSelection()) {
+          E.clipboard = getSelectedText();
+          _copyToSystemClipboard(E.clipboard);
+        }
+        render(); return;
+      }
+      if (ctrl && name === 'x') { // Cut
+        if (hasSelection()) {
+          E.clipboard = getSelectedText();
+          _copyToSystemClipboard(E.clipboard);
+          deleteSelection();
+        }
+        render(); return;
+      }
+      if (ctrl && name === 'v') { // Paste
+        // Try system clipboard first, fallback to internal
+        const sysCb = _readSystemClipboard();
+        if (sysCb) { E.clipboard = sysCb; insertTextAt(sysCb); }
+        else if (E.clipboard) insertTextAt(E.clipboard);
+        render(); return;
+      }
+
+      // ── Escape ──
+      if (name === 'escape') {
+        // Prevent event propagation before cleanup
+        editorBox.removeAllListeners('keypress');
+        cleanup();
+        return;
+      }
+
+      // ── Arrow keys (with shift-select) ──
+      if (name === 'left' || name === 'right' || name === 'up' || name === 'down'
+        || name === 'home' || name === 'end' || name === 'pageup' || name === 'pagedown') {
+        const prevRow = E.row, prevCol = E.col;
+
+        if (name === 'left') {
+          if (E.col > 0) E.col--;
+          else if (E.row > 0) { E.row--; E.col = E.lines[E.row].length; }
+        } else if (name === 'right') {
+          if (E.col < E.lines[E.row].length) E.col++;
+          else if (E.row < E.lines.length - 1) { E.row++; E.col = 0; }
+        } else if (name === 'up') {
+          if (E.row > 0) { E.row--; E.col = Math.min(E.col, E.lines[E.row].length); }
+        } else if (name === 'down') {
+          if (E.row < E.lines.length - 1) { E.row++; E.col = Math.min(E.col, E.lines[E.row].length); }
+        } else if (name === 'home') {
+          E.col = 0;
+        } else if (name === 'end') {
+          E.col = E.lines[E.row].length;
+        } else if (name === 'pageup') {
+          const visH = editorBox.height - 2;
+          E.row = Math.max(0, E.row - visH);
+          E.col = Math.min(E.col, E.lines[E.row].length);
+        } else if (name === 'pagedown') {
+          const visH = editorBox.height - 2;
+          E.row = Math.min(E.lines.length - 1, E.row + visH);
+          E.col = Math.min(E.col, E.lines[E.row].length);
+        }
+
+        if (shift) {
+          if (!E.selAnchor) E.selAnchor = { row: prevRow, col: prevCol };
+          E.selEnd = { row: E.row, col: E.col };
+        } else {
+          clearSel();
+        }
+        render(); return;
+      }
+
+      // ── Backspace ──
+      if (name === 'backspace') {
+        if (hasSelection()) { deleteSelection(); }
+        else if (E.col > 0) {
+          E.lines[E.row] = E.lines[E.row].slice(0, E.col - 1) + E.lines[E.row].slice(E.col);
+          E.col--;
+          E.dirty = true;
+        } else if (E.row > 0) {
+          E.col = E.lines[E.row - 1].length;
+          E.lines[E.row - 1] += E.lines[E.row];
+          E.lines.splice(E.row, 1);
+          E.row--;
+          E.dirty = true;
+        }
+        render(); return;
+      }
+
+      // ── Delete ──
+      if (name === 'delete') {
+        if (hasSelection()) { deleteSelection(); }
+        else if (E.col < E.lines[E.row].length) {
+          E.lines[E.row] = E.lines[E.row].slice(0, E.col) + E.lines[E.row].slice(E.col + 1);
+          E.dirty = true;
+        } else if (E.row < E.lines.length - 1) {
+          E.lines[E.row] += E.lines[E.row + 1];
+          E.lines.splice(E.row + 1, 1);
+          E.dirty = true;
+        }
+        render(); return;
+      }
+
+      // ── Enter ──
+      if (name === 'enter' || name === 'return') {
+        if (hasSelection()) deleteSelection();
+        const after = E.lines[E.row].slice(E.col);
+        E.lines[E.row] = E.lines[E.row].slice(0, E.col);
+        E.lines.splice(E.row + 1, 0, after);
+        E.row++; E.col = 0;
+        E.dirty = true;
+        render(); return;
+      }
+
+      // ── Tab ──
+      if (name === 'tab') {
+        if (hasSelection()) deleteSelection();
+        insertTextAt('  ');
+        render(); return;
+      }
+
+      // ── Printable character ──
+      if (ch && ch.length === 1 && !ctrl && !key.meta) {
+        if (hasSelection()) deleteSelection();
+        E.lines[E.row] = E.lines[E.row].slice(0, E.col) + ch + E.lines[E.row].slice(E.col);
+        E.col++;
+        E.dirty = true;
+        render(); return;
+      }
+    });
+
+    // Prevent blessed's built-in key/scroll handling from moving content
+    editorBox.scrollable = false;
+    editorBox.focus();
+    screen.on('keypress', _blockKeys);
+    render();
+  }
+
   _adjustProxySlider(direction) {
     const def = this._proxySliderDefs[this._proxySliderIdx];
     if (!def || !this._proxyConfig) return;