ragent-cli 1.11.14 → 1.11.16

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "ragent-cli",
-      version: "1.11.14",
+      version: "1.11.16",
       description: "CLI agent for rAgent Live \u2014 browser-first terminal control plane for AI coding agents",
       main: "dist/index.js",
       bin: {
@@ -435,6 +435,10 @@ var blockCounter = 0;
 function genBlockId(prefix) {
   return `${prefix}-${Date.now()}-${(++blockCounter).toString(36)}`;
 }
+function makeStableBlockIdGen(turnId) {
+  let n = 0;
+  return (prefix) => `${turnId}-${prefix}-${n++}`;
+}
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -1422,6 +1426,7 @@ var GeminiCliParserV2 = class {
     return this.parseLegacySchemaItem(item, turnId, timestamp, pendingLegacyCalls);
   }
   parseNewSchemaItem(item, turnId, timestamp) {
+    const nextBlockId = makeStableBlockIdGen(turnId);
     const statusLevel = geminiStatusLevelFromType(item.type);
     if (statusLevel) {
       const text2 = geminiTextFromNewItem(item);
@@ -1440,7 +1445,7 @@ var GeminiCliParserV2 = class {
         {
           op: "insert_block",
           turnId,
-          block: makeStatusBlock(genBlockId("status"), "notice", text2, statusLevel)
+          block: makeStatusBlock(nextBlockId("status"), "notice", text2, statusLevel)
         },
         {
           op: "complete_turn",
@@ -1466,7 +1471,7 @@ ${description}` : subject || description;
           op: "insert_block",
           turnId,
           block: makeReasoningBlock(
-            genBlockId("reason"),
+            nextBlockId("reason"),
             reasoningText,
             "summary"
           )
@@ -1477,14 +1482,14 @@ ${description}` : subject || description;
       blocks.push({
         op: "insert_block",
         turnId,
-        block: makeTextBlock(genBlockId("txt"), text, true)
+        block: makeTextBlock(nextBlockId("txt"), text, true)
       });
     }
     if (role === "assistant" && Array.isArray(item.toolCalls)) {
       for (const tc of item.toolCalls) {
         if (!tc.name) continue;
-        const callId = tc.id ?? genBlockId("call");
-        const blockId = genBlockId("tool");
+        const callId = tc.id ?? nextBlockId("call");
+        const blockId = nextBlockId("tool");
         const state = mapGeminiToolStatus(tc.status);
         const isComplete = state === "completed" || state === "error" || state === "cancelled";
         blocks.push({
@@ -1527,6 +1532,7 @@ ${description}` : subject || description;
   parseLegacySchemaItem(item, turnId, timestamp, pendingLegacyCalls) {
     const role = geminiRoleFromLegacy(item.role);
     if (!role) return [];
+    const nextBlockId = makeStableBlockIdGen(turnId);
     const parts = geminiPartsFromLegacyItem(item);
     const currentTurnBlocks = [];
     const priorTurnUpdates = [];
@@ -1536,12 +1542,12 @@ ${description}` : subject || description;
         currentTurnBlocks.push({
           op: "insert_block",
           turnId,
-          block: makeTextBlock(genBlockId("txt"), text, true)
+          block: makeTextBlock(nextBlockId("txt"), text, true)
         });
       }
       if (part.functionCall?.name) {
-        const callId = genBlockId("call");
-        const blockId = genBlockId("tool");
+        const callId = nextBlockId("call");
+        const blockId = nextBlockId("tool");
         pendingLegacyCalls.set(part.functionCall.name, { turnId, blockId });
         currentTurnBlocks.push({
           op: "insert_block",
@@ -1577,13 +1583,13 @@ ${description}` : subject || description;
             });
           }
         } else {
-          const blockId = genBlockId("tool");
+          const blockId = nextBlockId("tool");
           currentTurnBlocks.push({
             op: "insert_block",
             turnId,
             block: makeToolBlock(
               blockId,
-              genBlockId("call"),
+              nextBlockId("call"),
               part.functionResponse.name,
               "completed",
               void 0,
@@ -1640,7 +1646,8 @@ var AntigravityCliParserV2 = class {
     if (!obj.source || !obj.type) return [];
     const ops = [];
     const timestamp = obj.created_at || now();
-    const turnId = `step-${obj.step_index}-${timestamp}`;
+    const turnId = `step-${obj.step_index}`;
+    const nextBlockId = makeStableBlockIdGen(turnId);
     const normalizedType = obj.type.toLowerCase().replace(/[^a-z0-9]/g, "");
     const pendingIndex = this.pendingTools.findIndex(
       (t) => t.normalizedName === normalizedType
@@ -1689,7 +1696,7 @@ var AntigravityCliParserV2 = class {
         ops.push({
           op: "insert_block",
           turnId,
-          block: makeTextBlock(genBlockId("txt"), obj.content, true)
+          block: makeTextBlock(nextBlockId("txt"), obj.content, true)
         });
       }
       ops.push({
@@ -1713,13 +1720,13 @@ var AntigravityCliParserV2 = class {
         ops.push({
           op: "insert_block",
           turnId,
-          block: makeTextBlock(genBlockId("txt"), obj.content, true)
+          block: makeTextBlock(nextBlockId("txt"), obj.content, true)
         });
       }
       if (obj.tool_calls && obj.tool_calls.length > 0) {
         for (const tc of obj.tool_calls) {
-          const callId = genBlockId("call");
-          const blockId = genBlockId("tool");
+          const callId = nextBlockId("call");
+          const blockId = nextBlockId("tool");
           const normalizedName = tc.name.toLowerCase().replace(/[^a-z0-9]/g, "");
           this.pendingTools.push({
             blockId,
@@ -1760,7 +1767,7 @@ var AntigravityCliParserV2 = class {
         ops.push({
           op: "insert_block",
           turnId,
-          block: makeTextBlock(genBlockId("txt"), obj.content, true)
+          block: makeTextBlock(nextBlockId("txt"), obj.content, true)
         });
       }
       ops.push({
@@ -1776,6 +1783,7 @@ var AntigravityCliParserV2 = class {
     return ops;
   }
   parseDocument(document) {
+    this.pendingTools = [];
     const ops = [];
     for (const line of document.split("\n")) {
       const trimmed = line.trim();
@@ -1992,8 +2000,10 @@ function setBlock(turns, turnId, blockId, block) {
 }
 var MAX_SNAPSHOT_TURNS = 1e3;
 var MAX_SNAPSHOT_SIZE_CHARS = 45e4;
+var SNAPSHOT_FIELD_RESERVE = 64;
 function trimSnapshot(snapshot, maxTurns = MAX_SNAPSHOT_TURNS) {
   let currentSnapshot = snapshot;
+  const originalLength = snapshot.turnOrder.length;
   if (currentSnapshot.turnOrder.length > maxTurns) {
     const keptOrder = currentSnapshot.turnOrder.slice(-maxTurns);
     const keptTurns = {};
@@ -2009,10 +2019,8 @@ function trimSnapshot(snapshot, maxTurns = MAX_SNAPSHOT_TURNS) {
     };
   }
   let serialized = JSON.stringify(currentSnapshot);
-  if (serialized.length <= MAX_SNAPSHOT_SIZE_CHARS) {
-    return currentSnapshot;
-  }
-  while (currentSnapshot.turnOrder.length > 1 && serialized.length > MAX_SNAPSHOT_SIZE_CHARS) {
+  const sizeBudget = MAX_SNAPSHOT_SIZE_CHARS - SNAPSHOT_FIELD_RESERVE;
+  while (currentSnapshot.turnOrder.length > 1 && serialized.length > sizeBudget) {
     const keptOrder = currentSnapshot.turnOrder.slice(1);
     const keptTurns = {};
     for (const id of keptOrder) {
@@ -2027,6 +2035,11 @@ function trimSnapshot(snapshot, maxTurns = MAX_SNAPSHOT_TURNS) {
     };
     serialized = JSON.stringify(currentSnapshot);
   }
+  const droppedThisCall = originalLength - currentSnapshot.turnOrder.length;
+  const truncatedTurns = (snapshot.truncatedTurns ?? 0) + droppedThisCall;
+  if (truncatedTurns > 0 && currentSnapshot.truncatedTurns !== truncatedTurns) {
+    currentSnapshot = { ...currentSnapshot, truncatedTurns };
+  }
   return currentSnapshot;
 }
 
@@ -2562,6 +2575,155 @@ function releaseSessionSource(sessionId) {
   sessionSourceLocks.delete(sessionId);
 }
 
+// src/websocket.ts
+var import_ws = __toESM(require("ws"));
+var BACKPRESSURE_HIGH_WATER = 256 * 1024;
+var BACKPRESSURE_LOW_WATER = 64 * 1024;
+var MAX_PENDING_QUEUE = 500;
+var DRAIN_INTERVAL_MS = 50;
+function sanitizeForJson(str) {
+  return str.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD");
+}
+var DANGEROUS_OSC_RE = /\x1b\](?:52|7|8);[^\x07\x1b]*(?:\x07|\x1b\\)/g;
+function stripDangerousEscapes(str) {
+  return str.replace(DANGEROUS_OSC_RE, "");
+}
+var SECRET_PATTERNS = [
+  /AKIA[0-9A-Z]{16}/g,
+  // AWS access key
+  /gh[ps]_[A-Za-z0-9_]{36,}/g,
+  // GitHub token
+  /sk_(?:live|test)_[A-Za-z0-9]{24,}/g,
+  // Stripe secret key
+  /eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}/g
+  // JWT
+];
+var redactionEnabled = true;
+function setRedactionEnabled(enabled) {
+  redactionEnabled = enabled;
+}
+function redactSecrets(str) {
+  if (!redactionEnabled) return str;
+  let result = str;
+  for (const pattern of SECRET_PATTERNS) {
+    pattern.lastIndex = 0;
+    result = result.replace(pattern, "[REDACTED]");
+  }
+  return result;
+}
+var streamingTails = /* @__PURE__ */ new Map();
+var MAX_STREAMING_TAIL = 1024;
+var SECRET_PREFIX_RE = /(?:AKIA[0-9A-Z]*|gh[ps]_[A-Za-z0-9_]*|sk_(?:live|test)_[A-Za-z0-9]*|eyJ[A-Za-z0-9_-]*(?:\.[A-Za-z0-9_-]*){0,2})$/;
+function redactStreamingChunk(sessionId, chunk) {
+  if (!redactionEnabled) return chunk;
+  const prevTail = streamingTails.get(sessionId) ?? "";
+  const combined = prevTail + chunk;
+  const redacted = redactSecrets(combined);
+  const prefix = SECRET_PREFIX_RE.exec(redacted);
+  if (prefix && prefix.index + prefix[0].length === redacted.length && redacted.length - prefix.index <= MAX_STREAMING_TAIL) {
+    streamingTails.set(sessionId, redacted.slice(prefix.index));
+    return redacted.slice(0, prefix.index);
+  }
+  streamingTails.delete(sessionId);
+  return redacted;
+}
+function flushStreamingRedaction(sessionId) {
+  const tail = streamingTails.get(sessionId) ?? "";
+  streamingTails.delete(sessionId);
+  return redactionEnabled ? redactSecrets(tail) : tail;
+}
+var pendingQueue = [];
+var drainTimer = null;
+var drainWs = null;
+var droppedFrames = 0;
+var PRESSURE_HIGH = 0.75;
+var PRESSURE_LOW = 0.25;
+var pressureIsHigh = false;
+function getQueuePressure() {
+  const level = pendingQueue.length / MAX_PENDING_QUEUE;
+  if (level >= PRESSURE_HIGH) pressureIsHigh = true;
+  else if (level < PRESSURE_LOW) pressureIsHigh = false;
+  return { level, isHigh: pressureIsHigh };
+}
+function getDroppedFrameCount() {
+  return droppedFrames;
+}
+function drainQueue() {
+  if (!drainWs || drainWs.readyState !== import_ws.default.OPEN) {
+    stopDrainTimer();
+    return;
+  }
+  while (pendingQueue.length > 0 && drainWs.bufferedAmount < BACKPRESSURE_LOW_WATER) {
+    const frame = pendingQueue.shift();
+    drainWs.send(frame);
+  }
+  if (pendingQueue.length === 0) {
+    stopDrainTimer();
+  }
+}
+function startDrainTimer(ws) {
+  drainWs = ws;
+  if (!drainTimer) {
+    drainTimer = setInterval(drainQueue, DRAIN_INTERVAL_MS);
+  }
+}
+function stopDrainTimer() {
+  if (drainTimer) {
+    clearInterval(drainTimer);
+    drainTimer = null;
+  }
+  drainWs = null;
+}
+function sendToGroup(ws, group, data) {
+  if (!group || ws.readyState !== import_ws.default.OPEN) return;
+  const sanitized = sanitizePayload(data);
+  const frame = JSON.stringify({
+    type: "sendToGroup",
+    group,
+    dataType: "json",
+    data: sanitized,
+    noEcho: true
+  });
+  if (ws.bufferedAmount > BACKPRESSURE_HIGH_WATER) {
+    if (pendingQueue.length >= MAX_PENDING_QUEUE) {
+      pendingQueue.shift();
+      droppedFrames++;
+      if (droppedFrames % 100 === 1) {
+        console.warn(`[rAgent] Backpressure: dropped ${droppedFrames} frames (queue full at ${MAX_PENDING_QUEUE})`);
+      }
+    }
+    pendingQueue.push(frame);
+    startDrainTimer(ws);
+    return;
+  }
+  if (pendingQueue.length > 0) {
+    pendingQueue.push(frame);
+    drainWs = ws;
+    drainQueue();
+    return;
+  }
+  ws.send(frame);
+}
+function sanitizeValue(value) {
+  if (typeof value === "string") {
+    return redactSecrets(stripDangerousEscapes(sanitizeForJson(value)));
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeValue(item));
+  }
+  if (value !== null && typeof value === "object") {
+    return sanitizePayload(value);
+  }
+  return value;
+}
+function sanitizePayload(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[key] = sanitizeValue(value);
+  }
+  return result;
+}
+
 // src/transcript-watcher.ts
 var log7 = createLogger("transcript-watcher");
 var cachedTicksPerSecond = null;
@@ -3056,7 +3218,7 @@ function getNewestPath(paths, options) {
     } catch {
       return null;
     }
-  }).filter((entry) => entry !== null).filter((entry) => options?.minMtimeMs === void 0 || entry.mtimeMs >= options.minMtimeMs).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  }).filter((entry) => entry !== null).filter((entry) => options?.minMtimeMs === void 0 || entry.mtimeMs >= options.minMtimeMs).filter((entry) => !options?.excludePaths?.has(entry.target)).sort((a, b) => b.mtimeMs - a.mtimeMs);
   return ranked[0]?.target ?? null;
 }
 function discoverTranscriptForPid(pid, agentType) {
@@ -3204,10 +3366,10 @@ function discoverViaProc(rootPid, agentType) {
   }
   return getNewestPath(candidates);
 }
-function discoverViaProcessCwd(pid, minMtimeMs) {
+function discoverViaProcessCwd(pid, minMtimeMs, excludePaths) {
   try {
     const processCwd = fs2.readlinkSync(`/proc/${pid}/cwd`);
-    return processCwd ? discoverViaCwd(processCwd, pid, minMtimeMs) : null;
+    return processCwd ? discoverViaCwd(processCwd, pid, minMtimeMs, excludePaths) : null;
   } catch {
     return null;
   }
@@ -3235,7 +3397,7 @@ function resolveUserHome(pid) {
     return null;
   }
 }
-function discoverCodexTranscriptFromHome(pid, minMtimeMs) {
+function discoverCodexTranscriptFromHome(pid, minMtimeMs, excludePaths) {
   const userHome = resolveUserHome(pid);
   if (!userHome) return null;
   const sessionsDir = path2.join(userHome, ".codex", "sessions");
@@ -3262,9 +3424,9 @@ function discoverCodexTranscriptFromHome(pid, minMtimeMs) {
       }
     }
   }
-  return getNewestPath(matches, { minMtimeMs });
+  return getNewestPath(matches, { minMtimeMs, excludePaths });
 }
-function discoverGeminiTranscriptFromHome(pid) {
+function discoverGeminiTranscriptFromHome(pid, minMtimeMs, excludePaths) {
   const userHome = resolveUserHome(pid);
   if (!userHome) return null;
   const tmpDir = path2.join(userHome, ".gemini", "tmp");
@@ -3291,9 +3453,9 @@ function discoverGeminiTranscriptFromHome(pid) {
       }
     }
   }
-  return getNewestPath(matches);
+  return getNewestPath(matches, { minMtimeMs, excludePaths });
 }
-function discoverAntigravityTranscriptFromHome(pid, minMtimeMs) {
+function discoverAntigravityTranscriptFromHome(pid, minMtimeMs, excludePaths) {
   const userHome = resolveUserHome(pid);
   if (!userHome) return null;
   const brainDir = path2.join(userHome, ".gemini", "antigravity-cli", "brain");
@@ -3311,9 +3473,9 @@ function discoverAntigravityTranscriptFromHome(pid, minMtimeMs) {
     }
   } catch {
   }
-  return getNewestPath(matches, { minMtimeMs });
+  return getNewestPath(matches, { minMtimeMs, excludePaths });
 }
-function discoverAntigravityViaCwd(paneCwd, pid) {
+function discoverAntigravityViaCwd(paneCwd, pid, excludePaths) {
   const userHome = resolveUserHome(pid);
   if (!userHome) return null;
   const historyFile = path2.join(userHome, ".gemini", "antigravity-cli", "history.jsonl");
@@ -3346,7 +3508,7 @@ function discoverAntigravityViaCwd(paneCwd, pid) {
               "logs",
               "transcript.jsonl"
             );
-            if (fs2.existsSync(transcriptPath)) {
+            if (fs2.existsSync(transcriptPath) && !excludePaths?.has(transcriptPath)) {
               return transcriptPath;
             }
           }
@@ -3359,7 +3521,7 @@ function discoverAntigravityViaCwd(paneCwd, pid) {
   }
   return null;
 }
-function discoverViaCwd(paneCwd, pid, minMtimeMs) {
+function discoverViaCwd(paneCwd, pid, minMtimeMs, excludePaths) {
   const userHome = resolveUserHome(pid);
   if (!userHome) return null;
   const claudeProjectsDir = path2.join(userHome, ".claude", "projects");
@@ -3373,60 +3535,67 @@ function discoverViaCwd(paneCwd, pid, minMtimeMs) {
   if (projectDirs.length === 0) return null;
   try {
     const jsonlFiles = projectDirs.flatMap((projectDir) => fs2.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => path2.join(projectDir, f)));
-    return getNewestPath(jsonlFiles, { minMtimeMs });
+    return getNewestPath(jsonlFiles, { minMtimeMs, excludePaths });
   } catch {
     return null;
   }
 }
-function discoverTranscriptFile(sessionId, agentType, forceRefresh = false) {
+function discoverTranscriptFile(sessionId, agentType, forceRefresh = false, excludePaths) {
   const now2 = Date.now();
   const cacheKey = `${sessionId}:${agentType || ""}`;
-  if (!forceRefresh) {
+  const exclusionScoped = Boolean(excludePaths && excludePaths.size > 0);
+  if (!forceRefresh && !exclusionScoped) {
     const cached = transcriptDiscoveryCache.get(cacheKey);
     if (cached && cached.expiresAt > now2) {
       return cached.value;
     }
   }
-  const result = discoverTranscriptFileImpl(sessionId, agentType);
+  const { path: result, viaProc } = discoverTranscriptFileImpl(sessionId, agentType, excludePaths);
   const isProcessSession = sessionId.startsWith("process:");
-  const ttl = result ? isProcessSession ? 3600 * 1e3 : 5e3 : 5e3;
-  transcriptDiscoveryCache.set(cacheKey, {
-    value: result,
-    expiresAt: Date.now() + ttl
-  });
+  const ttl = result ? isProcessSession && viaProc ? 3600 * 1e3 : 5e3 : 5e3;
+  if (!exclusionScoped) {
+    transcriptDiscoveryCache.set(cacheKey, {
+      value: result,
+      expiresAt: Date.now() + ttl
+    });
+  }
   return result;
 }
-function discoverTranscriptFileImpl(sessionId, agentType) {
+function discoverTranscriptFileDetailed(sessionId, agentType, excludePaths) {
+  return discoverTranscriptFileImpl(sessionId, agentType, excludePaths);
+}
+function discoverTranscriptFileImpl(sessionId, agentType, excludePaths) {
   const processPid = parseProcessPid(sessionId);
   if (processPid) {
     const t0 = performance.now();
     const procResult = discoverViaProc(processPid, agentType);
     if (procResult) {
       console.log(`[DISCOVER] discoverViaProc found file for PID ${processPid} in ${(performance.now() - t0).toFixed(2)} ms`);
-      return procResult;
+      return { path: procResult, viaProc: true };
     }
     if (agentType === "Claude Code") {
       const t1 = performance.now();
       const startMs = getProcessStartEpochMs(processPid);
-      const cwdResult = discoverViaProcessCwd(processPid, startMs ? startMs - 6e4 : void 0);
+      const cwdResult = discoverViaProcessCwd(processPid, startMs ? startMs - 6e4 : void 0, excludePaths);
       console.log(`[DISCOVER] Claude Code discovery for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
-      if (cwdResult) return cwdResult;
+      if (cwdResult) return { path: cwdResult, viaProc: false };
     }
     if (agentType === "Codex CLI") {
       const t1 = performance.now();
       const startMs = getProcessStartEpochMs(processPid);
       const command = getProcessCommand(processPid);
       if (commandMatchesAgent(command, agentType)) {
-        const codexResult = discoverCodexTranscriptFromHome(processPid, startMs ? startMs - 6e4 : void 0);
+        const codexResult = discoverCodexTranscriptFromHome(processPid, startMs ? startMs - 6e4 : void 0, excludePaths);
         console.log(`[DISCOVER] Codex CLI discovery for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
-        if (codexResult) return codexResult;
+        if (codexResult) return { path: codexResult, viaProc: false };
       }
     }
     if (agentType === "Gemini CLI") {
       const t1 = performance.now();
-      const geminiResult = discoverGeminiTranscriptFromHome(processPid);
+      const startMs = getProcessStartEpochMs(processPid);
+      const geminiResult = discoverGeminiTranscriptFromHome(processPid, startMs ? startMs - 6e4 : void 0, excludePaths);
       console.log(`[DISCOVER] Gemini CLI discovery for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
-      if (geminiResult) return geminiResult;
+      if (geminiResult) return { path: geminiResult, viaProc: false };
     }
     if (agentType === "Antigravity CLI") {
       const t1 = performance.now();
@@ -3434,23 +3603,23 @@ function discoverTranscriptFileImpl(sessionId, agentType) {
       try {
         const processCwd = fs2.readlinkSync(`/proc/${processPid}/cwd`);
         if (processCwd) {
-          const cwdResult = discoverAntigravityViaCwd(processCwd, processPid);
+          const cwdResult = discoverAntigravityViaCwd(processCwd, processPid, excludePaths);
           if (cwdResult) {
             console.log(`[DISCOVER] Antigravity CLI discovery (CWD path) for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
-            return cwdResult;
+            return { path: cwdResult, viaProc: false };
           }
         }
       } catch {
       }
-      const antigravityResult = discoverAntigravityTranscriptFromHome(processPid, startMs ? startMs - 6e4 : void 0);
+      const antigravityResult = discoverAntigravityTranscriptFromHome(processPid, startMs ? startMs - 6e4 : void 0, excludePaths);
       console.log(`[DISCOVER] Antigravity CLI discovery (home path) for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
-      if (antigravityResult) return antigravityResult;
+      if (antigravityResult) return { path: antigravityResult, viaProc: false };
     }
-    return null;
+    return { path: null, viaProc: false };
   }
   if (sessionId.startsWith("tmux:")) {
     const paneTarget = sessionId.slice("tmux:".length);
-    if (!paneTarget) return null;
+    if (!paneTarget) return { path: null, viaProc: false };
     const cleanEnv = { ...process.env };
     delete cleanEnv.TMUX;
     delete cleanEnv.TMUX_PANE;
@@ -3465,7 +3634,7 @@ function discoverTranscriptFileImpl(sessionId, agentType) {
       if (parsedPanePid > 0) {
         panePid = parsedPanePid;
         const procResult = discoverViaProc(panePid, agentType);
-        if (procResult) return procResult;
+        if (procResult) return { path: procResult, viaProc: true };
       }
     } catch {
     }
@@ -3476,9 +3645,10 @@ function discoverTranscriptFileImpl(sessionId, agentType) {
         const cwdResult = discoverViaCwd(
           info.cwd,
           info.pid,
-          info.startEpochMs ? info.startEpochMs - 6e4 : void 0
+          info.startEpochMs ? info.startEpochMs - 6e4 : void 0,
+          excludePaths
         );
-        if (cwdResult) return cwdResult;
+        if (cwdResult) return { path: cwdResult, viaProc: false };
       }
       try {
         const paneCwd = (0, import_child_process2.execFileSync)(
@@ -3486,7 +3656,10 @@ function discoverTranscriptFileImpl(sessionId, agentType) {
           ["display-message", "-t", paneTarget, "-p", "#{pane_current_path}"],
           { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
         ).trim();
-        if (paneCwd) return discoverViaCwd(paneCwd, panePid ?? void 0);
+        if (paneCwd) {
+          const cwdResult = discoverViaCwd(paneCwd, panePid ?? void 0, void 0, excludePaths);
+          if (cwdResult) return { path: cwdResult, viaProc: false };
+        }
       } catch {
       }
     }
@@ -3495,20 +3668,23 @@ function discoverTranscriptFileImpl(sessionId, agentType) {
       const newestForAgent = getNewestPath(
         agentInfos.map((info) => discoverCodexTranscriptFromHome(
           info.pid,
-          info.startEpochMs ? info.startEpochMs - 6e4 : void 0
-        )).filter((value) => Boolean(value))
+          info.startEpochMs ? info.startEpochMs - 6e4 : void 0,
+          excludePaths
+        )).filter((value) => Boolean(value)),
+        { excludePaths }
       );
-      if (newestForAgent) return newestForAgent;
+      if (newestForAgent) return { path: newestForAgent, viaProc: false };
     }
     if (agentType === "Gemini CLI") {
-      return discoverGeminiTranscriptFromHome(panePid ?? void 0);
+      const geminiResult = discoverGeminiTranscriptFromHome(panePid ?? void 0, void 0, excludePaths);
+      if (geminiResult) return { path: geminiResult, viaProc: false };
     }
     if (agentType === "Antigravity CLI") {
       const agentInfos = panePid ? findAgentProcessInfos(panePid, agentType) : [];
       for (const info of agentInfos) {
         if (info.cwd) {
-          const cwdResult = discoverAntigravityViaCwd(info.cwd, info.pid);
-          if (cwdResult) return cwdResult;
+          const cwdResult = discoverAntigravityViaCwd(info.cwd, info.pid, excludePaths);
+          if (cwdResult) return { path: cwdResult, viaProc: false };
         }
       }
       try {
@@ -3518,28 +3694,31 @@ function discoverTranscriptFileImpl(sessionId, agentType) {
           { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
         ).trim();
         if (paneCwd) {
-          const cwdResult = discoverAntigravityViaCwd(paneCwd, panePid ?? void 0);
-          if (cwdResult) return cwdResult;
+          const cwdResult = discoverAntigravityViaCwd(paneCwd, panePid ?? void 0, excludePaths);
+          if (cwdResult) return { path: cwdResult, viaProc: false };
         }
       } catch {
       }
       const newestForAgent = getNewestPath(
         agentInfos.map((info) => discoverAntigravityTranscriptFromHome(
           info.pid,
-          info.startEpochMs ? info.startEpochMs - 6e4 : void 0
-        )).filter((value) => Boolean(value))
+          info.startEpochMs ? info.startEpochMs - 6e4 : void 0,
+          excludePaths
+        )).filter((value) => Boolean(value)),
+        { excludePaths }
       );
-      if (newestForAgent) return newestForAgent;
+      if (newestForAgent) return { path: newestForAgent, viaProc: false };
     }
-    return null;
+    return { path: null, viaProc: false };
   }
-  return null;
+  return { path: null, viaProc: false };
 }
 var MAX_PARTIAL_BUFFER = 256 * 1024;
 var MAX_REPLAY_TURNS = 1e3;
 var POLL_INTERVAL_MS = 800;
 var DOC_READ_DEBOUNCE_MS = 200;
 var REDISCOVERY_INTERVAL_MS = 5e3;
+var MARKDOWN_RESYNC_DRAIN_MS = 300;
 var ENABLE_RETRY_DELAYS_MS = [1e3, 2e3, 5e3];
 var TranscriptWatcher = class {
   filePath;
@@ -3662,6 +3841,9 @@ var TranscriptWatcher = class {
       return;
     }
     const ops = this.parserV2.parseDocument(content);
+    if (ops.length === 0 && this.snapshot.turnOrder.length > 0) {
+      return;
+    }
     let nextSnapshot = createEmptySnapshot(this.snapshot.sessionId);
     if (ops.length > 0) {
       nextSnapshot = applyOps(nextSnapshot, ops);
@@ -3752,6 +3934,12 @@ var TranscriptWatcher = class {
     }
     this.documentFingerprint = fingerprint;
     const parsedTurns = this.parser.parseDocument?.(content) ?? [];
+    const v2Ops = this.parserV2?.parseDocument?.(content) ?? [];
+    const parsedNothing = parsedTurns.length === 0 && v2Ops.length === 0;
+    const haveContent = this.turns.length > 0 || this.snapshot.turnOrder.length > 0;
+    if (parsedNothing && haveContent) {
+      return;
+    }
     this.seq++;
     this.turns = parsedTurns.slice(-MAX_REPLAY_TURNS).map((turn) => ({
       turnId: turn.turnId,
@@ -3762,10 +3950,9 @@ var TranscriptWatcher = class {
     }));
     this.callbacks.onTurnsSnapshot?.(this.turns, this.seq);
     if (this.parserV2?.parseDocument && this.callbacks.onSnapshot) {
-      const ops = this.parserV2.parseDocument(content);
       let nextSnapshot = createEmptySnapshot(this.snapshot.sessionId);
-      if (ops.length > 0) {
-        nextSnapshot = applyOps(nextSnapshot, ops);
+      if (v2Ops.length > 0) {
+        nextSnapshot = applyOps(nextSnapshot, v2Ops);
       }
       this.snapshot = trimSnapshot(nextSnapshot);
       this.callbacks.onSnapshot(this.snapshot, this.seq);
@@ -3825,6 +4012,9 @@ function getParser(agentType) {
 var TranscriptWatcherManager = class {
   active = /* @__PURE__ */ new Map();
   rediscoveryTimers = /* @__PURE__ */ new Map();
+  /** #542: sessions awaiting a markdown snapshot re-emit after a frame drop. */
+  pendingMarkdownResync = /* @__PURE__ */ new Set();
+  markdownResyncTimer;
   /** Pending retry timer per session for #483 (no_transcript / watch_failed). */
   enableRetryTimers = /* @__PURE__ */ new Map();
   /** Index into ENABLE_RETRY_DELAYS_MS for the next scheduled attempt. */
@@ -3865,7 +4055,11 @@ var TranscriptWatcherManager = class {
     const existing = this.active.get(sessionId);
     let replacingExisting = false;
     if (existing) {
-      const newPath = discoverTranscriptFile(sessionId, agentType, true);
+      const newPath = discoverTranscriptFileDetailed(
+        sessionId,
+        agentType,
+        this.ownedPathsExcept(sessionId)
+      ).path;
       const agentChanged = existing.agentType !== requestedAgentType;
       const pathChanged = Boolean(newPath && newPath !== existing.filePath);
       const existingPathGone = !fs2.existsSync(existing.filePath);
@@ -3890,7 +4084,11 @@ var TranscriptWatcherManager = class {
       this.cancelEnableRetry(sessionId);
       return { ok: false, reason: "unsupported_agent" };
     }
-    const filePath = discoverTranscriptFile(sessionId, agentType, isRetry || replacingExisting);
+    const filePath = discoverTranscriptFileDetailed(
+      sessionId,
+      agentType,
+      this.ownedPathsExcept(sessionId)
+    ).path;
     if (!filePath) {
       log7.info("no transcript file found", { sessionId });
       this.armEnableRetry(sessionId, agentType);
@@ -3990,6 +4188,22 @@ var TranscriptWatcherManager = class {
       this.sendV2SnapshotFn(sessionId, createEmptySnapshot(sessionId), 0);
     }
   }
+  /**
+   * Paths currently bound to OTHER live sessions. Passed to discovery so two
+   * sessions in one folder (or two same-tool sessions) never resolve to the
+   * same transcript via newest-mtime. The session's own file is never excluded
+   * (so it can keep/rebind it); /proc fd discovery ignores this set entirely.
+   * #540.
+   */
+  ownedPathsExcept(sessionId) {
+    const owned = /* @__PURE__ */ new Set();
+    for (const [sid, session] of this.active) {
+      if (sid !== sessionId && session.filePath) {
+        owned.add(session.filePath);
+      }
+    }
+    return owned;
+  }
   /** Disable markdown streaming for a session. */
   disableMarkdown(sessionId) {
     this.cancelEnableRetry(sessionId);
@@ -4005,6 +4219,7 @@ var TranscriptWatcherManager = class {
     }
     this.active.delete(sessionId);
     this.stopRediscovery(sessionId);
+    this.pendingMarkdownResync.delete(sessionId);
     log7.info("stopped watching transcript", { sessionId });
   }
   /** Periodically check if the transcript file has changed (new conversation). */
@@ -4016,7 +4231,11 @@ var TranscriptWatcherManager = class {
         this.stopRediscovery(sessionId);
         return;
       }
-      const newPath = discoverTranscriptFile(sessionId, agentType, true);
+      const { path: newPath } = discoverTranscriptFileDetailed(
+        sessionId,
+        agentType,
+        this.ownedPathsExcept(sessionId)
+      );
       if (!newPath || newPath === session.filePath) return;
       log7.info("transcript file changed", { sessionId, newPath });
       session.watcher.stop();
@@ -4078,8 +4297,62 @@ var TranscriptWatcherManager = class {
       this.sendV2SnapshotFn(sessionId, snapshot, session.watcher.currentSeq);
     }
   }
+  /**
+   * #542: re-emit markdown snapshots after the WS dropped frames under
+   * backpressure. The large V2 snapshot is sent as a single un-chunked frame
+   * and is the prime drop victim, but — unlike tmux-pipe terminal streams,
+   * which resync via capture-pane — the markdown channel had no recovery path,
+   * so a dropped snapshot left the read view permanently partial until a
+   * reconnect. Re-emit the V2 snapshot for every session that currently holds
+   * content, draining one per tick so the (large) snapshots don't immediately
+   * re-saturate the queue.
+   */
+  resyncMarkdownAfterDrop() {
+    if (!this.sendV2SnapshotFn) return;
+    let queued = false;
+    for (const [sessionId, session] of this.active) {
+      if (session.watcher.getSnapshot().turnOrder.length > 0) {
+        this.pendingMarkdownResync.add(sessionId);
+        queued = true;
+      }
+    }
+    if (!queued || this.markdownResyncTimer) return;
+    this.markdownResyncTimer = setInterval(() => {
+      if (this.pendingMarkdownResync.size === 0) {
+        this.stopMarkdownResync();
+        return;
+      }
+      if (getQueuePressure().isHigh) return;
+      const next = this.pendingMarkdownResync.values().next();
+      if (next.done) {
+        this.stopMarkdownResync();
+        return;
+      }
+      const sessionId = next.value;
+      this.pendingMarkdownResync.delete(sessionId);
+      const session = this.active.get(sessionId);
+      if (session && this.sendV2SnapshotFn) {
+        this.sendV2SnapshotFn(
+          sessionId,
+          session.watcher.getSnapshot(),
+          session.watcher.currentSeq
+        );
+      }
+    }, MARKDOWN_RESYNC_DRAIN_MS);
+    if (typeof this.markdownResyncTimer.unref === "function") {
+      this.markdownResyncTimer.unref();
+    }
+  }
+  stopMarkdownResync() {
+    if (this.markdownResyncTimer) {
+      clearInterval(this.markdownResyncTimer);
+      this.markdownResyncTimer = void 0;
+    }
+    this.pendingMarkdownResync.clear();
+  }
   /** Stop all watchers. */
   stopAll() {
+    this.stopMarkdownResync();
     for (const [sessionId, session] of this.active) {
       session.watcher.stop();
       this.stopRediscovery(sessionId);
@@ -10575,155 +10848,6 @@ var OutputBuffer = class {
   }
 };
 
-// src/websocket.ts
-var import_ws = __toESM(require("ws"));
-var BACKPRESSURE_HIGH_WATER = 256 * 1024;
-var BACKPRESSURE_LOW_WATER = 64 * 1024;
-var MAX_PENDING_QUEUE = 500;
-var DRAIN_INTERVAL_MS = 50;
-function sanitizeForJson(str) {
-  return str.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD");
-}
-var DANGEROUS_OSC_RE = /\x1b\](?:52|7|8);[^\x07\x1b]*(?:\x07|\x1b\\)/g;
-function stripDangerousEscapes(str) {
-  return str.replace(DANGEROUS_OSC_RE, "");
-}
-var SECRET_PATTERNS = [
-  /AKIA[0-9A-Z]{16}/g,
-  // AWS access key
-  /gh[ps]_[A-Za-z0-9_]{36,}/g,
-  // GitHub token
-  /sk_(?:live|test)_[A-Za-z0-9]{24,}/g,
-  // Stripe secret key
-  /eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}/g
-  // JWT
-];
-var redactionEnabled = true;
-function setRedactionEnabled(enabled) {
-  redactionEnabled = enabled;
-}
-function redactSecrets(str) {
-  if (!redactionEnabled) return str;
-  let result = str;
-  for (const pattern of SECRET_PATTERNS) {
-    pattern.lastIndex = 0;
-    result = result.replace(pattern, "[REDACTED]");
-  }
-  return result;
-}
-var streamingTails = /* @__PURE__ */ new Map();
-var MAX_STREAMING_TAIL = 1024;
-var SECRET_PREFIX_RE = /(?:AKIA[0-9A-Z]*|gh[ps]_[A-Za-z0-9_]*|sk_(?:live|test)_[A-Za-z0-9]*|eyJ[A-Za-z0-9_-]*(?:\.[A-Za-z0-9_-]*){0,2})$/;
-function redactStreamingChunk(sessionId, chunk) {
-  if (!redactionEnabled) return chunk;
-  const prevTail = streamingTails.get(sessionId) ?? "";
-  const combined = prevTail + chunk;
-  const redacted = redactSecrets(combined);
-  const prefix = SECRET_PREFIX_RE.exec(redacted);
-  if (prefix && prefix.index + prefix[0].length === redacted.length && redacted.length - prefix.index <= MAX_STREAMING_TAIL) {
-    streamingTails.set(sessionId, redacted.slice(prefix.index));
-    return redacted.slice(0, prefix.index);
-  }
-  streamingTails.delete(sessionId);
-  return redacted;
-}
-function flushStreamingRedaction(sessionId) {
-  const tail = streamingTails.get(sessionId) ?? "";
-  streamingTails.delete(sessionId);
-  return redactionEnabled ? redactSecrets(tail) : tail;
-}
-var pendingQueue = [];
-var drainTimer = null;
-var drainWs = null;
-var droppedFrames = 0;
-var PRESSURE_HIGH = 0.75;
-var PRESSURE_LOW = 0.25;
-var pressureIsHigh = false;
-function getQueuePressure() {
-  const level = pendingQueue.length / MAX_PENDING_QUEUE;
-  if (level >= PRESSURE_HIGH) pressureIsHigh = true;
-  else if (level < PRESSURE_LOW) pressureIsHigh = false;
-  return { level, isHigh: pressureIsHigh };
-}
-function getDroppedFrameCount() {
-  return droppedFrames;
-}
-function drainQueue() {
-  if (!drainWs || drainWs.readyState !== import_ws.default.OPEN) {
-    stopDrainTimer();
-    return;
-  }
-  while (pendingQueue.length > 0 && drainWs.bufferedAmount < BACKPRESSURE_LOW_WATER) {
-    const frame = pendingQueue.shift();
-    drainWs.send(frame);
-  }
-  if (pendingQueue.length === 0) {
-    stopDrainTimer();
-  }
-}
-function startDrainTimer(ws) {
-  drainWs = ws;
-  if (!drainTimer) {
-    drainTimer = setInterval(drainQueue, DRAIN_INTERVAL_MS);
-  }
-}
-function stopDrainTimer() {
-  if (drainTimer) {
-    clearInterval(drainTimer);
-    drainTimer = null;
-  }
-  drainWs = null;
-}
-function sendToGroup(ws, group, data) {
-  if (!group || ws.readyState !== import_ws.default.OPEN) return;
-  const sanitized = sanitizePayload(data);
-  const frame = JSON.stringify({
-    type: "sendToGroup",
-    group,
-    dataType: "json",
-    data: sanitized,
-    noEcho: true
-  });
-  if (ws.bufferedAmount > BACKPRESSURE_HIGH_WATER) {
-    if (pendingQueue.length >= MAX_PENDING_QUEUE) {
-      pendingQueue.shift();
-      droppedFrames++;
-      if (droppedFrames % 100 === 1) {
-        console.warn(`[rAgent] Backpressure: dropped ${droppedFrames} frames (queue full at ${MAX_PENDING_QUEUE})`);
-      }
-    }
-    pendingQueue.push(frame);
-    startDrainTimer(ws);
-    return;
-  }
-  if (pendingQueue.length > 0) {
-    pendingQueue.push(frame);
-    drainWs = ws;
-    drainQueue();
-    return;
-  }
-  ws.send(frame);
-}
-function sanitizeValue(value) {
-  if (typeof value === "string") {
-    return redactSecrets(stripDangerousEscapes(sanitizeForJson(value)));
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => sanitizeValue(item));
-  }
-  if (value !== null && typeof value === "object") {
-    return sanitizePayload(value);
-  }
-  return value;
-}
-function sanitizePayload(obj) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    result[key] = sanitizeValue(value);
-  }
-  return result;
-}
-
 // src/session-streamer.ts
 var import_node_child_process2 = require("child_process");
 var import_node_fs = require("fs");
@@ -10738,13 +10862,14 @@ var MAX_CONCURRENT_STREAMS = 20;
 var MAX_SESSION_BUFFER_BYTES = 64 * 1024;
 var PRIVATE_MODE_SEQUENCE_RE = /\x1b\[\?([0-9;]*)([hl])/g;
 var ALT_SCREEN_PARAMS = /* @__PURE__ */ new Set(["47", "1047", "1048", "1049"]);
+var MOUSE_MODE_PARAMS = /* @__PURE__ */ new Set(["9", "1000", "1002", "1003", "1005", "1006", "1015", "1016"]);
 function stripAlternateScreenModeSwitches(data) {
   return data.replace(
     PRIVATE_MODE_SEQUENCE_RE,
     (full, params, action) => {
       if (!params) return full;
       const parts = params.split(";");
-      const filtered = parts.filter((p) => !ALT_SCREEN_PARAMS.has(p));
+      const filtered = parts.filter((p) => !ALT_SCREEN_PARAMS.has(p) && !MOUSE_MODE_PARAMS.has(p));
       if (filtered.length === parts.length) return full;
       if (filtered.length === 0) return "";
       return `\x1B[?${filtered.join(";")}${action}`;
@@ -10769,6 +10894,18 @@ var AlternateScreenModeStripper = class {
     return stripAlternateScreenModeSwitches(pending);
   }
 };
+function buildRelativeCursorSync(lineCount, x, y) {
+  if (lineCount <= 0) return "";
+  let seq = "";
+  if (y <= lineCount - 1) {
+    const up = lineCount - 1 - y;
+    if (up > 0) seq += `\x1B[${up}A`;
+  } else {
+    seq += "\r\n".repeat(y - (lineCount - 1));
+  }
+  seq += `\x1B[${x + 1}G`;
+  return seq;
+}
 function parsePaneTarget(sessionId) {
   if (!sessionId.startsWith("tmux:")) return null;
   const rest = sessionId.slice("tmux:".length);
@@ -10824,6 +10961,11 @@ var SessionStreamer = class {
   pendingStops = /* @__PURE__ */ new Map();
   sendFn;
   onStreamStopped;
+  sendResetFn;
+  /** #542: invoked once when a new backpressure frame-drop is detected, so the
+   *  markdown channel can recover (the terminal channel resyncs via tmux-pipe
+   *  capture, but the markdown snapshot had no recovery path). */
+  onFramesDropped;
   /**
    * Per-session ring buffer for output captured while the WebSocket is disconnected.
    * Each entry is a string chunk; oldest entries are evicted when the total byte
@@ -10837,9 +10979,11 @@ var SessionStreamer = class {
   lastSeenDroppedFrames = 0;
   /** Sessions whose viewers need a capture-pane resync after frame drops. */
   pendingDropResync = /* @__PURE__ */ new Set();
-  constructor(sendFn, onStreamStopped) {
+  constructor(sendFn, onStreamStopped, sendResetFn, onFramesDropped) {
     this.sendFn = sendFn;
     this.onStreamStopped = onStreamStopped;
+    this.sendResetFn = sendResetFn;
+    this.onFramesDropped = onFramesDropped;
     this.cleanupStaleStreams();
     this.startBackpressureResumeTimer();
   }
@@ -10883,6 +11027,7 @@ var SessionStreamer = class {
           droppedTotal: dropped,
           streams: this.pendingDropResync.size
         });
+        this.onFramesDropped?.();
       }
       const next = this.pendingDropResync.values().next();
       if (!next.done) {
@@ -11123,84 +11268,141 @@ var SessionStreamer = class {
   }
   /**
    * Re-send capture-pane data for an already-active tmux stream.
-   * Used when a viewer missed the initial burst (e.g. joinGroup race)
-   * or reconnected ("Retry stream"). Does NOT restart pipe-pane.
+   * Used when a viewer missed the initial burst (e.g. joinGroup race),
+   * reconnected, resized, or after backpressure frame drops corrupted the
+   * stream. Does NOT restart pipe-pane.
+   *
+   * Default is a LEAN repaint: visible pane + cursor only. Replaying
+   * scrollback mid-session shoved thousands of lines of old output into
+   * live viewers ("ghost text") on every resize/heal. Pass
+   * `{ scrollback: true }` only for viewer (re)attach, where the replay is
+   * prefixed with ED3 (`\x1b[3J`) so the viewer's existing scrollback is
+   * cleared first instead of duplicated.
    */
-  resyncStream(sessionId, viewerId) {
+  resyncStream(sessionId, viewerId, opts) {
     const stream = this.active.get(sessionId);
     if (!stream || stream.stopped || stream.streamType !== "tmux-pipe") return false;
     const { paneTarget, cleanEnv } = stream;
     if (!paneTarget || !cleanEnv) return false;
     const targetViewerId = viewerId?.trim() || void 0;
-    const send = (data) => {
-      if (targetViewerId) {
-        this.sendFn(sessionId, data, targetViewerId);
-      } else {
-        this.sendFn(sessionId, data);
-      }
-    };
+    const withScrollback = opts?.scrollback === true;
+    if (stream.initializing) {
+      const pending = stream.pendingResyncs ??= [];
+      const duplicate = pending.some(
+        (p) => p.viewerId === targetViewerId && p.scrollback === withScrollback
+      );
+      if (!duplicate) pending.push({ viewerId: targetViewerId, scrollback: withScrollback });
+      return true;
+    }
+    stream.initBuffer = [];
     stream.initializing = true;
-    try {
-      let alternateScreen = false;
-      try {
-        const altFlag = (0, import_node_child_process2.execFileSync)(
-          "tmux",
-          ["display-message", "-t", paneTarget, "-p", "#{alternate_on}"],
-          { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
-        ).trim();
-        alternateScreen = altFlag === "1";
-      } catch {
+    setImmediate(() => {
+      if (stream.stopped) {
+        stream.initializing = false;
+        stream.initBuffer = [];
+        return;
       }
+      const send = (data) => {
+        if (targetViewerId) {
+          this.sendFn(sessionId, data, targetViewerId);
+        } else {
+          this.sendFn(sessionId, data);
+        }
+      };
       try {
-        const scrollback = (0, import_node_child_process2.execFileSync)(
-          "tmux",
-          ["capture-pane", "-t", paneTarget, "-p", "-e", "-S", "-5000", "-E", "-1"],
-          { env: cleanEnv, timeout: 1e4, encoding: "utf-8" }
-        );
-        if (scrollback && scrollback.length > 0) {
-          send(scrollback.replace(/\n/g, "\r\n"));
+        this.sendResetFn?.(sessionId, withScrollback ? "full" : "repaint", targetViewerId);
+        const alternateScreen = this.detectAlternateScreen(paneTarget, cleanEnv);
+        if (withScrollback) {
+          send("\x1B[3J");
+          try {
+            const scrollback = (0, import_node_child_process2.execFileSync)(
+              "tmux",
+              ["capture-pane", "-t", paneTarget, "-p", "-e", "-S", "-5000", "-E", "-1"],
+              { env: cleanEnv, timeout: 1e4, encoding: "utf-8" }
+            );
+            if (scrollback && scrollback.length > 0) {
+              send(scrollback.replace(/\n/g, "\r\n"));
+            }
+          } catch {
+          }
+        }
+        send("\x1B[?1049l\x1B[0m\x1B[2J\x1B[H");
+        const lineCount = this.sendVisiblePane(send, paneTarget, cleanEnv, alternateScreen);
+        this.sendCursorSync(send, paneTarget, cleanEnv, lineCount);
+        log17.info("resync capture", { sessionId, mode: withScrollback ? "full" : "repaint" });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log17.warn("failed to resync stream", { sessionId, error: message });
+      } finally {
+        stream.initializing = false;
+        stream.initBuffer = [];
+        const next = stream.pendingResyncs?.shift();
+        if (next && !stream.stopped) {
+          this.resyncStream(sessionId, next.viewerId, { scrollback: next.scrollback });
         }
-      } catch {
       }
-      send("\x1B[?1049l\x1B[0m\x1B[2J\x1B[H");
-      try {
-        const captureArgs = alternateScreen ? ["capture-pane", "-a", "-t", paneTarget, "-p", "-e"] : ["capture-pane", "-t", paneTarget, "-p", "-e"];
-        const initial = (0, import_node_child_process2.execFileSync)(
-          "tmux",
-          captureArgs,
-          { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+    });
+    return true;
+  }
+  /** Detect whether the pane is using the alternate screen buffer. */
+  detectAlternateScreen(paneTarget, cleanEnv) {
+    try {
+      const altFlag = (0, import_node_child_process2.execFileSync)(
+        "tmux",
+        ["display-message", "-t", paneTarget, "-p", "#{alternate_on}"],
+        { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+      ).trim();
+      return altFlag === "1";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Capture and send the visible pane content. Converts bare \n to \r\n for
+   * xterm.js and strips the trailing \r\n to prevent an extra scroll that
+   * would shift the viewport by 1 row. Returns the number of lines sent
+   * (0 when the capture failed or was empty) for relative cursor sync.
+   */
+  sendVisiblePane(send, paneTarget, cleanEnv, alternateScreen) {
+    try {
+      const captureArgs = alternateScreen ? ["capture-pane", "-a", "-t", paneTarget, "-p", "-e"] : ["capture-pane", "-t", paneTarget, "-p", "-e"];
+      const initial = (0, import_node_child_process2.execFileSync)(
+        "tmux",
+        captureArgs,
+        { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+      );
+      if (initial) {
+        const converted = stripAlternateScreenModeSwitches(
+          initial.replace(/\n/g, "\r\n").replace(/\r\n$/, "")
         );
-        if (initial) {
-          send(stripAlternateScreenModeSwitches(initial.replace(/\n/g, "\r\n").replace(/\r\n$/, "")));
+        if (converted) {
+          send(converted);
+          return converted.split("\r\n").length;
         }
-      } catch {
       }
-      try {
-        const cursorInfo = (0, import_node_child_process2.execFileSync)(
-          "tmux",
-          ["display-message", "-t", paneTarget, "-p", "#{cursor_x} #{cursor_y}"],
-          { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
-        ).trim();
-        const parts = cursorInfo.split(" ");
-        if (parts.length === 2) {
-          const x = parseInt(parts[0], 10);
-          const y = parseInt(parts[1], 10);
-          if (!isNaN(x) && !isNaN(y)) {
-            send(`\x1B[${y + 1};${x + 1}H`);
-          }
+    } catch {
+    }
+    return 0;
+  }
+  /** Query the tmux cursor position and send a relative cursor sync. */
+  sendCursorSync(send, paneTarget, cleanEnv, lineCount) {
+    if (lineCount <= 0) return;
+    try {
+      const cursorInfo = (0, import_node_child_process2.execFileSync)(
+        "tmux",
+        ["display-message", "-t", paneTarget, "-p", "#{cursor_x} #{cursor_y}"],
+        { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
+      ).trim();
+      const parts = cursorInfo.split(" ");
+      if (parts.length === 2) {
+        const x = parseInt(parts[0], 10);
+        const y = parseInt(parts[1], 10);
+        if (!isNaN(x) && !isNaN(y)) {
+          const seq = buildRelativeCursorSync(lineCount, x, y);
+          if (seq) send(seq);
         }
-      } catch {
       }
-      stream.initializing = false;
-      stream.initBuffer = [];
-      log17.info("resync capture", { sessionId });
-      return true;
-    } catch (error) {
-      stream.initializing = false;
-      stream.initBuffer = [];
-      const message = error instanceof Error ? error.message : String(error);
-      log17.warn("failed to resync stream", { sessionId, error: message });
-      return false;
+    } catch {
     }
   }
   // ---------------------------------------------------------------------------
@@ -11285,17 +11487,10 @@ var SessionStreamer = class {
           this.onStreamStopped?.(sessionId);
         }
       });
-      let alternateScreen = false;
-      try {
-        const altFlag = (0, import_node_child_process2.execFileSync)(
-          "tmux",
-          ["display-message", "-t", paneTarget, "-p", "#{alternate_on}"],
-          { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
-        ).trim();
-        alternateScreen = altFlag === "1";
-      } catch {
-      }
+      this.sendResetFn?.(sessionId, "full");
+      const alternateScreen = this.detectAlternateScreen(paneTarget, cleanEnv);
       stream.alternateScreen = alternateScreen;
+      this.sendFn(sessionId, "\x1B[3J");
       try {
         const scrollback = (0, import_node_child_process2.execFileSync)(
           "tmux",
@@ -11308,34 +11503,9 @@ var SessionStreamer = class {
       } catch {
       }
       this.sendFn(sessionId, "\x1B[?1049l\x1B[0m\x1B[2J\x1B[H");
-      try {
-        const captureArgs = alternateScreen ? ["capture-pane", "-a", "-t", paneTarget, "-p", "-e"] : ["capture-pane", "-t", paneTarget, "-p", "-e"];
-        const initial = (0, import_node_child_process2.execFileSync)(
-          "tmux",
-          captureArgs,
-          { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
-        );
-        if (initial) {
-          this.sendFn(sessionId, stripAlternateScreenModeSwitches(initial.replace(/\n/g, "\r\n").replace(/\r\n$/, "")));
-        }
-      } catch {
-      }
-      try {
-        const cursorInfo = (0, import_node_child_process2.execFileSync)(
-          "tmux",
-          ["display-message", "-t", paneTarget, "-p", "#{cursor_x} #{cursor_y}"],
-          { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
-        ).trim();
-        const parts = cursorInfo.split(" ");
-        if (parts.length === 2) {
-          const x = parseInt(parts[0], 10);
-          const y = parseInt(parts[1], 10);
-          if (!isNaN(x) && !isNaN(y)) {
-            this.sendFn(sessionId, `\x1B[${y + 1};${x + 1}H`);
-          }
-        }
-      } catch {
-      }
+      const sendBroadcast = (data) => this.sendFn(sessionId, data);
+      const lineCount = this.sendVisiblePane(sendBroadcast, paneTarget, cleanEnv, alternateScreen);
+      this.sendCursorSync(sendBroadcast, paneTarget, cleanEnv, lineCount);
       stream.initializing = false;
       stream.initBuffer = [];
       log17.info("started streaming (tmux)", { sessionId, pane: paneTarget });
@@ -11697,6 +11867,11 @@ var ANSI_KEY_SEQUENCES = /* @__PURE__ */ new Map([
   ["\x1B[6~", "PageDown"]
 ]);
 var ANSI_KEY_ENTRIES = Array.from(ANSI_KEY_SEQUENCES.entries());
+var MOUSE_OR_FOCUS_REPORT_RE = /\x1b\[(?:<\d+;\d+;\d+[Mm]|\d+;\d+;\d+M|M[\x20-\xFF]{3}|[IO])/g;
+function sanitizeRemoteInput(data) {
+  if (!data.includes("\x1B[")) return data;
+  return data.replace(MOUSE_OR_FOCUS_REPORT_RE, "");
+}
 function controlKeyName(charCode) {
   if (charCode >= 1 && charCode <= 26) {
     return `C-${String.fromCharCode(charCode + 96)}`;
@@ -11727,7 +11902,8 @@ function appendLiteralSegment(segments, value) {
     segments.push({ kind: "literal", value });
   }
 }
-function encodeTmuxInput(data) {
+function encodeTmuxInput(rawData) {
+  const data = sanitizeRemoteInput(rawData);
   const segments = [];
   let literal = "";
   const flushLiteral = () => {
@@ -12075,6 +12251,7 @@ var InventoryManager = class {
 
 // src/connection-manager.ts
 var import_ws3 = __toESM(require("ws"));
+var import_node_crypto2 = require("crypto");
 var log21 = createLogger("connection");
 var OPPORTUNISTIC_INVENTORY_SYNC_MS = 1200;
 var MIN_INVENTORY_SYNC_GAP_MS = 1500;
@@ -12085,6 +12262,16 @@ var ConnectionManager = class {
   reconnectDelay = DEFAULT_RECONNECT_DELAY_MS;
   /** Outbound frame counter; reset on every new handshake. See #310. */
   txSeq = new SequenceTracker();
+  /**
+   * Per-process stream epoch, announced in the `register` message. The
+   * sessionKey is derived from the (stable) hostId, so it does NOT change when
+   * the CLI process restarts — but `txSeq` resets to 1 on a fresh process. A
+   * portal holding a high lastSeq would then reject every restarted frame as
+   * out-of-order and silently drop it forever. The portal resets its inbound
+   * trackers when this epoch changes, recovering the stream without a manual
+   * refresh. A new value per ConnectionManager == per CLI process. See #543.
+   */
+  streamEpoch = (0, import_node_crypto2.randomUUID)();
   /**
    * Inbound frame trackers, keyed by viewerId. The portal's Terminal.tsx
    * initializes a fresh txSeq (starting at 1) on every component mount, so a
@@ -13310,7 +13497,9 @@ var ControlDispatcher = class {
     this.handleInput(writtenPath, sessionId);
   }
   /** Handle input routing to the correct target. */
-  handleInput(data, sessionId) {
+  handleInput(rawData, sessionId) {
+    const data = sanitizeRemoteInput(rawData);
+    if (!data) return;
     if (!sessionId || sessionId.startsWith("pty:")) {
       this.shell.write(data);
     } else if (sessionId.startsWith("tmux:")) {
@@ -13689,12 +13878,11 @@ var ControlDispatcher = class {
     const viewerKey = viewerId?.trim() || "";
     if (sessionId.startsWith("tmux:") || sessionId.startsWith("screen:") || sessionId.startsWith("zellij:") || sessionId.startsWith("process:")) {
       const alreadyStreaming = this.streamer.isStreaming(sessionId);
-      const viewerAlreadyAttached = alreadyStreaming && this.streamer.hasViewer(sessionId, viewerKey);
       const started = this.streamer.startStream(sessionId, viewerId ?? void 0);
       if (ws && ws.readyState === import_ws4.default.OPEN && group) {
         if (started) {
-          if (alreadyStreaming && !viewerAlreadyAttached) {
-            this.streamer.resyncStream(sessionId, viewerKey);
+          if (alreadyStreaming) {
+            this.streamer.resyncStream(sessionId, viewerKey, { scrollback: true });
           }
           const dims = this.queryPaneDimensions(sessionId);
           sendToGroup(ws, group, { type: "stream-started", sessionId, ...dims });
@@ -13769,7 +13957,7 @@ function validateProvisionRequest(payload) {
 }
 
 // src/approval-policy.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 function hasToken(cmd, token) {
   const lower = cmd.toLowerCase();
   const t = token.toLowerCase();
@@ -13876,7 +14064,7 @@ function matchPolicy(command, _policy = DEFAULT_APPROVAL_POLICY, hostId = "", se
   for (const matcher of MATCHERS) {
     if (matcher.test(command)) {
       return {
-        requestId: (0, import_node_crypto2.randomUUID)(),
+        requestId: (0, import_node_crypto3.randomUUID)(),
         hostId,
         sessionId,
         action: matcher.action,
@@ -14308,6 +14496,27 @@ async function runAgent(rawOptions) {
       }
       if (!conn.isReady()) return;
       sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, { type: "stream-stopped", sessionId });
+    },
+    (sessionId, mode, viewerId) => {
+      if (!conn.isReady()) return;
+      const tail = flushStreamingRedaction(sessionId);
+      if (tail) {
+        if (conn.sessionKey) {
+          const { enc, iv, seq } = encryptPayload(tail, conn.sessionKey, conn.txSeq.next());
+          sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, { type: "output", enc, iv, seq, sessionId });
+        } else {
+          sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, { type: "output", data: tail, sessionId });
+        }
+      }
+      sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, {
+        type: "stream-reset",
+        sessionId,
+        mode,
+        ...viewerId ? { viewerId } : {}
+      });
+    },
+    () => {
+      transcriptWatcher.resyncMarkdownAfterDrop();
     }
   );
   const conn = new ConnectionManager(sessionStreamer, outputBuffer);
@@ -14514,7 +14723,11 @@ async function runAgent(rawOptions) {
             sendToGroup(ws, groups.privateGroup, {
               type: "register",
               hostName: options.hostName,
-              environment: os10.platform()
+              environment: os10.platform(),
+              // #543: lets the portal detect a CLI process restart (txSeq reset
+              // to 1 under a host-stable sessionKey) and reset its inbound
+              // sequence trackers so restarted frames aren't dropped forever.
+              streamEpoch: conn.streamEpoch
             });
             conn.replayBufferedOutput((chunk) => {
               for (const outputChunk of splitTransportChunks(chunk)) {