specmem-hardwicksoftware 3.7.31 → 3.7.33

package/dist/mcp/compactionProxy.js

@@ -15,7 +15,7 @@
  * @website https://justcalljon.pro
  */
 
-import { createServer, get as httpGet } from 'http';
+import { createServer, get as httpGet, request as httpRequest } from 'http';
 import { request as httpsRequest } from 'https';
 import { appendFileSync, writeFileSync, readFileSync, mkdirSync, existsSync, copyFileSync, unlinkSync } from 'fs';
 import { createConnection } from 'net';
@@ -58,16 +58,58 @@ const TOOL_USE_INPUT_PREVIEW_CHARS = 100;
 
 // Old-message stripping config — applied to ALL requests (not just compaction)
 // Only strips tool_results larger than this threshold in messages outside the recent window
-const OLD_STRIP_THRESHOLD = 400;         // chars — only strip results bigger than this
+const OLD_STRIP_THRESHOLD = 100;         // chars — only strip results bigger than this
 const OLD_STRIP_PREVIEW_CHARS = 200;     // chars — keep this much of the original
 
 // Live neural MT compression config
-const TRANSLATE_SOCKET = process.env.SPECMEM_TRANSLATE_SOCKET ||
+const _TRANSLATE_SOCKET_FALLBACK = process.env.SPECMEM_TRANSLATE_SOCKET ||
   join(process.env.SPECMEM_PROJECT_PATH || process.cwd(), 'specmem', 'run', 'translate.sock');
 const PRESERVE_RECENT_MESSAGES = 3;
-const MIN_TRANSLATE_LENGTH = 50;
+const MIN_TRANSLATE_LENGTH = 0;  // No minimum — compress everything
 const DONT_COMPRESS_FLAG = 'DONT_COMPRESS';
 
+// ============================================================================
+// Multi-Project Registry — tracks all registered projects for resource sharing
+// ============================================================================
+
+const projectRegistry = new Map(); // keyed by projectPath → { projectPath, pid, registeredAt, lastSeen }
+
+// Auto-register the spawning project so daemon always has at least one
+const _foundingProjectPath = process.env.SPECMEM_PROJECT_PATH || null;
+if (_foundingProjectPath) {
+  projectRegistry.set(_foundingProjectPath, {
+    projectPath: _foundingProjectPath,
+    pid: process.ppid || 0,
+    registeredAt: Date.now(),
+    lastSeen: Date.now(),
+  });
+}
+
+/**
+ * Resolve translate socket dynamically across all registered projects.
+ * Iterates registry sorted by lastSeen desc, returns first socket that exists.
+ * Fallback: SPECMEM_TRANSLATE_SOCKET env var, then null.
+ */
+function resolveTranslateSocket() {
+  // Try registered projects, most recently seen first
+  const entries = [...projectRegistry.values()].sort((a, b) => b.lastSeen - a.lastSeen);
+  for (const entry of entries) {
+    const sockPath = join(entry.projectPath, 'specmem', 'run', 'translate.sock');
+    if (existsSync(sockPath)) return sockPath;
+  }
+  // Fallback to env var / founding project socket
+  if (existsSync(_TRANSLATE_SOCKET_FALLBACK)) return _TRANSLATE_SOCKET_FALLBACK;
+  return null;
+}
+
+/**
+ * Invalidate TM and synonym caches — called on registry changes.
+ */
+function _invalidateProjectCaches() {
+  _tmCache = null;
+  _synonyms = null;
+}
+
 // Preview ring buffer — stores last 5 compressed requests for TUI display
 const PREVIEW_BUFFER_SIZE = 5;
 const recentRequests = [];  // { original, optimized, timestamp, type, savings }
@@ -160,6 +202,7 @@ let liveConfig = {
   TRANSLATE_ENABLED: true,   // toggle MT translation (requires translate.sock)
   OLD_STRIP_ENABLED: true,   // toggle old tool_result stripping
   SYSTEM_PROMPT_COMPRESS: true, // toggle system prompt steno+translate compression
+  SYSTEM_REMINDER_STRIPPING: true,  // toggle <system-reminder> stripping (keeps first, strips rest)
 };
 
 // Stats
@@ -171,6 +214,7 @@ const stats = {
   tokensStripped: 0,
   bytesStripped: 0,
   liveCharsCompressed: 0,
+  systemRemindersStripped: 0,
   liveBlocksCompressed: 0,
   zhVerified: 0,        // Chinese translations that passed loop-back verification
   zhRejected: 0,        // Chinese translations rejected (steno fallback)
@@ -200,18 +244,53 @@ const TM_MAX_ENTRIES = 10000;
 let _tmCache = null;    // { hash: { en, zh, sim, ts } }
 let _synonyms = null;   // { word: Set<synonym> } — learned from failed verifications
 
+/**
+ * Get all TM file paths from registered projects.
+ */
+function _getAllTMPaths() {
+  const paths = [];
+  for (const entry of projectRegistry.values()) {
+    paths.push(join(entry.projectPath, 'specmem', 'run', 'translation-memory.json'));
+  }
+  // Always include founding project path as fallback
+  if (!paths.includes(TM_FILE)) paths.push(TM_FILE);
+  return paths;
+}
+
+/**
+ * Get all synonyms file paths from registered projects.
+ */
+function _getAllSynonymPaths() {
+  const paths = [];
+  for (const entry of projectRegistry.values()) {
+    paths.push(join(entry.projectPath, 'specmem', 'run', 'learned-synonyms.json'));
+  }
+  if (!paths.includes(SYNONYMS_FILE)) paths.push(SYNONYMS_FILE);
+  return paths;
+}
+
 function _tmHash(text) {
   return createHash('md5').update(text.toLowerCase().trim()).digest('hex').slice(0, 16);
 }
 
 function _loadTM() {
   if (_tmCache) return _tmCache;
-  try {
-    if (existsSync(TM_FILE)) {
-      _tmCache = JSON.parse(readFileSync(TM_FILE, 'utf8'));
-    }
-  } catch { /* corrupt file, start fresh */ }
-  if (!_tmCache || typeof _tmCache !== 'object') _tmCache = {};
+  _tmCache = {};
+  // Merge TM entries from all registered projects (later timestamp wins)
+  for (const tmPath of _getAllTMPaths()) {
+    try {
+      if (existsSync(tmPath)) {
+        const entries = JSON.parse(readFileSync(tmPath, 'utf8'));
+        if (entries && typeof entries === 'object') {
+          for (const [hash, entry] of Object.entries(entries)) {
+            if (!_tmCache[hash] || (entry.ts || 0) > (_tmCache[hash].ts || 0)) {
+              _tmCache[hash] = entry;
+            }
+          }
+        }
+      }
+    } catch { /* corrupt file, skip */ }
+  }
   return _tmCache;
 }
 
@@ -225,7 +304,14 @@ function _saveTM() {
       const toRemove = sorted.slice(0, keys.length - TM_MAX_ENTRIES);
       for (const k of toRemove) delete tm[k];
     }
-    writeFileSync(TM_FILE, JSON.stringify(tm), 'utf8');
+    const data = JSON.stringify(tm);
+    // Fan-out write to ALL registered projects
+    for (const tmPath of _getAllTMPaths()) {
+      try {
+        mkdirSync(dirname(tmPath), { recursive: true });
+        writeFileSync(tmPath, data, 'utf8');
+      } catch { /* skip unreachable paths */ }
+    }
   } catch (e) { log('warn', `TM save failed: ${e.message}`); }
 }
 
@@ -253,29 +339,41 @@ let _tmSaveTimer = null;
 // e.g., MT says "rebuild" but original had "refactor" — these are equivalent
 function _loadSynonyms() {
   if (_synonyms) return _synonyms;
-  // Try project path first, then fall back to package seed file
-  const seedPaths = [
-    SYNONYMS_FILE,
+  _synonyms = {};
+  // Merge synonyms from all registered projects + package seed
+  const allPaths = [
+    ..._getAllSynonymPaths(),
     join(fileURLToPath(import.meta.url), '..', '..', '..', 'specmem', 'run', 'learned-synonyms.json'),
   ];
-  for (const synPath of seedPaths) {
+  let loadedAny = false;
+  for (const synPath of allPaths) {
     try {
       if (existsSync(synPath)) {
         const raw = JSON.parse(readFileSync(synPath, 'utf8'));
-        _synonyms = {};
         for (const [word, syns] of Object.entries(raw)) {
-          _synonyms[word] = new Set(syns);
+          if (!_synonyms[word]) _synonyms[word] = new Set();
+          const synList = Array.isArray(syns) ? syns : [...syns];
+          for (const s of synList) _synonyms[word].add(s);
         }
-        // If loaded from package seed and project file doesn't exist, copy seed to project
-        if (synPath !== SYNONYMS_FILE && _synonyms && Object.keys(_synonyms).length > 0) {
-          try { mkdirSync(dirname(SYNONYMS_FILE), { recursive: true }); } catch {}
-          try { copyFileSync(synPath, SYNONYMS_FILE); } catch {}
-        }
-        break;
+        loadedAny = true;
+      }
+    } catch { /* skip corrupt */ }
+  }
+  // If loaded from package seed and no project files exist, seed all projects
+  if (loadedAny && Object.keys(_synonyms).length > 0) {
+    for (const synPath of _getAllSynonymPaths()) {
+      if (!existsSync(synPath)) {
+        try { mkdirSync(dirname(synPath), { recursive: true }); } catch {}
+        try {
+          const serializable = {};
+          for (const [word, set] of Object.entries(_synonyms)) {
+            serializable[word] = [...set];
+          }
+          writeFileSync(synPath, JSON.stringify(serializable), 'utf8');
+        } catch {}
       }
-    } catch { /* try next */ }
+    }
   }
-  if (!_synonyms) _synonyms = {};
   return _synonyms;
 }
 
@@ -286,7 +384,14 @@ function _saveSynonyms() {
     for (const [word, set] of Object.entries(syns)) {
       serializable[word] = [...set];
     }
-    writeFileSync(SYNONYMS_FILE, JSON.stringify(serializable), 'utf8');
+    const data = JSON.stringify(serializable);
+    // Fan-out write to ALL registered projects
+    for (const synPath of _getAllSynonymPaths()) {
+      try {
+        mkdirSync(dirname(synPath), { recursive: true });
+        writeFileSync(synPath, data, 'utf8');
+      } catch { /* skip unreachable paths */ }
+    }
   } catch (e) { log('warn', `Synonyms save failed: ${e.message}`); }
 }
 
@@ -380,6 +485,23 @@ function isCompactionRequest(body) {
   return false;
 }
 
+/**
+ * Smart-strip Edit tool_use inputs to just - / + diff lines.
+ * Returns compact string or null if not an Edit block.
+ */
+function smartStripEdit(input) {
+  if (!input || !input.file_path || !input.old_string) return null;
+  const lines = [`Edit(${input.file_path})`];
+  // old_string → removed lines (prefix with -)
+  for (const l of input.old_string.split('\n')) lines.push(`- ${l}`);
+  // new_string → added lines (prefix with +)
+  if (input.new_string != null) {
+    for (const l of input.new_string.split('\n')) lines.push(`+ ${l}`);
+  }
+  if (input.replace_all) lines.push('(replace_all)');
+  return lines.join('\n');
+}
+
 function stripMessages(messages) {
   if (!Array.isArray(messages)) return { strippedMessages: messages, strippingStats: { toolResultsStripped: 0, toolUsesStripped: 0, charsRemoved: 0 } };
 
@@ -422,6 +544,22 @@ function stripMessages(messages) {
         const input = block.input;
         if (!input) return block;
 
+        // Smart diff stripping for Edit tool — keep only - / + lines
+        const editDiff = (block.name === 'Edit') ? smartStripEdit(input) : null;
+        if (editDiff) {
+          const inputStr = JSON.stringify(input);
+          charsRemoved += inputStr.length - editDiff.length;
+          toolUsesStripped++;
+          const stripped = {
+            type: 'tool_use',
+            id: block.id,
+            name: block.name,
+            input: { _stripped: editDiff }
+          };
+          if (block.cache_control) stripped.cache_control = block.cache_control;
+          return stripped;
+        }
+
         const inputStr = JSON.stringify(input);
         if (inputStr.length <= TOOL_USE_INPUT_PREVIEW_CHARS * 2) return block;
 
@@ -513,6 +651,16 @@ function stripOldToolResults(messages) {
         const input = block.input;
         if (!input) return block;
 
+        // Smart Edit stripping — keep only - / + diff lines
+        const editDiff = smartStripEdit(block);
+        if (editDiff) {
+          const origLen = JSON.stringify(input).length;
+          const newLen = JSON.stringify(editDiff.input).length;
+          charsRemoved += origLen - newLen;
+          toolResultsStripped++;
+          return editDiff;
+        }
+
         const inputStr = JSON.stringify(input);
         if (inputStr.length <= liveConfig.OLD_STRIP_THRESHOLD) return block;
 
@@ -533,6 +681,36 @@ function stripOldToolResults(messages) {
         return stripped;
       }
 
+      // Strip specmem hook injection text blocks from old messages
+      if (block.type === 'text' && typeof block.text === 'string') {
+        const txt = block.text;
+        const isHookOutput = txt.includes('[SM-找]') || txt.includes('[SM-碼]') ||
+          txt.includes('[SM-檔改]') || txt.includes('[SPECMEM-SESSION]') ||
+          txt.includes('⚠️壓縮:繁中') || txt.includes('[SM-搜]');
+        if (isHookOutput && txt.length > liveConfig.OLD_STRIP_THRESHOLD) {
+          const removed = txt.length - OLD_STRIP_PREVIEW_CHARS;
+          charsRemoved += removed;
+          toolResultsStripped++;
+          return {
+            ...block,
+            text: txt.slice(0, OLD_STRIP_PREVIEW_CHARS) + `...\n[HOOK-TRIMMED: ${txt.length} chars]`
+          };
+        }
+
+        // Strip old assistant text blocks — Claude's own output echoed back
+        // No point sending Claude its own words; keep first line as context anchor
+        if (msg.role === 'assistant' && txt.length > 120) {
+          const firstLine = txt.split('\n')[0].slice(0, 120);
+          const removed = txt.length - firstLine.length;
+          charsRemoved += removed;
+          toolResultsStripped++;
+          return {
+            ...block,
+            text: `${firstLine}...\n[ASST-ECHO-STRIPPED: ${txt.length} chars → ${firstLine.length}]`
+          };
+        }
+      }
+
       return block;
     });
 
@@ -542,6 +720,81 @@ function stripOldToolResults(messages) {
   return { messages: newMessages, strippingStats: { toolResultsStripped, charsRemoved } };
 }
 
+/**
+ * Strip <system-reminder> tags from messages.
+ * Keeps the FIRST system-reminder encountered (sets up style/context),
+ * strips all subsequent ones to save tokens.
+ *
+ * Returns { messages, remindersStripped, charsRemoved }.
+ */
+function stripSystemReminders(messages) {
+  if (!Array.isArray(messages)) return { messages, remindersStripped: 0, charsRemoved: 0 };
+  if (!liveConfig.SYSTEM_REMINDER_STRIPPING) return { messages, remindersStripped: 0, charsRemoved: 0 };
+
+  const SR_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+  let firstSeen = false;
+  let remindersStripped = 0;
+  let charsRemoved = 0;
+
+  const newMessages = messages.map(msg => {
+    if (!msg) return msg;
+
+    // Handle string content
+    if (typeof msg.content === 'string') {
+      const matches = msg.content.match(SR_RE);
+      if (!matches) return msg;
+
+      let newText = msg.content;
+      for (const match of matches) {
+        if (!firstSeen) {
+          firstSeen = true; // keep the very first one
+          continue;
+        }
+        newText = newText.replace(match, '');
+        charsRemoved += match.length;
+        remindersStripped++;
+      }
+      return { ...msg, content: newText.replace(/\n{3,}/g, '\n\n').trim() };
+    }
+
+    // Handle array content blocks
+    if (!Array.isArray(msg.content)) return msg;
+
+    const newContent = msg.content.map(block => {
+      if (block.type !== 'text' || typeof block.text !== 'string') return block;
+
+      const matches = block.text.match(SR_RE);
+      if (!matches) return block;
+
+      let newText = block.text;
+      for (const match of matches) {
+        if (!firstSeen) {
+          firstSeen = true; // keep the very first one
+          continue;
+        }
+        newText = newText.replace(match, '');
+        charsRemoved += match.length;
+        remindersStripped++;
+      }
+      const cleaned = newText.replace(/\n{3,}/g, '\n\n').trim();
+
+      // If block is now empty after stripping, remove it entirely
+      if (!cleaned) return null;
+
+      return { ...block, text: cleaned };
+    }).filter(Boolean);
+
+    // If all content blocks were stripped, keep a minimal marker
+    if (newContent.length === 0) {
+      return { ...msg, content: [{ type: 'text', text: '[context]' }] };
+    }
+
+    return { ...msg, content: newContent };
+  });
+
+  return { messages: newMessages, remindersStripped, charsRemoved };
+}
+
 // ============================================================================
 // Live Compression — Stenography + Neural MT with Loop-back Verification
 // ============================================================================
@@ -789,6 +1042,9 @@ async function compressMessagesLive(messages) {
 
         // Standalone text blocks (user/assistant conversational text) → steno only
         if (block.type === 'text' && typeof block.text === 'string') {
+          // Skip specmem hook injection text — already partially compressed Chinese, steno would garble
+          const _htxt = block.text;
+          if (_htxt.includes('[SM-') || _htxt.includes('[SPECMEM-SESSION]') || _htxt.includes('⚠️壓縮:繁中')) continue;
           if (looksLikeNaturalLanguage(block.text)) {
             originals.push(block.text);
             textLocations.push({ msgIdx: i, blockIdx: j, mtEligible: false });
@@ -829,15 +1085,60 @@ async function compressMessagesLive(messages) {
   let stenoOnlyCount = 0;
   let tmHits = 0;
 
-  const translateAvailable = liveConfig.TRANSLATE_ENABLED && existsSync(TRANSLATE_SOCKET);
+  const _resolvedSocket = resolveTranslateSocket();
+  const translateAvailable = liveConfig.TRANSLATE_ENABLED && !!_resolvedSocket;
+
+  // ── Pre-translation filter: detect "translation-hostile" content ──
+  // File paths, IDs, hashes, permissions, IPs, URLs, code identifiers, etc.
+  // These will ALWAYS fail backtranslation verification, so skip MT entirely.
+  const _PATH_RE = /(?:^|\s)[.~]?\/[\w./-]{3,}/;                    // /foo/bar.js, ./rel, ~/home
+  const _UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+  const _HEX_RE  = /\b[0-9a-f]{7,64}\b/i;                           // git hashes, hex IDs
+  const _PERM_RE = /[dl-][r-][w-][xsStT-][r-][w-][xsStT-][r-][w-][xsStT-]/; // drwxr-xr-x
+  const _IP_RE   = /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/;       // IPv4
+  const _URL_RE  = /https?:\/\/\S{6,}/;                              // URLs
+  const _PKG_RE  = /[\w@][\w./-]*@\d+\.\d+/;                        // pkg@1.2.3
+  const _CODE_ID = /\b[a-z][a-zA-Z0-9]{2,}\.[a-zA-Z]{1,4}\b/;      // file.ext patterns
+  const _CAMEL   = /\b[a-z]+[A-Z][a-zA-Z]+\b/;                      // camelCase identifiers
+  const _SNAKE   = /\b[a-z]+_[a-z_]+\b/;                             // snake_case identifiers
+
+  function isTranslationHostile(text) {
+    if (!text || text.length < 20) return true;  // too short to compress meaningfully
+    // Count how many "technical markers" appear
+    const markers = [_PATH_RE, _UUID_RE, _HEX_RE, _PERM_RE, _IP_RE, _URL_RE, _PKG_RE, _CODE_ID];
+    let hits = 0;
+    for (const re of markers) if (re.test(text)) hits++;
+    if (hits >= 3) return true;   // 3+ different marker types = definitely technical
+
+    // Check density: what fraction of words are code/path-like?
+    const words = text.split(/\s+/).filter(w => w.length > 1);
+    if (words.length === 0) return true;
+    let techWords = 0;
+    for (const w of words) {
+      if (_PATH_RE.test(w) || _HEX_RE.test(w) || _UUID_RE.test(w) ||
+          _PERM_RE.test(w) || _IP_RE.test(w) || _URL_RE.test(w) ||
+          _CAMEL.test(w) || _SNAKE.test(w) || _PKG_RE.test(w) ||
+          /^\d+$/.test(w) || /^[A-Z_]{3,}$/.test(w)) {
+        techWords++;
+      }
+    }
+    return (techWords / words.length) > 0.40;  // >40% technical tokens = skip MT
+  }
 
   // Step 1.5: Check Translation Memory cache first
   const needMT = [];     // indices that need neural MT (only mtEligible blocks)
+  let mtSkippedTech = 0;
   for (let i = 0; i < stenoTexts.length; i++) {
     // Only tool_result content is eligible for Chinese MT
     // User/assistant text stays steno-only to prevent Claude responding in Chinese
     if (!textLocations[i].mtEligible) continue;
 
+    // Skip translation-hostile content (file paths, IDs, code, etc.)
+    if (isTranslationHostile(stenoTexts[i])) {
+      mtSkippedTech++;
+      continue;  // stays steno-only — finalTexts[i] already has steno text
+    }
+
     const cached = tmLookup(stenoTexts[i]);
     if (cached && cached.length < stenoTexts[i].length) {
       finalTexts[i] = cached;
@@ -847,12 +1148,15 @@ async function compressMessagesLive(messages) {
       needMT.push(i);
     }
   }
+  if (mtSkippedTech > 0) {
+    log('info', `MT-SKIP: ${mtSkippedTech} blocks skipped (translation-hostile content)`);
+  }
 
   if (translateAvailable && needMT.length > 0) {
     try {
       // Step 2: Translate uncached steno English → Chinese (zt)
       const mtInputs = needMT.map(i => stenoTexts[i]);
-      const chineseTexts = await translateBatch(mtInputs, TRANSLATE_SOCKET, 'en', 'zh');
+      const chineseTexts = await translateBatch(mtInputs, _resolvedSocket, 'en', 'zh');
 
       // Filter: only verify texts that actually changed and got shorter
       const needVerify = [];
@@ -868,7 +1172,7 @@ async function compressMessagesLive(messages) {
 
       if (needVerify.length > 0) {
         // Step 3: Translate Chinese → English (loop-back)
-        const backTranslated = await translateBatch(needVerify, TRANSLATE_SOCKET, 'zh', 'en');
+        const backTranslated = await translateBatch(needVerify, _resolvedSocket, 'zh', 'en');
 
         // Step 4: Verify each — compare back-translated with original
         for (let v = 0; v < verifyIndices.length; v++) {
@@ -1011,13 +1315,14 @@ async function compressSystemPrompt(system) {
     : [...textBlocks];
 
   // Step 2: Apply Chinese translation to eligible sections
-  if (liveConfig.TRANSLATE_ENABLED) {
+  const _sysSocket = resolveTranslateSocket();
+  if (liveConfig.TRANSLATE_ENABLED && _sysSocket) {
     try {
       // Translate entire steno'd text via Hardwick Translate
-      const translations = await translateBatch(compressed, TRANSLATE_SOCKET, 'en', 'zh');
+      const translations = await translateBatch(compressed, _sysSocket, 'en', 'zh');
       if (translations && translations.length === compressed.length) {
         // Verify each translation round-trips correctly
-        const backTranslated = await translateBatch(translations, TRANSLATE_SOCKET, 'zh', 'en');
+        const backTranslated = await translateBatch(translations, _sysSocket, 'zh', 'en');
 
         for (let i = 0; i < compressed.length; i++) {
           if (!translations[i] || !backTranslated) continue;
@@ -1133,7 +1438,7 @@ async function handleRequest(req, res) {
     const tmSize = Object.keys(tm).length;
     const synSize = Object.keys(syns).length;
     res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ status: 'ok', paused: proxyPaused, uptime: Math.round((Date.now() - stats.startTime) / 1000), ...stats, tmEntries: tmSize, synonymPairs: synSize, envBaseUrlSet: !!process.env.ANTHROPIC_BASE_URL, envBaseUrl: process.env.ANTHROPIC_BASE_URL || '(not set)' }, null, 2));
+    res.end(JSON.stringify({ status: 'ok', paused: proxyPaused, uptime: Math.round((Date.now() - stats.startTime) / 1000), ...stats, tmEntries: tmSize, synonymPairs: synSize, registeredProjects: projectRegistry.size, activeTranslateSocket: resolveTranslateSocket(), envBaseUrlSet: !!process.env.ANTHROPIC_BASE_URL, envBaseUrl: process.env.ANTHROPIC_BASE_URL || '(not set)' }, null, 2));
     return;
   }
 
@@ -1156,13 +1461,14 @@ async function handleRequest(req, res) {
       try {
         const body = JSON.parse((await collectBody(req)).toString('utf8'));
         if (body.PRESERVE_RECENT_MESSAGES != null) liveConfig.PRESERVE_RECENT_MESSAGES = Math.max(1, Math.min(20, parseInt(body.PRESERVE_RECENT_MESSAGES) || 3));
-        if (body.OLD_STRIP_THRESHOLD != null) liveConfig.OLD_STRIP_THRESHOLD = Math.max(100, Math.min(2000, parseInt(body.OLD_STRIP_THRESHOLD) || 400));
-        if (body.MIN_TRANSLATE_LENGTH != null) liveConfig.MIN_TRANSLATE_LENGTH = Math.max(20, Math.min(200, parseInt(body.MIN_TRANSLATE_LENGTH) || 50));
+        if (body.OLD_STRIP_THRESHOLD != null) liveConfig.OLD_STRIP_THRESHOLD = Math.max(0, Math.min(2000, parseInt(body.OLD_STRIP_THRESHOLD) || 0));
+        if (body.MIN_TRANSLATE_LENGTH != null) liveConfig.MIN_TRANSLATE_LENGTH = Math.max(0, Math.min(200, parseInt(body.MIN_TRANSLATE_LENGTH) || 0));
         if (body.TOOL_RESULT_PREVIEW_CHARS != null) liveConfig.TOOL_RESULT_PREVIEW_CHARS = Math.max(50, Math.min(500, parseInt(body.TOOL_RESULT_PREVIEW_CHARS) || 200));
         if (body.STENO_ENABLED != null) liveConfig.STENO_ENABLED = !!body.STENO_ENABLED;
         if (body.TRANSLATE_ENABLED != null) liveConfig.TRANSLATE_ENABLED = !!body.TRANSLATE_ENABLED;
         if (body.OLD_STRIP_ENABLED != null) liveConfig.OLD_STRIP_ENABLED = !!body.OLD_STRIP_ENABLED;
         if (body.SYSTEM_PROMPT_COMPRESS != null) liveConfig.SYSTEM_PROMPT_COMPRESS = !!body.SYSTEM_PROMPT_COMPRESS;
+        if (body.SYSTEM_REMINDER_STRIPPING != null) liveConfig.SYSTEM_REMINDER_STRIPPING = !!body.SYSTEM_REMINDER_STRIPPING;
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ ok: true, ...liveConfig }));
       } catch (e) {
@@ -1204,11 +1510,97 @@ async function handleRequest(req, res) {
     return;
   }
 
+  // Explicit pause/resume endpoints — no guessing with toggle
+  if (req.url === '/pause' && req.method === 'POST') {
+    proxyPaused = true;
+    log('info', 'Proxy PAUSED via /pause');
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ paused: true }));
+    return;
+  }
+  if (req.url === '/resume' && req.method === 'POST') {
+    proxyPaused = false;
+    log('info', 'Proxy RESUMED via /resume');
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ paused: false }));
+    return;
+  }
+
+  // --- Multi-Project Registry Endpoints ---
+
+  // POST /register — register a project with the daemon
+  if (req.url === '/register' && req.method === 'POST') {
+    try {
+      const body = JSON.parse((await collectBody(req)).toString('utf8'));
+      if (!body.projectPath) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'projectPath required' }));
+        return;
+      }
+      projectRegistry.set(body.projectPath, {
+        projectPath: body.projectPath,
+        pid: body.pid || 0,
+        registeredAt: projectRegistry.get(body.projectPath)?.registeredAt || Date.now(),
+        lastSeen: Date.now(),
+      });
+      _invalidateProjectCaches();
+      log('info', `REGISTRY: registered project "${body.projectPath}" (pid=${body.pid || 0}, total=${projectRegistry.size})`);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, registered: projectRegistry.size }));
+    } catch (e) {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: e.message }));
+    }
+    return;
+  }
+
+  // POST /deregister — remove a project from the daemon
+  if (req.url === '/deregister' && req.method === 'POST') {
+    try {
+      const body = JSON.parse((await collectBody(req)).toString('utf8'));
+      if (body.projectPath && projectRegistry.has(body.projectPath)) {
+        projectRegistry.delete(body.projectPath);
+        _invalidateProjectCaches();
+        log('info', `REGISTRY: deregistered project "${body.projectPath}" (remaining=${projectRegistry.size})`);
+      }
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, registered: projectRegistry.size }));
+    } catch (e) {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: e.message }));
+    }
+    return;
+  }
+
+  // GET /registry — diagnostic: list all registered projects
+  if (req.url === '/registry' && req.method === 'GET') {
+    const projects = [];
+    for (const [path, entry] of projectRegistry.entries()) {
+      let alive = false;
+      if (entry.pid > 0) {
+        try { process.kill(entry.pid, 0); alive = true; } catch {}
+      }
+      const sockPath = join(path, 'specmem', 'run', 'translate.sock');
+      projects.push({
+        projectPath: path,
+        pid: entry.pid,
+        alive,
+        registeredAt: new Date(entry.registeredAt).toISOString(),
+        lastSeen: new Date(entry.lastSeen).toISOString(),
+        translateSocket: existsSync(sockPath) ? sockPath : null,
+      });
+    }
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ projects, total: projects.length }, null, 2));
+    return;
+  }
+
   // Count only real API traffic, not management endpoint polls
   stats.totalRequests++;
 
+  let rawBody;
   try {
-    const rawBody = await collectBody(req);
+    rawBody = await collectBody(req);
 
     // Paused — pass everything through untouched
     if (proxyPaused) {
@@ -1255,7 +1647,8 @@ async function handleRequest(req, res) {
     pushEvent('info', `POST /v1/messages model=${body.model || '?'} msgs=${messageCount} size=${(originalSize / 1024).toFixed(0)}KB`);
 
     const isCompaction = isCompactionRequest(body);
-    const isPassthrough = !isCompaction && (dontCompress || messageCount <= liveConfig.PRESERVE_RECENT_MESSAGES);
+    // No passthrough — always process everything (system-reminder strip + steno + translate)
+    const isPassthrough = false;
     let sysPromptModified = false;
 
     // === SYSTEM PROMPT COMPRESSION ===
@@ -1266,7 +1659,7 @@ async function handleRequest(req, res) {
       const _sysKey = typeof body.system === 'string' ? body.system
         : Array.isArray(body.system) ? body.system.map(b => typeof b === 'string' ? b : (b?.text || '')).join('')
         : JSON.stringify(body.system);
-      const _sysHash = require('crypto').createHash('md5').update(_sysKey).digest('hex');
+      const _sysHash = createHash('md5').update(_sysKey).digest('hex');
       const _sysCached = _sysPromptCache.get(_sysHash);
 
       if (_sysCached) {
@@ -1313,8 +1706,26 @@ async function handleRequest(req, res) {
       log('info', `=== ${logMsg} ===`);
       pushEvent('compaction', logMsg);
 
-      const { strippedMessages, strippingStats } = stripMessages(body.messages);
-      body.messages = strippedMessages;
+      // Strip redundant system-reminders first (before tool stripping)
+      try {
+        const srResult = stripSystemReminders(body.messages);
+        if (srResult.remindersStripped > 0) {
+          body.messages = srResult.messages;
+          log('info', `[compaction] Stripped ${srResult.remindersStripped} system-reminders (${srResult.charsRemoved} chars)`);
+        }
+      } catch (srErr) {
+        log('warn', `[compaction] stripSystemReminders failed: ${srErr.message}`);
+      }
+
+      let strippingStats = { toolResultsStripped: 0, toolUsesStripped: 0, charsRemoved: 0 };
+      try {
+        const result = stripMessages(body.messages);
+        body.messages = result.strippedMessages;
+        strippingStats = result.strippingStats;
+      } catch (stripErr) {
+        log('warn', `stripMessages failed, using raw messages: ${stripErr.message}`);
+        // Keep body.messages as-is
+      }
 
       // Run steno+MT compression in parallel (independent of strip)
       if (!dontCompress) {
@@ -1349,24 +1760,38 @@ async function handleRequest(req, res) {
       return;
     }
 
-    // === NON-COMPACTION — passthrough if below threshold ===
-    if (isPassthrough) {
-      stats.passthrough++;
-      pushEvent('pass', `msgs=${messageCount} (below threshold ${liveConfig.PRESERVE_RECENT_MESSAGES})`);
-      // Use modified body if sys prompt was compressed (cache hit), else rawBody
-      const passthroughBody = sysPromptModified
-        ? Buffer.from(JSON.stringify(body), 'utf8')
-        : rawBody;
-      forwardRequest(req, res, passthroughBody);
-      return;
+    // === NO PASSTHROUGH — always process all requests ===
+    // (passthrough mode removed — every request gets stripped + compressed)
+
+    // Step 0: Strip redundant <system-reminder> tags
+    let srCharsRemoved = 0;
+    let srRemindersStripped = 0;
+    try {
+      const srResult = stripSystemReminders(body.messages);
+      if (srResult.remindersStripped > 0) {
+        body.messages = srResult.messages;
+        srCharsRemoved = srResult.charsRemoved;
+        srRemindersStripped = srResult.remindersStripped;
+        log('info', `Stripped ${srResult.remindersStripped} system-reminders (${srResult.charsRemoved} chars)`);
+      }
+    } catch (srErr) {
+      log('warn', `stripSystemReminders failed, skipping: ${srErr.message}`);
     }
 
     // Step 1: Strip large tool_results from old messages (biggest savings)
-    const { messages: preStripped, strippingStats: oldStrip } = liveConfig.OLD_STRIP_ENABLED
-      ? stripOldToolResults(body.messages)
-      : { messages: body.messages, strippingStats: { toolResultsStripped: 0, charsRemoved: 0 } };
+    let oldStrip = { toolResultsStripped: 0, charsRemoved: 0 };
+    try {
+      if (liveConfig.OLD_STRIP_ENABLED) {
+        const result = stripOldToolResults(body.messages);
+        if (result.strippingStats.charsRemoved > 0) {
+          body.messages = result.messages;
+          oldStrip = result.strippingStats;
+        }
+      }
+    } catch (stripErr) {
+      log('warn', `stripOldToolResults failed, skipping: ${stripErr.message}`);
+    }
     if (oldStrip.charsRemoved > 0) {
-      body.messages = preStripped;
       stats.oldStripped += oldStrip.toolResultsStripped;
       stats.oldCharsRemoved += oldStrip.charsRemoved;
       stats.tokensStripped += Math.floor(oldStrip.charsRemoved / 4);
@@ -1377,13 +1802,18 @@ async function handleRequest(req, res) {
     // Step 2: Steno+MT compression on remaining text
     const { messages: compressed, blocksCompressed, charsCompressed, verifiedCount = 0, stenoOnlyCount = 0, tmHits: hits = 0, samples: liveSamples = [] } = await compressMessagesLive(body.messages);
 
-    if (blocksCompressed === 0 && oldStrip.charsRemoved === 0) {
+    // srCharsRemoved already tracked from Step 0 above
+
+    if (blocksCompressed === 0 && oldStrip.charsRemoved === 0 && srCharsRemoved === 0) {
       stats.passthrough++;
       pushEvent('pass', `msgs=${messageCount} (nothing to compress)`);
       forwardRequest(req, res, rawBody);
       return;
     }
 
+    // If anything was stripped/compressed, body was mutated — must re-serialize
+    body.messages = compressed;
+
     // Store translation samples for preview
     if (liveSamples.length > 0) stats._lastSamples = liveSamples;
 
@@ -1397,8 +1827,8 @@ async function handleRequest(req, res) {
       stats.stenoOnly += (blocksCompressed - verifiedCount - stenoOnlyCount);
       stats.tmHits += hits;
       pushEvent('compress', `LIVE: ${blocksCompressed} blocks, ${charsCompressed} chars (${verifiedCount} zh, ${stenoOnlyCount} steno, ${hits} TM)`);
-    } else if (oldStrip.charsRemoved > 0) {
-      // Only stripping, no compression — still send modified body
+    } else if (oldStrip.charsRemoved > 0 || srCharsRemoved > 0) {
+      // Only stripping (tool results or system-reminders), no compression — still send modified body
       stats.liveCompressed++;
     }
     stats.lastLiveCompress = new Date().toISOString();
@@ -1408,7 +1838,8 @@ async function handleRequest(req, res) {
     const savedPercent = originalSize > 0 ? ((savedBytes / originalSize) * 100).toFixed(1) : '0';
 
     const stripInfo = oldStrip.charsRemoved > 0 ? ` [STRIP: ${oldStrip.toolResultsStripped} results, ${(oldStrip.charsRemoved / 1024).toFixed(0)}KB]` : '';
-    log('info', `LIVE: ${blocksCompressed} blocks | ${(originalSize / 1024).toFixed(0)}KB → ${(compressedBody.length / 1024).toFixed(0)}KB (-${savedPercent}%)${stripInfo}`);
+    const srInfo = srCharsRemoved > 0 ? ` [SR: ${srRemindersStripped} reminders, ${(srCharsRemoved / 1024).toFixed(1)}KB]` : '';
+    log('info', `LIVE: ${blocksCompressed} blocks | ${(originalSize / 1024).toFixed(0)}KB → ${(compressedBody.length / 1024).toFixed(0)}KB (-${savedPercent}%)${stripInfo}${srInfo}`);
     pushEvent('saved', `${(originalSize / 1024).toFixed(0)}KB → ${(compressedBody.length / 1024).toFixed(0)}KB (-${savedPercent}%) ~${Math.round(savedBytes / 3.5)} tokens`);
 
     pushPreview(rawBody.toString('utf8'), compressedBody.toString('utf8'), 'live', liveSamples);
@@ -1417,11 +1848,35 @@ async function handleRequest(req, res) {
 
   } catch (err) {
     log('error', `Handler error: ${err.message}`);
+    log('error', `Handler stack: ${err.stack || '(no stack)'}`);
     pushEvent('error', err.message);
     stats.errors++;
+    // CRITICAL: Never return 502 — fall back to forwarding raw body.
+    // The proxy must NEVER break the API call. Compression is optional;
+    // if it fails, just passthrough the original request.
     if (!res.headersSent) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Proxy error', message: err.message }));
+      try {
+        const fallbackBody = (typeof rawBody !== 'undefined' && rawBody && rawBody.length > 0) ? rawBody : null;
+        if (fallbackBody) {
+          log('warn', `Falling back to passthrough after handler error: ${err.message}`);
+          stats.passthrough++;
+          forwardRequest(req, res, fallbackBody);
+        } else {
+          // rawBody unavailable — re-collect from request if possible, else auto-pause and passthrough next time
+          log('warn', `No rawBody available — auto-pausing proxy to prevent further 502s: ${err.message}`);
+          proxyPaused = true;
+          // Return a retriable error so Claude Code retries (and next attempt hits passthrough path)
+          res.writeHead(503, { 'Content-Type': 'application/json', 'Retry-After': '1' });
+          res.end(JSON.stringify({ type: 'error', error: { type: 'overloaded_error', message: 'Proxy auto-paused due to handler error, retry immediately' } }));
+        }
+      } catch (fallbackErr) {
+        log('error', `Fallback also failed: ${fallbackErr.message}`);
+        if (!res.headersSent) {
+          proxyPaused = true;
+          res.writeHead(503, { 'Content-Type': 'application/json', 'Retry-After': '1' });
+          res.end(JSON.stringify({ type: 'error', error: { type: 'overloaded_error', message: 'Proxy auto-paused, retry immediately' } }));
+        }
+      }
     }
   }
 }
@@ -1439,13 +1894,9 @@ let proxyServer = null;
  * Returns { started: boolean, port: number }
  */
 export async function startCompactionProxy() {
-  // Check for user disable flag
-  if (existsSync(DISABLED_FILE)) {
-    log('info', 'Compaction proxy disabled by user (flag file exists)');
-    cleanupPortFile();
-    cleanupPidFile();
-    return { started: false, port: PROXY_PORT, reason: 'disabled_by_user' };
-  }
+  // Disabled flag = start in passthrough mode (proxy always in path for seamless toggling).
+  // The daemon itself reads the flag and starts paused.
+  const disabledByUser = existsSync(DISABLED_FILE);
 
   // Check PID file — is daemon already running?
   if (existsSync(PID_FILE)) {
@@ -1458,8 +1909,11 @@ export async function startCompactionProxy() {
           // Process exists, verify it responds to health check
           const healthy = await checkDaemonHealth();
           if (healthy) {
-            log('info', `Daemon already running (PID ${pid}), skipping spawn`);
-            return { started: false, port: PROXY_PORT, reason: 'daemon_already_running' };
+            log('info', `Daemon already running (PID ${pid})${disabledByUser ? ' (passthrough mode)' : ''}, skipping spawn`);
+            // If disabled flag changed since daemon started, sync pause state via SIGUSR1
+            // (daemon checks disabled file on toggle, but we can hint via stats check)
+            registerWithDaemon(process.env.SPECMEM_PROJECT_PATH, process.pid);
+            return { started: false, port: PROXY_PORT, paused: disabledByUser, reason: 'daemon_already_running' };
           }
           // Process alive but not responding — stale, kill it
           log('warn', `Daemon PID ${pid} alive but not healthy, killing stale process`);
@@ -1495,14 +1949,16 @@ export async function startCompactionProxy() {
   const deadline = Date.now() + 3000;
   while (Date.now() < deadline) {
     if (existsSync(PORT_FILE)) {
-      log('info', `Daemon ready (PID ${child.pid}), port file appeared`);
-      return { started: true, port: PROXY_PORT };
+      log('info', `Daemon ready (PID ${child.pid})${disabledByUser ? ' in passthrough mode' : ''}, port file appeared`);
+      registerWithDaemon(process.env.SPECMEM_PROJECT_PATH, process.pid);
+      return { started: true, port: PROXY_PORT, paused: disabledByUser };
     }
     await new Promise(r => setTimeout(r, 100));
   }
 
   log('warn', 'Daemon spawned but port file did not appear within 3s');
-  return { started: true, port: PROXY_PORT, reason: 'timeout_waiting_for_port' };
+  registerWithDaemon(process.env.SPECMEM_PROJECT_PATH, process.pid);
+  return { started: true, port: PROXY_PORT, paused: disabledByUser, reason: 'timeout_waiting_for_port' };
 }
 
 /**
@@ -1539,6 +1995,12 @@ function togglePause() {
   return proxyPaused;
 }
 
+function setPaused(state) {
+  proxyPaused = !!state;
+  log('info', `Proxy pause state set to ${proxyPaused ? 'PAUSED' : 'ACTIVE'}`);
+  return proxyPaused;
+}
+
 /**
  * Check if the daemon is responding on its health endpoint.
  */
@@ -1555,11 +2017,12 @@ function checkDaemonHealth() {
 }
 
 /**
- * Stop the proxy — NO-OP for daemon mode.
+ * Stop the proxy — deregisters this project from the daemon.
  * The daemon persists independently of the MCP process.
  * Use killCompactionProxy() to explicitly terminate the daemon.
  */
 export function stopCompactionProxy() {
+  deregisterFromDaemon(process.env.SPECMEM_PROJECT_PATH);
   return Promise.resolve();
 }
 
@@ -1647,6 +2110,115 @@ export function getCompactionProxyStats() {
   return { running, daemonPid, port: PROXY_PORT };
 }
 
+// ============================================================================
+// Registration helpers — fire-and-forget HTTP to the daemon
+// ============================================================================
+
+/**
+ * Register this project with the running daemon.
+ * Fire-and-forget — if daemon isn't running yet, fails silently.
+ */
+function registerWithDaemon(projectPath, pid) {
+  if (!projectPath) return;
+  const body = JSON.stringify({ projectPath, pid: pid || process.pid });
+  try {
+    const req = httpRequest({
+      hostname: '127.0.0.1',
+      port: PROXY_PORT,
+      path: '/register',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+      timeout: 2000,
+    });
+    req.on('error', () => {}); // fire-and-forget
+    req.on('timeout', () => req.destroy());
+    req.write(body);
+    req.end();
+    log('info', `Sent /register for "${projectPath}" (pid=${pid || process.pid})`);
+  } catch { /* fire-and-forget */ }
+}
+
+/**
+ * Deregister this project from the running daemon.
+ * Fire-and-forget — best effort cleanup on shutdown.
+ */
+function deregisterFromDaemon(projectPath) {
+  if (!projectPath) return;
+  const body = JSON.stringify({ projectPath });
+  try {
+    const req = httpRequest({
+      hostname: '127.0.0.1',
+      port: PROXY_PORT,
+      path: '/deregister',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+      timeout: 2000,
+    });
+    req.on('error', () => {}); // fire-and-forget
+    req.on('timeout', () => req.destroy());
+    req.write(body);
+    req.end();
+    log('info', `Sent /deregister for "${projectPath}"`);
+  } catch { /* fire-and-forget */ }
+}
+
+// ============================================================================
+// Stale Project Reaper — removes dead projects from the registry
+// ============================================================================
+
+/**
+ * Check if a PID is alive using signal 0.
+ */
+function isPidAlive(pid) {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Reap stale projects — remove entries with dead PIDs.
+ */
+function reapStaleProjects() {
+  let reaped = 0;
+  for (const [path, entry] of projectRegistry.entries()) {
+    if (entry.pid > 0 && !isPidAlive(entry.pid)) {
+      projectRegistry.delete(path);
+      reaped++;
+      log('info', `REAPER: removed stale project "${path}" (dead pid=${entry.pid})`);
+    }
+  }
+  if (reaped > 0) {
+    _invalidateProjectCaches();
+    log('info', `REAPER: reaped ${reaped} stale projects, ${projectRegistry.size} remaining`);
+  }
+}
+
+let _reaperTimer = null;
+
+/**
+ * Start the stale project reaper (30s interval, unref'd).
+ */
+function startReaper() {
+  if (_reaperTimer) return;
+  _reaperTimer = setInterval(reapStaleProjects, 30000);
+  _reaperTimer.unref();
+  log('info', 'REAPER: started (30s interval)');
+}
+
+/**
+ * Check if any registered projects have live PIDs.
+ */
+function hasLiveProjects() {
+  for (const entry of projectRegistry.values()) {
+    if (entry.pid > 0 && isPidAlive(entry.pid)) return true;
+  }
+  return false;
+}
+
 // ============================================================================
 // Daemon Internals — exported for compactionProxyDaemon.js
 // ============================================================================
@@ -1655,6 +2227,9 @@ export {
   handleRequest,
   log,
   togglePause,
+  setPaused,
+  startReaper,
+  hasLiveProjects,
   PROXY_PORT,
   PORT_FILE,
   PID_FILE,