ragent-cli 1.11.18 → 1.11.21

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "ragent-cli",
-      version: "1.11.18",
+      version: "1.11.21",
       description: "CLI agent for rAgent Live \u2014 browser-first terminal control plane for AI coding agents",
       main: "dist/index.js",
       bin: {
@@ -90,7 +90,7 @@ var require_package = __commonJS({
         commander: "^14.0.3",
         figlet: "^1.9.3",
         "node-pty": "^1.1.0",
-        ws: "^8.19.0"
+        ws: "^8.21.0"
       },
       devDependencies: {
         "@changesets/changelog-github": "^0.5.2",
@@ -421,6 +421,7 @@ var fs2 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
 var import_child_process2 = require("child_process");
+var import_string_decoder = require("string_decoder");
 
 // src/transcript-parser-v2.ts
 var log4 = createLogger("transcript-parser-v2");
@@ -786,6 +787,34 @@ function extractCodexText(content) {
     (c) => (c.type === "input_text" || c.type === "output_text" || c.type === "text") && typeof c.text === "string"
   ).map((c) => c.text).join("\n").trim();
 }
+function normalizeCodexFunctionCallOutput(output) {
+  if (typeof output === "string") return output;
+  if (output == null) return "";
+  const formatPart = (part) => {
+    if (typeof part === "string") return part;
+    if (part == null) return "";
+    if (typeof part !== "object" || Array.isArray(part)) {
+      return String(part);
+    }
+    const content = part;
+    const type = typeof content.type === "string" ? content.type : "";
+    if ((type === "input_text" || type === "output_text" || type === "text") && typeof content.text === "string") {
+      return content.text;
+    }
+    if (type === "input_image" || type === "output_image" || type === "image" || typeof content.image_url === "string") {
+      return "[Image output omitted from transcript]";
+    }
+    try {
+      return JSON.stringify(part);
+    } catch {
+      return "[Unsupported tool output]";
+    }
+  };
+  if (Array.isArray(output)) {
+    return output.map(formatPart).filter((part) => part.length > 0).join("\n");
+  }
+  return formatPart(output);
+}
 function parseCodexArguments(args) {
   if (typeof args !== "string" || !args) return void 0;
   try {
@@ -1081,7 +1110,7 @@ var CodexCliParserV2 = class {
     if (payload.type === "function_call_output") {
       if (!payload.call_id) return [];
       const pending = this.pendingTools.get(payload.call_id);
-      const output = payload.output ?? "";
+      const output = normalizeCodexFunctionCallOutput(payload.output);
       const { state, errorText } = inferCodexFunctionCallOutputState(output);
       if (pending) {
         this.pendingTools.delete(payload.call_id);
@@ -1823,37 +1852,52 @@ function createEmptySnapshot(sessionId) {
   };
 }
 function applyOps(state, ops) {
-  const turns = { ...state.turns };
-  const turnOrder = [...state.turnOrder];
+  return applyReducedOps(state, coalesceAdjacentAppendOps(ops));
+}
+function applyReducedOps(state, ops) {
+  let snapshotFields = state;
+  let turns = { ...state.turns };
+  let turnOrder = [...state.turnOrder];
+  let sizeIndex = getSnapshotSizeIndex(state);
   for (const op of ops) {
+    let changedTurnId;
+    let previousChangedTurn;
+    let addedOrderId;
     switch (op.op) {
       case "upsert_turn": {
         const { turn } = op;
         const existing = turns[turn.turnId];
+        previousChangedTurn = existing;
         if (existing) {
           turns[turn.turnId] = {
             ...existing,
             ...turn,
-            blockOrder: turn.blockOrder ?? existing.blockOrder,
-            blocks: turn.blocks ? { ...existing.blocks, ...turn.blocks } : existing.blocks
+            blockOrder: turn.blockOrder ? [...turn.blockOrder] : existing.blockOrder,
+            blocks: turn.blocks ? { ...existing.blocks, ...cloneBlocks(turn.blocks) } : existing.blocks
           };
         } else {
+          if (snapshotFields.truncatedTurnIds?.includes(turn.turnId)) break;
           turns[turn.turnId] = {
             ...turn,
-            blockOrder: turn.blockOrder ?? [],
-            blocks: turn.blocks ?? {}
+            blockOrder: turn.blockOrder ? [...turn.blockOrder] : [],
+            blocks: turn.blocks ? cloneBlocks(turn.blocks) : {}
           };
           if (!turnOrder.includes(turn.turnId)) {
             turnOrder.push(turn.turnId);
+            addedOrderId = turn.turnId;
           }
         }
+        changedTurnId = turn.turnId;
         break;
       }
       case "insert_block": {
         const turn = turns[op.turnId];
         if (!turn) break;
-        const newBlocks = { ...turn.blocks, [op.block.blockId]: op.block };
-        const newBlockOrder = [...turn.blockOrder];
+        previousChangedTurn = turn;
+        const newBlocks = { ...turn.blocks, [op.block.blockId]: { ...op.block } };
+        const newBlockOrder = turn.blockOrder.filter(
+          (blockId) => blockId !== op.block.blockId
+        );
         if (op.afterBlockId) {
           const idx = newBlockOrder.indexOf(op.afterBlockId);
           if (idx >= 0) {
@@ -1870,28 +1914,33 @@ function applyOps(state, ops) {
           blockOrder: newBlockOrder,
           updatedAt: op.block.updatedAt
         };
+        changedTurnId = op.turnId;
         break;
       }
       case "replace_block": {
         const turn = turns[op.turnId];
         if (!turn || !turn.blocks[op.block.blockId]) break;
+        previousChangedTurn = turn;
         turns[op.turnId] = {
           ...turn,
-          blocks: { ...turn.blocks, [op.block.blockId]: op.block },
+          blocks: { ...turn.blocks, [op.block.blockId]: { ...op.block } },
           updatedAt: op.block.updatedAt
         };
+        changedTurnId = op.turnId;
         break;
       }
       case "append_text": {
         const block = findBlock(turns, op.turnId, op.blockId);
         if (!block) break;
         if (block.kind === "text" || block.kind === "reasoning") {
+          previousChangedTurn = turns[op.turnId];
           const updated = {
             ...block,
-            text: block.text + op.text,
-            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            text: appendProjectedSnapshotText(block, block.text, op.text)
           };
+          refreshTransportTruncation(updated, op.text);
           setBlock(turns, op.turnId, op.blockId, updated);
+          changedTurnId = op.turnId;
         }
         break;
       }
@@ -1900,21 +1949,33 @@ function applyOps(state, ops) {
         if (!block || block.kind !== "tool") {
           const found = findBlockAcrossTurns(turns, op.blockId);
           if (found && found.block.kind === "tool") {
+            previousChangedTurn = turns[found.turnId];
             const updated2 = {
               ...found.block,
-              outputText: (found.block.outputText ?? "") + op.text,
-              updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+              outputText: appendProjectedSnapshotText(
+                found.block,
+                found.block.outputText ?? "",
+                op.text
+              )
             };
+            refreshTransportTruncation(updated2, op.text);
             setBlock(turns, found.turnId, op.blockId, updated2);
+            changedTurnId = found.turnId;
           }
           break;
         }
         const updated = {
           ...block,
-          outputText: (block.outputText ?? "") + op.text,
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          outputText: appendProjectedSnapshotText(
+            block,
+            block.outputText ?? "",
+            op.text
+          )
         };
+        previousChangedTurn = turns[op.turnId];
+        refreshTransportTruncation(updated, op.text);
         setBlock(turns, op.turnId, op.blockId, updated);
+        changedTurnId = op.turnId;
         break;
       }
       case "set_tool_state": {
@@ -1934,10 +1995,11 @@ function applyOps(state, ops) {
           state: op.state,
           ...op.exitCode !== void 0 && { exitCode: op.exitCode },
           ...op.errorText !== void 0 && { errorText: op.errorText },
-          ...op.isComplete !== void 0 && { isComplete: op.isComplete },
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          ...op.isComplete !== void 0 && { isComplete: op.isComplete }
         };
+        previousChangedTurn = turns[resolvedTurnId];
         setBlock(turns, resolvedTurnId, op.blockId, updated);
+        changedTurnId = resolvedTurnId;
         break;
       }
       case "complete_block": {
@@ -1957,27 +2019,93 @@ function applyOps(state, ops) {
           isComplete: true,
           updatedAt: op.updatedAt
         };
+        previousChangedTurn = turns[resolvedTurnId];
         setBlock(turns, resolvedTurnId, op.blockId, updated);
+        changedTurnId = resolvedTurnId;
         break;
       }
       case "complete_turn": {
         const turn = turns[op.turnId];
         if (!turn) break;
+        previousChangedTurn = turn;
         turns[op.turnId] = {
           ...turn,
           isComplete: true,
           endedAt: op.endedAt,
           updatedAt: op.updatedAt
         };
+        changedTurnId = op.turnId;
         break;
       }
     }
+    if (changedTurnId) {
+      updateIndexedTurn(
+        sizeIndex,
+        changedTurnId,
+        previousChangedTurn,
+        turns[changedTurnId]
+      );
+    }
+    if (addedOrderId) addIndexedTurnOrder(sizeIndex, addedOrderId);
+    const projected = projectWorkingSnapshot(
+      snapshotFields,
+      turnOrder,
+      turns,
+      sizeIndex
+    );
+    snapshotFields = projected.snapshotFields;
+    turnOrder = projected.turnOrder;
+    turns = projected.turns;
+    sizeIndex = projected.sizeIndex;
   }
-  return {
-    ...state,
+  const result = {
+    ...snapshotFields,
     turnOrder,
     turns
   };
+  cacheSnapshotSizeIndex(result, sizeIndex);
+  return result;
+}
+function cloneBlocks(blocks) {
+  const cloned = {};
+  for (const [blockId, block] of Object.entries(blocks)) {
+    cloned[blockId] = { ...block };
+  }
+  return cloned;
+}
+function coalesceAdjacentAppendOps(ops) {
+  const result = [];
+  let pending;
+  const flush = () => {
+    if (!pending) return;
+    result.push({
+      op: pending.op,
+      turnId: pending.turnId,
+      blockId: pending.blockId,
+      text: pending.chunks.join("")
+    });
+    pending = void 0;
+  };
+  for (const op of ops) {
+    if (op.op === "append_text" || op.op === "append_tool_output") {
+      if (pending?.op === op.op && pending.turnId === op.turnId && pending.blockId === op.blockId) {
+        pending.chunks.push(op.text);
+      } else {
+        flush();
+        pending = {
+          op: op.op,
+          turnId: op.turnId,
+          blockId: op.blockId,
+          chunks: [op.text]
+        };
+      }
+      continue;
+    }
+    flush();
+    result.push(op);
+  }
+  flush();
+  return result;
 }
 function findBlock(turns, turnId, blockId) {
   return turns[turnId]?.blocks[blockId];
@@ -1999,50 +2127,944 @@ 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 = {};
-    for (const id of keptOrder) {
-      if (currentSnapshot.turns[id]) {
-        keptTurns[id] = currentSnapshot.turns[id];
+var MAX_SNAPSHOT_SIZE_BYTES = 448 * 1024;
+var MAX_TRUNCATED_TURN_ID_BYTES = 16 * 1024;
+var SNAPSHOT_FIELD_RESERVE = MAX_TRUNCATED_TURN_ID_BYTES + 512;
+var MAX_SNAPSHOT_BLOCK_FIELD_BYTES = 96 * 1024;
+var MAX_SNAPSHOT_IDENTIFIER_BYTES = 4 * 1024;
+var MAX_SNAPSHOT_TIMESTAMP_BYTES = 1024;
+var SNAPSHOT_TRUNCATION_MARKER = "\n\n[Content truncated for remote display]\n\n";
+var TRANSPORT_NOTICE_METADATA_KEY = "ragentTransportTruncationNotice";
+var TRANSPORT_OMITTED_BLOCKS_KEY = "ragentTransportOmittedBlocks";
+var utf8Encoder = new TextEncoder();
+function utf8Size(value) {
+  return utf8Encoder.encode(value).byteLength;
+}
+function serializedBytes(value) {
+  return utf8Size(JSON.stringify(value));
+}
+var snapshotSizeCache = /* @__PURE__ */ new WeakMap();
+function cloneSnapshotSizeIndex(index) {
+  return { ...index };
+}
+function snapshotSizeFromIndex(index) {
+  return index.shellBytes + index.orderBytes + index.turnMapBytes;
+}
+function buildSnapshotSizeIndex(snapshot) {
+  const shellBytes = serializedBytes({
+    ...snapshot,
+    turnOrder: [],
+    turns: {}
+  });
+  let orderBytes = 0;
+  for (let index = 0; index < snapshot.turnOrder.length; index++) {
+    orderBytes += utf8Size(JSON.stringify(snapshot.turnOrder[index])) + (index > 0 ? 1 : 0);
+  }
+  let turnMapBytes = 0;
+  let turnIndex = 0;
+  for (const [turnId, turn] of Object.entries(snapshot.turns)) {
+    const bytes = serializedBytes(turn);
+    turnMapBytes += utf8Size(JSON.stringify(turnId)) + 1 + bytes + (turnIndex > 0 ? 1 : 0);
+    turnIndex++;
+  }
+  return {
+    shellBytes,
+    orderBytes,
+    orderCount: snapshot.turnOrder.length,
+    turnMapBytes,
+    turnCount: turnIndex
+  };
+}
+function getSnapshotSizeIndex(snapshot) {
+  const cached = snapshotSizeCache.get(snapshot);
+  return cached ? cloneSnapshotSizeIndex(cached) : buildSnapshotSizeIndex(snapshot);
+}
+function cacheSnapshotSizeIndex(snapshot, index) {
+  snapshotSizeCache.set(snapshot, cloneSnapshotSizeIndex(index));
+}
+function updateIndexedTurn(index, turnId, previousTurn, nextTurn) {
+  const previousBytes = previousTurn ? serializedBytes(previousTurn) : void 0;
+  if (!nextTurn) {
+    if (previousBytes === void 0) return;
+    index.turnMapBytes -= utf8Size(JSON.stringify(turnId)) + 1 + previousBytes + (index.turnCount > 1 ? 1 : 0);
+    index.turnCount--;
+    return;
+  }
+  const nextBytes = serializedBytes(nextTurn);
+  if (previousBytes === void 0) {
+    index.turnMapBytes += utf8Size(JSON.stringify(turnId)) + 1 + nextBytes + (index.turnCount > 0 ? 1 : 0);
+    index.turnCount++;
+  } else {
+    index.turnMapBytes += nextBytes - previousBytes;
+  }
+}
+function addIndexedTurnOrder(index, turnId) {
+  index.orderBytes += utf8Size(JSON.stringify(turnId)) + (index.orderCount > 0 ? 1 : 0);
+  index.orderCount++;
+}
+function removeIndexedTurnOrder(index, turnId) {
+  if (index.orderCount <= 0) return;
+  index.orderBytes -= utf8Size(JSON.stringify(turnId)) + (index.orderCount > 1 ? 1 : 0);
+  index.orderCount--;
+}
+function refreshIndexedShell(index, snapshotFields) {
+  index.shellBytes = serializedBytes({
+    ...snapshotFields,
+    turnOrder: [],
+    turns: {}
+  });
+}
+function projectWorkingSnapshot(initialFields, turnOrder, turns, sizeIndex) {
+  let snapshotFields = initialFields;
+  const sizeBudget = MAX_SNAPSHOT_SIZE_BYTES - SNAPSHOT_FIELD_RESERVE;
+  while ((turnOrder.length > MAX_SNAPSHOT_TURNS || snapshotSizeFromIndex(sizeIndex) > sizeBudget) && turnOrder.length > 1) {
+    const dropped = [];
+    while ((turnOrder.length > MAX_SNAPSHOT_TURNS || snapshotSizeFromIndex(sizeIndex) > sizeBudget) && turnOrder.length > 1) {
+      const turnId = turnOrder.shift();
+      if (!turnId) break;
+      removeIndexedTurnOrder(sizeIndex, turnId);
+      if (!turnOrder.includes(turnId)) {
+        updateIndexedTurn(sizeIndex, turnId, turns[turnId], void 0);
+        delete turns[turnId];
+      }
+      dropped.push(turnId);
+    }
+    if (dropped.length === 0) break;
+    snapshotFields = {
+      ...snapshotFields,
+      truncatedTurns: (snapshotFields.truncatedTurns ?? 0) + dropped.length,
+      truncatedTurnIds: mergeTruncatedTurnIds(
+        snapshotFields.truncatedTurnIds,
+        dropped
+      )
+    };
+    refreshIndexedShell(sizeIndex, snapshotFields);
+  }
+  const soleTurnId = turnOrder.length === 1 ? turnOrder[0] : void 0;
+  const soleTurn = soleTurnId ? turns[soleTurnId] : void 0;
+  const omittedBlocks = soleTurn?.metadata?.[TRANSPORT_OMITTED_BLOCKS_KEY];
+  const missingSyntheticNotice = typeof omittedBlocks === "number" && omittedBlocks > 0 && !soleTurn?.blockOrder.some((blockId) => soleTurn.blocks[blockId]?.metadata?.[TRANSPORT_NOTICE_METADATA_KEY] === true);
+  if (soleTurn && (snapshotSizeFromIndex(sizeIndex) > sizeBudget || missingSyntheticNotice)) {
+    let bounded = boundSingleTurnSnapshot({
+      ...snapshotFields,
+      turnOrder,
+      turns
+    });
+    let boundedIndex = buildSnapshotSizeIndex(bounded);
+    if (snapshotSizeFromIndex(boundedIndex) > MAX_SNAPSHOT_SIZE_BYTES) {
+      bounded = minimalTransportSnapshot(bounded, bounded.truncatedTurns);
+      boundedIndex = buildSnapshotSizeIndex(bounded);
+    }
+    return {
+      snapshotFields: bounded,
+      turnOrder: [...bounded.turnOrder],
+      turns: { ...bounded.turns },
+      sizeIndex: boundedIndex
+    };
+  }
+  return { snapshotFields, turnOrder, turns, sizeIndex };
+}
+function prefixWithinBytes(value, maxBytes) {
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (utf8Size(value.slice(0, mid)) <= maxBytes) low = mid;
+    else high = mid - 1;
+  }
+  if (low > 0 && /[\uD800-\uDBFF]/.test(value[low - 1] ?? "")) low--;
+  return value.slice(0, low);
+}
+function suffixWithinBytes(value, maxBytes) {
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const count = Math.ceil((low + high) / 2);
+    if (utf8Size(value.slice(value.length - count)) <= maxBytes) low = count;
+    else high = count - 1;
+  }
+  let start = value.length - low;
+  if (start < value.length && /[\uDC00-\uDFFF]/.test(value[start] ?? "")) start++;
+  return value.slice(start);
+}
+function truncateSnapshotText(value, maxBytes) {
+  if (utf8Size(value) <= maxBytes) return value;
+  const markerBytes = utf8Size(SNAPSHOT_TRUNCATION_MARKER);
+  if (maxBytes <= markerBytes) {
+    return prefixWithinBytes(SNAPSHOT_TRUNCATION_MARKER, maxBytes);
+  }
+  const available = maxBytes - markerBytes;
+  const markerIndex = value.indexOf(SNAPSHOT_TRUNCATION_MARKER);
+  const headSource = markerIndex >= 0 ? value.slice(0, markerIndex) : value;
+  const tailSource = markerIndex >= 0 ? value.slice(markerIndex + SNAPSHOT_TRUNCATION_MARKER.length) : value;
+  const head = prefixWithinBytes(headSource, Math.floor(available * 0.75));
+  const tail = suffixWithinBytes(tailSource, available - utf8Size(head));
+  return `${head}${SNAPSHOT_TRUNCATION_MARKER}${tail}`;
+}
+function appendProjectedSnapshotText(block, current, addition) {
+  if (block.truncation?.reason === "transport_limit" && current.includes(SNAPSHOT_TRUNCATION_MARKER)) {
+    const markerIndex = current.indexOf(SNAPSHOT_TRUNCATION_MARKER);
+    const head = current.slice(0, markerIndex);
+    const tail = current.slice(markerIndex + SNAPSHOT_TRUNCATION_MARKER.length);
+    const tailBudget = Math.max(
+      0,
+      utf8Size(current) - utf8Size(head) - utf8Size(SNAPSHOT_TRUNCATION_MARKER)
+    );
+    return `${head}${SNAPSHOT_TRUNCATION_MARKER}${suffixWithinBytes(
+      tail + addition,
+      tailBudget
+    )}`;
+  }
+  return current + addition;
+}
+function refreshTransportTruncation(block, _addition) {
+  const projectedText = block.kind === "text" || block.kind === "reasoning" ? block.text : block.kind === "tool" ? block.outputText : void 0;
+  if (block.truncation?.reason !== "transport_limit" || !projectedText?.includes(SNAPSHOT_TRUNCATION_MARKER)) {
+    return;
+  }
+  const { truncation: _truncation, ...withoutTruncation } = block;
+  block.truncation = {
+    reason: "transport_limit",
+    keptBytes: serializedBytes(withoutTruncation),
+    didWarnUser: true
+  };
+}
+function boundSnapshotBlock(block, fieldBudget = MAX_SNAPSHOT_BLOCK_FIELD_BYTES) {
+  const { truncation: existingTruncation, ...originalWithoutTruncation } = block;
+  const originalBytes = serializedBytes(originalWithoutTruncation);
+  let bounded;
+  switch (block.kind) {
+    case "text":
+    case "reasoning":
+      bounded = { ...block, metadata: void 0, text: truncateSnapshotText(block.text, fieldBudget) };
+      break;
+    case "tool": {
+      let input = block.input;
+      if (input !== void 0 && serializedBytes(input) > 16 * 1024) {
+        input = "[Tool input truncated for remote display]";
+      }
+      bounded = {
+        ...block,
+        metadata: void 0,
+        callId: truncateSnapshotText(block.callId, MAX_SNAPSHOT_IDENTIFIER_BYTES),
+        toolName: truncateSnapshotText(block.toolName, 2 * 1024),
+        input,
+        outputText: block.outputText === void 0 ? void 0 : truncateSnapshotText(block.outputText, fieldBudget),
+        errorText: block.errorText === void 0 ? void 0 : truncateSnapshotText(block.errorText, 32 * 1024),
+        outputMimeType: block.outputMimeType === void 0 ? void 0 : truncateSnapshotText(block.outputMimeType, 2 * 1024)
+      };
+      break;
+    }
+    case "status":
+      bounded = {
+        ...block,
+        metadata: void 0,
+        statusType: truncateSnapshotText(block.statusType, 2 * 1024),
+        text: block.text === void 0 ? void 0 : truncateSnapshotText(block.text, 32 * 1024)
+      };
+      break;
+    case "unknown":
+      bounded = {
+        ...block,
+        metadata: void 0,
+        rawKind: truncateSnapshotText(block.rawKind, 2 * 1024),
+        rawPayload: block.rawPayload !== void 0 && serializedBytes(block.rawPayload) > 16 * 1024 ? "[Unknown payload truncated for remote display]" : block.rawPayload,
+        fallbackText: block.fallbackText === void 0 ? void 0 : truncateSnapshotText(block.fallbackText, 32 * 1024)
+      };
+      break;
+    case "attachment":
+      bounded = {
+        ...block,
+        metadata: void 0,
+        mediaType: truncateSnapshotText(block.mediaType, 2 * 1024),
+        name: block.name === void 0 ? void 0 : truncateSnapshotText(block.name, 2 * 1024),
+        uri: block.uri === void 0 ? void 0 : truncateSnapshotText(block.uri, 8 * 1024),
+        path: block.path === void 0 ? void 0 : truncateSnapshotText(block.path, 8 * 1024)
+      };
+      break;
+  }
+  bounded = {
+    ...bounded,
+    blockId: truncateSnapshotText(block.blockId, MAX_SNAPSHOT_IDENTIFIER_BYTES),
+    createdAt: truncateSnapshotText(block.createdAt, MAX_SNAPSHOT_TIMESTAMP_BYTES),
+    updatedAt: truncateSnapshotText(block.updatedAt, MAX_SNAPSHOT_TIMESTAMP_BYTES),
+    metadata: void 0
+  };
+  const { truncation: _boundedTruncation, ...boundedWithoutTruncation } = bounded;
+  const keptBytes = serializedBytes(boundedWithoutTruncation);
+  if (keptBytes < originalBytes || existingTruncation?.reason === "transport_limit") {
+    bounded = {
+      ...boundedWithoutTruncation,
+      truncation: {
+        reason: "transport_limit",
+        keptBytes,
+        didWarnUser: true
+      }
+    };
+  } else if (existingTruncation) {
+    bounded = { ...boundedWithoutTruncation, truncation: existingTruncation };
+  } else {
+    bounded = boundedWithoutTruncation;
+  }
+  return bounded;
+}
+function boundSingleTurnSnapshot(snapshot) {
+  const originalTurnId = snapshot.turnOrder[0];
+  const originalTurn = originalTurnId ? snapshot.turns[originalTurnId] : void 0;
+  if (!originalTurnId || !originalTurn) return snapshot;
+  const turnId = truncateSnapshotText(originalTurnId, MAX_SNAPSHOT_IDENTIFIER_BYTES);
+  const boundedEntries = [];
+  const usedBlockIds = /* @__PURE__ */ new Set();
+  const storedDroppedBlocks = originalTurn.metadata?.[TRANSPORT_OMITTED_BLOCKS_KEY];
+  let previouslyDroppedBlocks = typeof storedDroppedBlocks === "number" ? storedDroppedBlocks : 0;
+  let collisionDrops = 0;
+  const sourceOrder = originalTurn.blockOrder.length > 0 ? originalTurn.blockOrder : Object.keys(originalTurn.blocks);
+  for (const originalBlockId of sourceOrder) {
+    const block = originalTurn.blocks[originalBlockId];
+    if (!block) continue;
+    if (block.kind === "status" && block.metadata?.[TRANSPORT_NOTICE_METADATA_KEY] === true) {
+      const metadataCount = block.metadata.omittedBlocks;
+      const priorCount = typeof metadataCount === "number" ? metadataCount : Number.parseInt(block.text?.match(/(\d+) earlier blocks omitted/)?.[1] ?? "0", 10);
+      previouslyDroppedBlocks = Math.max(
+        previouslyDroppedBlocks,
+        Number.isFinite(priorCount) ? priorCount : 0
+      );
+      continue;
+    }
+    const bounded = boundSnapshotBlock(block);
+    if (usedBlockIds.has(bounded.blockId)) {
+      collisionDrops++;
+      continue;
+    }
+    usedBlockIds.add(bounded.blockId);
+    boundedEntries.push({ id: bounded.blockId, block: bounded });
+  }
+  const boundedTurn = {
+    ...originalTurn,
+    turnId,
+    startedAt: truncateSnapshotText(originalTurn.startedAt, MAX_SNAPSHOT_TIMESTAMP_BYTES),
+    updatedAt: truncateSnapshotText(originalTurn.updatedAt, MAX_SNAPSHOT_TIMESTAMP_BYTES),
+    endedAt: originalTurn.endedAt === void 0 ? void 0 : truncateSnapshotText(originalTurn.endedAt, MAX_SNAPSHOT_TIMESTAMP_BYTES),
+    agent: originalTurn.agent === void 0 ? void 0 : {
+      vendor: originalTurn.agent.vendor === void 0 ? void 0 : truncateSnapshotText(originalTurn.agent.vendor, 2 * 1024),
+      agentType: originalTurn.agent.agentType === void 0 ? void 0 : truncateSnapshotText(originalTurn.agent.agentType, 2 * 1024),
+      name: originalTurn.agent.name === void 0 ? void 0 : truncateSnapshotText(originalTurn.agent.name, 2 * 1024),
+      version: originalTurn.agent.version === void 0 ? void 0 : truncateSnapshotText(originalTurn.agent.version, 2 * 1024),
+      transcriptSource: originalTurn.agent.transcriptSource
+    },
+    metadata: void 0,
+    blockOrder: [],
+    blocks: {}
+  };
+  const build = (entries, notice2, omittedBlocks = previouslyDroppedBlocks + collisionDrops) => {
+    const blockOrder = notice2 ? [notice2.blockId, ...entries.map((entry) => entry.id)] : entries.map((entry) => entry.id);
+    const blocks = {};
+    if (notice2) blocks[notice2.blockId] = notice2;
+    for (const entry of entries) blocks[entry.id] = entry.block;
+    return {
+      ...snapshot,
+      turnOrder: [turnId],
+      turns: {
+        [turnId]: {
+          ...boundedTurn,
+          metadata: omittedBlocks > 0 ? { [TRANSPORT_OMITTED_BLOCKS_KEY]: omittedBlocks } : void 0,
+          blockOrder,
+          blocks
+        }
       }
+    };
+  };
+  const budget = MAX_SNAPSHOT_SIZE_BYTES - SNAPSHOT_FIELD_RESERVE;
+  const emptyResult = build([]);
+  const emptyBytes = serializedBytes(emptyResult);
+  let allEntriesBytes = emptyBytes;
+  for (let index = 0; index < boundedEntries.length; index++) {
+    const entry = boundedEntries[index];
+    allEntriesBytes += utf8Size(JSON.stringify(entry.id)) + utf8Size(JSON.stringify(entry.id)) + 1 + serializedBytes(entry.block) + (index > 0 ? 2 : 0);
+  }
+  const hasVisibleTruncation = boundedEntries.some(({ block }) => block.truncation?.didWarnUser === true || "text" in block && typeof block.text === "string" && block.text.includes("[Content truncated for remote display]"));
+  const sizeRequiresDrops = allEntriesBytes > budget;
+  const knownDrops = previouslyDroppedBlocks + collisionDrops;
+  const needsNotice = knownDrops > 0 || sizeRequiresDrops || !hasVisibleTruncation;
+  let noticeId = "__transport_truncation_notice__";
+  while (usedBlockIds.has(noticeId)) noticeId = `_${noticeId}`;
+  const makeNotice = (droppedBlocks2) => ({
+    blockId: noticeId,
+    kind: "status",
+    statusType: "notice",
+    text: droppedBlocks2 > 0 ? `[Content truncated for remote display] ${droppedBlocks2} earlier blocks omitted.` : "[Content truncated for remote display]",
+    level: "warning",
+    isComplete: true,
+    createdAt: boundedTurn.startedAt,
+    updatedAt: boundedTurn.updatedAt,
+    metadata: {
+      [TRANSPORT_NOTICE_METADATA_KEY]: true,
+      omittedBlocks: droppedBlocks2
     }
-    currentSnapshot = {
-      ...currentSnapshot,
-      turnOrder: keptOrder,
-      turns: keptTurns
+  });
+  const maximumDrops = knownDrops + boundedEntries.length;
+  const reserveNotice = needsNotice ? makeNotice(maximumDrops) : void 0;
+  let retainedBytes = serializedBytes(build([], reserveNotice, maximumDrops));
+  let retainedCount = 0;
+  let retainedStart = boundedEntries.length;
+  for (let index = boundedEntries.length - 1; index >= 0; index--) {
+    const entry = boundedEntries[index];
+    const addedBytes = utf8Size(JSON.stringify(entry.id)) + utf8Size(JSON.stringify(entry.id)) + 1 + serializedBytes(entry.block) + (reserveNotice || retainedCount > 0 ? 2 : 0);
+    if (retainedBytes + addedBytes > budget) break;
+    retainedBytes += addedBytes;
+    retainedCount++;
+    retainedStart = index;
+  }
+  let retained = boundedEntries.slice(retainedStart);
+  if (retained.length === 0 && boundedEntries.length > 0) {
+    const newest = boundedEntries.at(-1);
+    retained = [{ ...newest, block: boundSnapshotBlock(newest.block, 32 * 1024) }];
+  }
+  const droppedBlocks = knownDrops + boundedEntries.length - retained.length;
+  const notice = needsNotice ? makeNotice(droppedBlocks) : void 0;
+  let result = build(retained, notice, droppedBlocks);
+  if (serializedBytes(result) > budget) {
+    result = build([], makeNotice(maximumDrops), maximumDrops);
+  }
+  return result;
+}
+function minimalTransportSnapshot(snapshot, truncatedTurns) {
+  const originalTurnId = snapshot.turnOrder.at(-1);
+  const originalTurn = originalTurnId ? snapshot.turns[originalTurnId] : void 0;
+  const sessionId = truncateSnapshotText(snapshot.sessionId, MAX_SNAPSHOT_IDENTIFIER_BYTES);
+  if (!originalTurnId || !originalTurn) {
+    return {
+      schemaVersion: snapshot.schemaVersion,
+      sessionId,
+      turnOrder: [],
+      turns: {},
+      ...truncatedTurns === void 0 ? {} : { truncatedTurns },
+      ...snapshot.truncatedTurnIds === void 0 ? {} : { truncatedTurnIds: snapshot.truncatedTurnIds }
     };
   }
-  let serialized = JSON.stringify(currentSnapshot);
-  const sizeBudget = MAX_SNAPSHOT_SIZE_CHARS - SNAPSHOT_FIELD_RESERVE;
-  while (currentSnapshot.turnOrder.length > 1 && serialized.length > sizeBudget) {
-    const keptOrder = currentSnapshot.turnOrder.slice(1);
+  const turnId = truncateSnapshotText(originalTurnId, MAX_SNAPSHOT_IDENTIFIER_BYTES) || "__transport_truncated_turn__";
+  const blockId = "__transport_truncation_notice__";
+  const startedAt = truncateSnapshotText(
+    originalTurn.startedAt,
+    MAX_SNAPSHOT_TIMESTAMP_BYTES
+  );
+  const updatedAt = truncateSnapshotText(
+    originalTurn.updatedAt,
+    MAX_SNAPSHOT_TIMESTAMP_BYTES
+  );
+  return {
+    schemaVersion: snapshot.schemaVersion,
+    sessionId,
+    turnOrder: [turnId],
+    turns: {
+      [turnId]: {
+        turnId,
+        role: originalTurn.role,
+        startedAt,
+        updatedAt,
+        endedAt: originalTurn.endedAt === void 0 ? void 0 : truncateSnapshotText(originalTurn.endedAt, MAX_SNAPSHOT_TIMESTAMP_BYTES),
+        isComplete: originalTurn.isComplete,
+        blockOrder: [blockId],
+        blocks: {
+          [blockId]: {
+            blockId,
+            kind: "status",
+            statusType: "notice",
+            text: "[Content truncated for remote display]",
+            level: "warning",
+            isComplete: true,
+            createdAt: startedAt,
+            updatedAt,
+            metadata: {
+              [TRANSPORT_NOTICE_METADATA_KEY]: true,
+              omittedBlocks: 0
+            },
+            truncation: {
+              reason: "transport_limit",
+              keptBytes: 0,
+              didWarnUser: true
+            }
+          }
+        }
+      }
+    },
+    ...truncatedTurns === void 0 ? {} : { truncatedTurns },
+    ...snapshot.truncatedTurnIds === void 0 ? {} : { truncatedTurnIds: snapshot.truncatedTurnIds }
+  };
+}
+function mergeTruncatedTurnIds(existing, dropped) {
+  if ((existing?.length ?? 0) === 0 && dropped.length === 0) return void 0;
+  const newestFirst = [];
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [...existing ?? [], ...dropped];
+  let bytes = 2;
+  for (let index = candidates.length - 1; index >= 0; index--) {
+    const id = candidates[index];
+    if (seen.has(id)) continue;
+    const idBytes = utf8Size(JSON.stringify(id));
+    const added = idBytes + (newestFirst.length > 0 ? 1 : 0);
+    if (bytes + added > MAX_TRUNCATED_TURN_ID_BYTES) break;
+    bytes += added;
+    seen.add(id);
+    newestFirst.push(id);
+  }
+  return newestFirst.reverse();
+}
+function trimSnapshot(snapshot, maxTurns = MAX_SNAPSHOT_TURNS) {
+  let currentSnapshot = snapshot;
+  const originalLength = snapshot.turnOrder.length;
+  const sizeBudget = MAX_SNAPSHOT_SIZE_BYTES - SNAPSHOT_FIELD_RESERVE;
+  const countFloor = Math.max(0, originalLength - Math.max(1, maxTurns));
+  const alreadyWithinCount = countFloor === 0;
+  const originalSize = alreadyWithinCount ? serializedBytes(snapshot) : Number.POSITIVE_INFINITY;
+  let knownCurrentSize = alreadyWithinCount ? originalSize : void 0;
+  if (!alreadyWithinCount || originalSize > sizeBudget) {
+    const shell = {
+      ...snapshot,
+      turnOrder: [],
+      turns: {}
+    };
+    let retainedBytes = serializedBytes(shell);
+    let retainedOrderCount = 0;
+    let retainedTurnCount = 0;
+    let retainedStart = originalLength;
+    for (let index = originalLength - 1; index >= countFloor; index--) {
+      const id = snapshot.turnOrder[index];
+      const turn = snapshot.turns[id];
+      const addedOrderBytes = utf8Size(JSON.stringify(id)) + (retainedOrderCount > 0 ? 1 : 0);
+      const addedTurnBytes = turn ? utf8Size(JSON.stringify(id)) + 1 + serializedBytes(turn) + (retainedTurnCount > 0 ? 1 : 0) : 0;
+      if (retainedBytes + addedOrderBytes + addedTurnBytes > sizeBudget) break;
+      retainedBytes += addedOrderBytes + addedTurnBytes;
+      retainedOrderCount++;
+      if (turn) retainedTurnCount++;
+      retainedStart = index;
+    }
+    if (retainedStart === originalLength && originalLength > 0) {
+      retainedStart = originalLength - 1;
+    }
+    const keptOrder = snapshot.turnOrder.slice(retainedStart);
     const keptTurns = {};
     for (const id of keptOrder) {
-      if (currentSnapshot.turns[id]) {
-        keptTurns[id] = currentSnapshot.turns[id];
-      }
+      const turn = snapshot.turns[id];
+      if (turn) keptTurns[id] = turn;
     }
     currentSnapshot = {
-      ...currentSnapshot,
+      ...snapshot,
       turnOrder: keptOrder,
       turns: keptTurns
     };
-    serialized = JSON.stringify(currentSnapshot);
+    knownCurrentSize = void 0;
+  }
+  const soleTurnId = currentSnapshot.turnOrder.length === 1 ? currentSnapshot.turnOrder[0] : void 0;
+  const soleTurn = soleTurnId ? currentSnapshot.turns[soleTurnId] : void 0;
+  const omittedBlocks = soleTurn?.metadata?.[TRANSPORT_OMITTED_BLOCKS_KEY];
+  const missingSyntheticNotice = typeof omittedBlocks === "number" && omittedBlocks > 0 && !soleTurn?.blockOrder.some((blockId) => soleTurn.blocks[blockId]?.metadata?.[TRANSPORT_NOTICE_METADATA_KEY] === true);
+  if (currentSnapshot.turnOrder.length === 1 && ((knownCurrentSize ?? serializedBytes(currentSnapshot)) > sizeBudget || missingSyntheticNotice)) {
+    currentSnapshot = boundSingleTurnSnapshot(currentSnapshot);
+    knownCurrentSize = void 0;
   }
   const droppedThisCall = originalLength - currentSnapshot.turnOrder.length;
   const truncatedTurns = (snapshot.truncatedTurns ?? 0) + droppedThisCall;
   if (truncatedTurns > 0 && currentSnapshot.truncatedTurns !== truncatedTurns) {
     currentSnapshot = { ...currentSnapshot, truncatedTurns };
+    knownCurrentSize = void 0;
+  }
+  if (droppedThisCall > 0) {
+    const truncatedTurnIds = mergeTruncatedTurnIds(
+      snapshot.truncatedTurnIds,
+      snapshot.turnOrder.slice(0, droppedThisCall)
+    );
+    currentSnapshot = { ...currentSnapshot, truncatedTurnIds };
+    knownCurrentSize = void 0;
+  }
+  let finalSize = knownCurrentSize ?? serializedBytes(currentSnapshot);
+  if (finalSize > MAX_SNAPSHOT_SIZE_BYTES) {
+    currentSnapshot = minimalTransportSnapshot(
+      currentSnapshot,
+      truncatedTurns > 0 ? truncatedTurns : currentSnapshot.truncatedTurns
+    );
+    finalSize = serializedBytes(currentSnapshot);
+  }
+  if (finalSize > MAX_SNAPSHOT_SIZE_BYTES) {
+    throw new Error("Transcript snapshot exceeded its UTF-8 byte budget");
   }
   return currentSnapshot;
 }
 
+// src/transcript-wire.ts
+var import_node_crypto = require("crypto");
+var MAX_TRANSCRIPT_SNAPSHOT_BYTES = 448 * 1024;
+var MAX_TRANSCRIPT_OP_BATCH_BYTES = 192 * 1024;
+var MAX_TRANSCRIPT_TURN_BYTES = 160 * 1024;
+var MAX_TRANSCRIPT_FIELD_BYTES = 128 * 1024;
+var MAX_TOOL_RESULT_BYTES = 32 * 1024;
+var MAX_TOOL_INPUT_BYTES = 16 * 1024;
+var MAX_IDENTIFIER_BYTES = 4 * 1024;
+var MAX_TIMESTAMP_BYTES = 1024;
+var TRUNCATION_MARKER = "\n\n[Content truncated for remote display]\n\n";
+function utf8Bytes(value) {
+  const serialized = JSON.stringify(value);
+  return Buffer.byteLength(serialized ?? "", "utf8");
+}
+function stringBytes(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function prefixWithinBytes2(value, maxBytes) {
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (stringBytes(value.slice(0, mid)) <= maxBytes) low = mid;
+    else high = mid - 1;
+  }
+  if (low > 0 && /[\uD800-\uDBFF]/.test(value[low - 1] ?? "")) low--;
+  return value.slice(0, low);
+}
+function suffixWithinBytes2(value, maxBytes) {
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const count = Math.ceil((low + high) / 2);
+    if (stringBytes(value.slice(value.length - count)) <= maxBytes) low = count;
+    else high = count - 1;
+  }
+  let start = value.length - low;
+  if (start < value.length && /[\uDC00-\uDFFF]/.test(value[start] ?? "")) start++;
+  return value.slice(start);
+}
+function truncateUtf8ForWire(value, maxBytes) {
+  if (stringBytes(value) <= maxBytes) return value;
+  const markerBytes = stringBytes(TRUNCATION_MARKER);
+  if (maxBytes <= markerBytes) return prefixWithinBytes2(TRUNCATION_MARKER, maxBytes);
+  const available = maxBytes - markerBytes;
+  const head = prefixWithinBytes2(value, Math.floor(available * 0.75));
+  const tail = suffixWithinBytes2(value, available - stringBytes(head));
+  let result = `${head}${TRUNCATION_MARKER}${tail}`;
+  if (stringBytes(result) > maxBytes) {
+    result = `${prefixWithinBytes2(head, available)}${TRUNCATION_MARKER}`;
+  }
+  return result;
+}
+function boundedToolInput(input) {
+  if (!input) return void 0;
+  try {
+    if (utf8Bytes(input) <= MAX_TOOL_INPUT_BYTES) return input;
+  } catch {
+  }
+  return { notice: "Tool input truncated for remote display" };
+}
+function boundTool(tool) {
+  return {
+    ...tool,
+    name: truncateUtf8ForWire(tool.name, 2 * 1024),
+    input: boundedToolInput(tool.input),
+    result: typeof tool.result === "string" ? truncateUtf8ForWire(tool.result, MAX_TOOL_RESULT_BYTES) : void 0
+  };
+}
+function minimalMarkdownTurn(turn) {
+  return {
+    turnId: truncateUtf8ForWire(turn.turnId, 1024),
+    role: turn.role,
+    content: "[Content truncated for remote display]",
+    timestamp: truncateUtf8ForWire(turn.timestamp, 256)
+  };
+}
+function boundMarkdownTurnForWire(turn) {
+  let bounded = {
+    ...turn,
+    turnId: truncateUtf8ForWire(turn.turnId, MAX_IDENTIFIER_BYTES),
+    content: truncateUtf8ForWire(turn.content, MAX_TRANSCRIPT_FIELD_BYTES),
+    tools: turn.tools?.slice(-12).map(boundTool),
+    timestamp: truncateUtf8ForWire(turn.timestamp, MAX_TIMESTAMP_BYTES)
+  };
+  while (utf8Bytes(bounded) > MAX_TRANSCRIPT_TURN_BYTES && (bounded.tools?.length ?? 0) > 0) {
+    bounded = { ...bounded, tools: bounded.tools.slice(1) };
+  }
+  if (utf8Bytes(bounded) > MAX_TRANSCRIPT_TURN_BYTES) {
+    bounded = {
+      ...bounded,
+      content: truncateUtf8ForWire(bounded.content, 64 * 1024),
+      tools: void 0
+    };
+  }
+  if (utf8Bytes(bounded) > MAX_TRANSCRIPT_TURN_BYTES) {
+    bounded = minimalMarkdownTurn(bounded);
+  }
+  if (utf8Bytes(bounded) > MAX_TRANSCRIPT_TURN_BYTES) {
+    throw new Error("Legacy transcript turn exceeded its UTF-8 byte budget");
+  }
+  return bounded;
+}
+function boundMarkdownTurnsForWire(turns, maxBytes = MAX_TRANSCRIPT_SNAPSHOT_BYTES) {
+  const bounded = turns.map(boundMarkdownTurnForWire);
+  const emptySnapshotBytes = utf8Bytes({ turns: [] });
+  let retainedBytes = emptySnapshotBytes;
+  let retainedCount = 0;
+  let start = bounded.length;
+  for (let index = bounded.length - 1; index >= 0; index--) {
+    const addedBytes = utf8Bytes(bounded[index]) + (retainedCount > 0 ? 1 : 0);
+    if (retainedBytes + addedBytes > maxBytes) break;
+    retainedBytes += addedBytes;
+    retainedCount++;
+    start = index;
+  }
+  let retained = bounded.slice(start);
+  if (retained.length === 0 && bounded.length > 0) {
+    retained = [minimalMarkdownTurn(bounded.at(-1))];
+  }
+  if (utf8Bytes({ turns: retained }) > maxBytes) {
+    throw new Error("Legacy transcript snapshot exceeded its UTF-8 byte budget");
+  }
+  return retained;
+}
+function withTruncation(block, originalBytes, keptBytes) {
+  return {
+    ...block,
+    truncation: {
+      reason: "transport_limit",
+      originalBytes,
+      keptBytes,
+      didWarnUser: true
+    }
+  };
+}
+function boundIdentifier(rawId, context) {
+  const existing = context.identifiers.get(rawId);
+  if (existing !== void 0) return existing;
+  if (stringBytes(rawId) <= MAX_IDENTIFIER_BYTES) {
+    context.identifiers.set(rawId, rawId);
+    return rawId;
+  }
+  const suffix = `~${(0, import_node_crypto.createHash)("sha256").update(rawId).digest("hex").slice(0, 20)}`;
+  const bounded = `${prefixWithinBytes2(
+    rawId,
+    MAX_IDENTIFIER_BYTES - stringBytes(suffix)
+  )}${suffix}`;
+  context.identifiers.set(rawId, bounded);
+  return bounded;
+}
+function boundBlock(block, boundedBlockId = truncateUtf8ForWire(block.blockId, MAX_IDENTIFIER_BYTES)) {
+  const originalBytes = utf8Bytes(block);
+  let bounded;
+  switch (block.kind) {
+    case "text":
+    case "reasoning":
+      bounded = { ...block, text: truncateUtf8ForWire(block.text, MAX_TRANSCRIPT_FIELD_BYTES) };
+      break;
+    case "tool": {
+      let input = block.input;
+      if (input !== void 0) {
+        try {
+          if (utf8Bytes(input) > MAX_TOOL_INPUT_BYTES) {
+            input = "[Tool input truncated for remote display]";
+          }
+        } catch {
+          input = "[Tool input truncated for remote display]";
+        }
+      }
+      bounded = {
+        ...block,
+        callId: truncateUtf8ForWire(block.callId, MAX_IDENTIFIER_BYTES),
+        toolName: truncateUtf8ForWire(block.toolName, 2 * 1024),
+        input,
+        outputText: block.outputText === void 0 ? void 0 : truncateUtf8ForWire(block.outputText, MAX_TRANSCRIPT_FIELD_BYTES),
+        errorText: block.errorText === void 0 ? void 0 : truncateUtf8ForWire(block.errorText, MAX_TOOL_RESULT_BYTES),
+        outputMimeType: block.outputMimeType === void 0 ? void 0 : truncateUtf8ForWire(block.outputMimeType, 2 * 1024)
+      };
+      break;
+    }
+    case "status":
+      bounded = {
+        ...block,
+        statusType: truncateUtf8ForWire(block.statusType, 2 * 1024),
+        text: block.text === void 0 ? void 0 : truncateUtf8ForWire(block.text, MAX_TOOL_RESULT_BYTES)
+      };
+      break;
+    case "unknown":
+      bounded = {
+        ...block,
+        rawKind: truncateUtf8ForWire(block.rawKind, 2 * 1024),
+        rawPayload: block.rawPayload === void 0 ? void 0 : "[Unknown payload truncated for remote display]",
+        fallbackText: block.fallbackText === void 0 ? void 0 : truncateUtf8ForWire(block.fallbackText, MAX_TOOL_RESULT_BYTES)
+      };
+      break;
+    case "attachment":
+      bounded = {
+        ...block,
+        mediaType: truncateUtf8ForWire(block.mediaType, 2 * 1024),
+        uri: block.uri === void 0 ? void 0 : truncateUtf8ForWire(block.uri, 8 * 1024),
+        path: block.path === void 0 ? void 0 : truncateUtf8ForWire(block.path, 8 * 1024),
+        name: block.name === void 0 ? void 0 : truncateUtf8ForWire(block.name, 2 * 1024)
+      };
+      break;
+  }
+  bounded = {
+    ...bounded,
+    blockId: boundedBlockId,
+    createdAt: truncateUtf8ForWire(block.createdAt, MAX_TIMESTAMP_BYTES),
+    updatedAt: truncateUtf8ForWire(block.updatedAt, MAX_TIMESTAMP_BYTES),
+    metadata: void 0
+  };
+  if (utf8Bytes(bounded) < originalBytes) {
+    bounded = withTruncation(bounded, originalBytes, utf8Bytes(bounded));
+  }
+  return bounded;
+}
+function boundOp(op, context) {
+  switch (op.op) {
+    case "append_text":
+    case "append_tool_output":
+      return {
+        ...op,
+        turnId: boundIdentifier(op.turnId, context),
+        blockId: boundIdentifier(op.blockId, context),
+        text: truncateUtf8ForWire(op.text, MAX_TRANSCRIPT_FIELD_BYTES)
+      };
+    case "insert_block":
+      return {
+        ...op,
+        turnId: boundIdentifier(op.turnId, context),
+        afterBlockId: op.afterBlockId === void 0 ? void 0 : boundIdentifier(op.afterBlockId, context),
+        block: boundBlock(
+          op.block,
+          boundIdentifier(op.block.blockId, context)
+        )
+      };
+    case "replace_block":
+      return {
+        ...op,
+        turnId: boundIdentifier(op.turnId, context),
+        block: boundBlock(
+          op.block,
+          boundIdentifier(op.block.blockId, context)
+        )
+      };
+    case "upsert_turn": {
+      return {
+        ...op,
+        turn: {
+          ...op.turn,
+          turnId: boundIdentifier(op.turn.turnId, context),
+          startedAt: truncateUtf8ForWire(op.turn.startedAt, MAX_TIMESTAMP_BYTES),
+          updatedAt: truncateUtf8ForWire(op.turn.updatedAt, MAX_TIMESTAMP_BYTES),
+          endedAt: op.turn.endedAt === void 0 ? void 0 : truncateUtf8ForWire(op.turn.endedAt, MAX_TIMESTAMP_BYTES),
+          agent: op.turn.agent === void 0 ? void 0 : {
+            vendor: op.turn.agent.vendor === void 0 ? void 0 : truncateUtf8ForWire(op.turn.agent.vendor, 2 * 1024),
+            agentType: op.turn.agent.agentType === void 0 ? void 0 : truncateUtf8ForWire(op.turn.agent.agentType, 2 * 1024),
+            name: op.turn.agent.name === void 0 ? void 0 : truncateUtf8ForWire(op.turn.agent.name, 2 * 1024),
+            version: op.turn.agent.version === void 0 ? void 0 : truncateUtf8ForWire(op.turn.agent.version, 2 * 1024),
+            transcriptSource: op.turn.agent.transcriptSource
+          },
+          metadata: void 0,
+          blocks: void 0,
+          blockOrder: void 0
+        }
+      };
+    }
+    case "set_tool_state":
+      return {
+        ...op,
+        turnId: boundIdentifier(op.turnId, context),
+        blockId: boundIdentifier(op.blockId, context),
+        errorText: op.errorText === void 0 ? void 0 : truncateUtf8ForWire(op.errorText, MAX_TOOL_RESULT_BYTES)
+      };
+    case "complete_block":
+      return {
+        ...op,
+        turnId: boundIdentifier(op.turnId, context),
+        blockId: boundIdentifier(op.blockId, context),
+        updatedAt: truncateUtf8ForWire(op.updatedAt, MAX_TIMESTAMP_BYTES)
+      };
+    case "complete_turn":
+      return {
+        ...op,
+        turnId: boundIdentifier(op.turnId, context),
+        endedAt: truncateUtf8ForWire(op.endedAt, MAX_TIMESTAMP_BYTES),
+        updatedAt: truncateUtf8ForWire(op.updatedAt, MAX_TIMESTAMP_BYTES)
+      };
+    default:
+      return op;
+  }
+}
+function expandBoundOp(op, context) {
+  if (op.op !== "upsert_turn" || !op.turn.blocks) return [boundOp(op, context)];
+  const order = op.turn.blockOrder ?? Object.keys(op.turn.blocks);
+  const base = boundOp(op, context);
+  const boundedTurnId = base.op === "upsert_turn" ? base.turn.turnId : truncateUtf8ForWire(op.turn.turnId, MAX_IDENTIFIER_BYTES);
+  const expanded = [base];
+  for (const blockId of order) {
+    const block = op.turn.blocks[blockId];
+    if (!block) continue;
+    expanded.push({
+      op: "insert_block",
+      // Use exactly the same bounded identifier as the base upsert so an
+      // adversarial long ID cannot orphan its expanded blocks.
+      turnId: boundedTurnId,
+      block: boundBlock(
+        block,
+        boundIdentifier(block.blockId, context)
+      )
+    });
+  }
+  return expanded;
+}
+function forceBoundOp(op, maxBytes) {
+  if (utf8Bytes(op) <= maxBytes) return op;
+  if (op.op === "insert_block" || op.op === "replace_block") {
+    return {
+      ...op,
+      block: {
+        blockId: truncateUtf8ForWire(op.block.blockId, MAX_IDENTIFIER_BYTES),
+        kind: "status",
+        statusType: "notice",
+        text: "Block content truncated for remote display",
+        level: "warning",
+        isComplete: op.block.isComplete,
+        createdAt: op.block.createdAt,
+        updatedAt: op.block.updatedAt,
+        truncation: {
+          reason: "transport_limit",
+          originalBytes: utf8Bytes(op.block),
+          keptBytes: 0,
+          didWarnUser: true
+        }
+      }
+    };
+  }
+  if (op.op === "append_text" || op.op === "append_tool_output") {
+    return { ...op, text: truncateUtf8ForWire(op.text, 32 * 1024) };
+  }
+  return op;
+}
+function boundTranscriptOpsForWire(ops, maxBytes = MAX_TRANSCRIPT_OP_BATCH_BYTES) {
+  const idContext = {
+    identifiers: /* @__PURE__ */ new Map()
+  };
+  const batches = [];
+  let current = [];
+  let currentBytes = 2;
+  for (const rawOp of ops) {
+    for (const expanded of expandBoundOp(rawOp, idContext)) {
+      const op = forceBoundOp(expanded, maxBytes);
+      const opBytes = utf8Bytes(op);
+      if (opBytes + 2 > maxBytes) continue;
+      const addedBytes = opBytes + (current.length > 0 ? 1 : 0);
+      if (current.length > 0 && currentBytes + addedBytes > maxBytes) {
+        batches.push(current);
+        current = [];
+        currentBytes = 2;
+      }
+      current.push(op);
+      currentBytes += opBytes + (current.length > 1 ? 1 : 0);
+    }
+  }
+  if (current.length > 0) batches.push(current);
+  if (batches.some((batch) => utf8Bytes(batch) > maxBytes)) {
+    throw new Error("Transcript wire batch exceeded its UTF-8 byte budget");
+  }
+  return batches;
+}
+
 // src/native-stream-manager.ts
 var import_child_process = require("child_process");
 
@@ -2580,6 +3602,9 @@ var import_ws = __toESM(require("ws"));
 var BACKPRESSURE_HIGH_WATER = 256 * 1024;
 var BACKPRESSURE_LOW_WATER = 64 * 1024;
 var MAX_PENDING_QUEUE = 500;
+var MAX_PENDING_BYTES = 4 * 1024 * 1024;
+var CONTROL_FRAME_RESERVE = 32;
+var CONTROL_BYTE_RESERVE = 256 * 1024;
 var DRAIN_INTERVAL_MS = 50;
 function sanitizeForJson(str) {
   return str.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD");
@@ -2633,6 +3658,7 @@ function flushStreamingRedaction(sessionId) {
   return redactionEnabled ? redactSecrets(tail) : tail;
 }
 var pendingQueue = [];
+var pendingQueueBytes = 0;
 var drainTimer = null;
 var drainWs = null;
 var droppedFrames = 0;
@@ -2640,10 +3666,17 @@ var PRESSURE_HIGH = 0.75;
 var PRESSURE_LOW = 0.25;
 var pressureIsHigh = false;
 function getQueuePressure() {
-  const level = pendingQueue.length / MAX_PENDING_QUEUE;
+  const frameLevel = pendingQueue.length / MAX_PENDING_QUEUE;
+  const byteLevel = pendingQueueBytes / MAX_PENDING_BYTES;
+  const level = Math.max(frameLevel, byteLevel);
   if (level >= PRESSURE_HIGH) pressureIsHigh = true;
   else if (level < PRESSURE_LOW) pressureIsHigh = false;
-  return { level, isHigh: pressureIsHigh };
+  return {
+    level,
+    queuedFrames: pendingQueue.length,
+    queuedBytes: pendingQueueBytes,
+    isHigh: pressureIsHigh
+  };
 }
 function getDroppedFrameCount() {
   return droppedFrames;
@@ -2654,13 +3687,133 @@ function drainQueue() {
     return;
   }
   while (pendingQueue.length > 0 && drainWs.bufferedAmount < BACKPRESSURE_LOW_WATER) {
-    const frame = pendingQueue.shift();
-    drainWs.send(frame);
+    const pending = pendingQueue.shift();
+    pendingQueueBytes -= pending.bytes;
+    drainWs.send(pending.frame);
   }
   if (pendingQueue.length === 0) {
     stopDrainTimer();
   }
 }
+function classifyPendingFrame(frame, group, data, hints) {
+  const sessionId = hints?.sessionId ?? (typeof data.sessionId === "string" ? data.sessionId : void 0);
+  const isMarkdown = data.type === "markdown" || hints?.markdownSubtype !== void 0;
+  const subtype = hints?.markdownSubtype ?? (typeof data.subtype === "string" ? data.subtype : void 0);
+  const isResetSnapshot = isMarkdown && subtype === "snapshot" && (hints?.reset === true || data.reset === true);
+  const replaceableSnapshot = isMarkdown && subtype === "snapshot" && !isResetSnapshot;
+  const markdownSchemaVersion = isMarkdown ? hints?.markdownSchemaVersion ?? (data.schemaVersion === 2 ? 2 : 1) : void 0;
+  const transcriptOrderBarrier = isMarkdown && !replaceableSnapshot;
+  const protectedOrderBarrier = isResetSnapshot || data.type === "stream-reset" || data.type === "stream-started" || data.type === "stream-stopped";
+  const protectedBarrierKind = isResetSnapshot ? "markdown-reset" : data.type === "stream-reset" ? "stream-reset" : data.type === "stream-started" ? "stream-started" : data.type === "stream-stopped" ? "stream-stopped" : void 0;
+  let priority = 2 /* Control */;
+  if (data.type === "output" || isMarkdown && subtype === "delta") {
+    priority = 0 /* Bulk */;
+  } else if (replaceableSnapshot) {
+    priority = 1 /* Snapshot */;
+  }
+  return {
+    frame,
+    bytes: Buffer.byteLength(frame, "utf8"),
+    group,
+    sessionId,
+    priority,
+    replaceableSnapshot,
+    markdownSchemaVersion,
+    // Encrypted markdown frames have no visible subtype, so treat them as a
+    // barrier. Guessing that one is replaceable could reorder an encrypted
+    // reset, status, or delta and corrupt transcript state.
+    transcriptOrderBarrier,
+    protectedOrderBarrier,
+    protectedBarrierKind
+  };
+}
+function obsoleteSnapshotIndices(incoming) {
+  const indices = /* @__PURE__ */ new Set();
+  if (!incoming.replaceableSnapshot || !incoming.sessionId) return indices;
+  for (let i = pendingQueue.length - 1; i >= 0; i--) {
+    const queued = pendingQueue[i];
+    if (queued.group !== incoming.group || queued.sessionId !== incoming.sessionId) {
+      continue;
+    }
+    if (queued.transcriptOrderBarrier) break;
+    if (queued.replaceableSnapshot && queued.markdownSchemaVersion === incoming.markdownSchemaVersion) {
+      indices.add(i);
+    }
+  }
+  return indices;
+}
+function supersededProtectedBarrierIndices(incoming) {
+  const indices = /* @__PURE__ */ new Set();
+  if (!incoming.protectedBarrierKind || !incoming.sessionId) return indices;
+  for (let i = pendingQueue.length - 1; i >= 0; i--) {
+    const queued = pendingQueue[i];
+    if (queued.group !== incoming.group || queued.sessionId !== incoming.sessionId) {
+      continue;
+    }
+    if (queued.protectedBarrierKind === incoming.protectedBarrierKind) {
+      indices.add(i);
+      continue;
+    }
+    break;
+  }
+  return indices;
+}
+function recordDroppedFrame() {
+  droppedFrames++;
+  if (droppedFrames % 100 === 1) {
+    console.warn(
+      `[rAgent] Backpressure: dropped ${droppedFrames} frames (queue limit ${MAX_PENDING_QUEUE} frames / ${MAX_PENDING_BYTES} bytes)`
+    );
+  }
+}
+function findEvictionCandidate(incomingPriority, excluded) {
+  for (let priority = 0 /* Bulk */; priority <= incomingPriority; priority++) {
+    const index = pendingQueue.findIndex(
+      (queued, queuedIndex) => !excluded.has(queuedIndex) && !queued.protectedOrderBarrier && queued.priority === priority
+    );
+    if (index >= 0) return index;
+  }
+  return -1;
+}
+function enqueuePendingFrame(pending) {
+  if (pending.bytes > MAX_PENDING_BYTES) {
+    recordDroppedFrame();
+    return false;
+  }
+  const obsolete = obsoleteSnapshotIndices(pending);
+  const supersededBarriers = supersededProtectedBarrierIndices(pending);
+  const coalesced = /* @__PURE__ */ new Set([...obsolete, ...supersededBarriers]);
+  const removable = new Set(coalesced);
+  const frameCapacity = pending.priority === 0 /* Bulk */ ? MAX_PENDING_QUEUE - CONTROL_FRAME_RESERVE : MAX_PENDING_QUEUE;
+  const byteCapacity = pending.priority === 0 /* Bulk */ ? MAX_PENDING_BYTES - CONTROL_BYTE_RESERVE : MAX_PENDING_BYTES;
+  let projectedLength = pendingQueue.length - removable.size;
+  let projectedBytes = pendingQueueBytes;
+  for (const index of removable) projectedBytes -= pendingQueue[index].bytes;
+  while (projectedLength >= frameCapacity || projectedBytes + pending.bytes > byteCapacity) {
+    let candidate = findEvictionCandidate(pending.priority, removable);
+    if (candidate < 0 && pending.protectedOrderBarrier) {
+      candidate = pendingQueue.findIndex(
+        (queued, queuedIndex) => !removable.has(queuedIndex) && queued.protectedOrderBarrier
+      );
+    }
+    if (candidate < 0) {
+      recordDroppedFrame();
+      return false;
+    }
+    removable.add(candidate);
+    projectedLength--;
+    projectedBytes -= pendingQueue[candidate].bytes;
+  }
+  const indices = [...removable].sort((a, b) => b - a);
+  for (const index of indices) {
+    const [removed] = pendingQueue.splice(index, 1);
+    pendingQueueBytes -= removed.bytes;
+    if (!coalesced.has(index)) recordDroppedFrame();
+  }
+  pendingQueue.push(pending);
+  pendingQueueBytes += pending.bytes;
+  return true;
+}
 function startDrainTimer(ws) {
   drainWs = ws;
   if (!drainTimer) {
@@ -2674,7 +3827,7 @@ function stopDrainTimer() {
   }
   drainWs = null;
 }
-function sendToGroup(ws, group, data) {
+function sendToGroup(ws, group, data, hints) {
   if (!group || ws.readyState !== import_ws.default.OPEN) return;
   const sanitized = sanitizePayload(data);
   const frame = JSON.stringify({
@@ -2684,20 +3837,20 @@ function sendToGroup(ws, group, data) {
     data: sanitized,
     noEcho: true
   });
+  const pending = classifyPendingFrame(frame, group, sanitized, hints);
+  if (pending.bytes > MAX_PENDING_BYTES) {
+    recordDroppedFrame();
+    return;
+  }
   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})`);
-      }
+    enqueuePendingFrame(pending);
+    if (pendingQueue.length > 0) {
+      startDrainTimer(ws);
     }
-    pendingQueue.push(frame);
-    startDrainTimer(ws);
     return;
   }
   if (pendingQueue.length > 0) {
-    pendingQueue.push(frame);
+    enqueuePendingFrame(pending);
     drainWs = ws;
     drainQueue();
     return;
@@ -2728,6 +3881,36 @@ function sanitizePayload(obj) {
 var log7 = createLogger("transcript-watcher");
 var cachedTicksPerSecond = null;
 var transcriptDiscoveryCache = /* @__PURE__ */ new Map();
+var codexSubagentTranscriptCache = /* @__PURE__ */ new Map();
+function createTranscriptDiscoveryIndex() {
+  return { candidates: /* @__PURE__ */ new Map() };
+}
+function indexedCandidates(index, key, scan) {
+  const rank = () => scan().map((target) => {
+    try {
+      return { target, mtimeMs: fs2.statSync(target).mtimeMs };
+    } catch {
+      return null;
+    }
+  }).filter((entry) => entry !== null).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  if (!index) return rank();
+  const cached = index.candidates.get(key);
+  if (cached) return cached;
+  const candidates = rank();
+  index.candidates.set(key, candidates);
+  return candidates;
+}
+function getNewestIndexedPath(candidates, options) {
+  for (const candidate of candidates) {
+    if (options?.minMtimeMs !== void 0 && candidate.mtimeMs < options.minMtimeMs) {
+      break;
+    }
+    if (options?.excludePaths?.has(candidate.target)) continue;
+    if (options?.isEligible && !options.isEligible(candidate.target)) continue;
+    return candidate.target;
+  }
+  return null;
+}
 var ClaudeCodeParser = class {
   name = "claude-code";
   /** Maps tool_use id → tool name for matching results back to tools. */
@@ -2903,6 +4086,7 @@ var CodexCliParser = class {
       if (!payload.call_id) return null;
       const toolName = this.pendingTools.get(payload.call_id) ?? "tool";
       this.pendingTools.delete(payload.call_id);
+      const output = normalizeCodexFunctionCallOutput(payload.output);
       return {
         turnId: this.genTurnId(lineTimestamp),
         role: "user",
@@ -2911,7 +4095,7 @@ var CodexCliParser = class {
           {
             name: toolName,
             status: "completed",
-            result: payload.output || void 0
+            result: output || void 0
           }
         ],
         timestamp
@@ -3219,7 +4403,48 @@ function getNewestPath(paths, options) {
       return null;
     }
   }).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;
+  return ranked.find((entry) => options?.isEligible?.(entry.target) ?? true)?.target ?? null;
+}
+function isCodexSubagentTranscript(target) {
+  const cached = codexSubagentTranscriptCache.get(target);
+  if (cached !== void 0) return cached;
+  let isSubagent = false;
+  let classified = false;
+  let fd = null;
+  try {
+    fd = fs2.openSync(target, "r");
+    const buffer = Buffer.alloc(256 * 1024);
+    const bytesRead = fs2.readSync(fd, buffer, 0, buffer.length, 0);
+    const content = buffer.subarray(0, bytesRead).toString("utf8");
+    const newline = content.indexOf("\n");
+    if (newline < 0 && bytesRead === buffer.length) {
+      throw new Error("session metadata exceeds bounded read");
+    }
+    const firstLine = newline >= 0 ? content.slice(0, newline) : content;
+    const record = JSON.parse(firstLine);
+    classified = true;
+    const source = record.type === "session_meta" ? record.payload?.source : void 0;
+    isSubagent = Boolean(
+      source && typeof source === "object" && !Array.isArray(source) && Object.prototype.hasOwnProperty.call(source, "subagent")
+    );
+  } catch {
+    isSubagent = false;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs2.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+  if (classified) {
+    if (codexSubagentTranscriptCache.size >= 5e3) {
+      const oldest = codexSubagentTranscriptCache.keys().next().value;
+      if (oldest) codexSubagentTranscriptCache.delete(oldest);
+    }
+    codexSubagentTranscriptCache.set(target, isSubagent);
+  }
+  return isSubagent;
 }
 function discoverTranscriptForPid(pid, agentType) {
   const fdDir = `/proc/${pid}/fd`;
@@ -3235,7 +4460,7 @@ function discoverTranscriptForPid(pid, agentType) {
       } catch {
       }
     }
-    return getNewestPath(matches);
+    return getNewestPath(matches, agentType === "Codex CLI" ? { isEligible: (target) => !isCodexSubagentTranscript(target) } : void 0);
   } catch {
     return null;
   }
@@ -3366,10 +4591,10 @@ function discoverViaProc(rootPid, agentType) {
   }
   return getNewestPath(candidates);
 }
-function discoverViaProcessCwd(pid, minMtimeMs, excludePaths) {
+function discoverViaProcessCwd(pid, minMtimeMs, excludePaths, discoveryIndex) {
   try {
     const processCwd = fs2.readlinkSync(`/proc/${pid}/cwd`);
-    return processCwd ? discoverViaCwd(processCwd, pid, minMtimeMs, excludePaths) : null;
+    return processCwd ? discoverViaCwd(processCwd, pid, minMtimeMs, excludePaths, discoveryIndex) : null;
   } catch {
     return null;
   }
@@ -3397,83 +4622,108 @@ function resolveUserHome(pid) {
     return null;
   }
 }
-function discoverCodexTranscriptFromHome(pid, minMtimeMs, excludePaths) {
+function discoverCodexTranscriptFromHome(pid, minMtimeMs, excludePaths, discoveryIndex) {
   const userHome = resolveUserHome(pid);
   if (!userHome) return null;
   const sessionsDir = path2.join(userHome, ".codex", "sessions");
   if (!fs2.existsSync(sessionsDir)) return null;
-  const matches = [];
-  const stack = [sessionsDir];
-  let visited = 0;
-  while (stack.length > 0 && visited < 3e3) {
-    const current = stack.pop();
-    if (!current) continue;
-    visited++;
-    let entries;
-    try {
-      entries = fs2.readdirSync(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const fullPath = path2.join(current, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(fullPath);
-      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-        matches.push(fullPath);
+  const matches = indexedCandidates(
+    discoveryIndex,
+    `codex:${sessionsDir}`,
+    () => {
+      const found = [];
+      const stack = [sessionsDir];
+      let visited = 0;
+      while (stack.length > 0 && visited < 3e3) {
+        const current = stack.pop();
+        if (!current) continue;
+        visited++;
+        let entries;
+        try {
+          entries = fs2.readdirSync(current, { withFileTypes: true });
+        } catch {
+          continue;
+        }
+        for (const entry of entries) {
+          const fullPath = path2.join(current, entry.name);
+          if (entry.isDirectory()) {
+            stack.push(fullPath);
+          } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+            found.push(fullPath);
+          }
+        }
       }
+      return found;
     }
-  }
-  return getNewestPath(matches, { minMtimeMs, excludePaths });
+  );
+  return getNewestIndexedPath(matches, {
+    minMtimeMs,
+    excludePaths,
+    isEligible: (target) => !isCodexSubagentTranscript(target)
+  });
 }
-function discoverGeminiTranscriptFromHome(pid, minMtimeMs, excludePaths) {
+function discoverGeminiTranscriptFromHome(pid, minMtimeMs, excludePaths, discoveryIndex) {
   const userHome = resolveUserHome(pid);
   if (!userHome) return null;
   const tmpDir = path2.join(userHome, ".gemini", "tmp");
   if (!fs2.existsSync(tmpDir)) return null;
-  const matches = [];
-  const stack = [tmpDir];
-  let visited = 0;
-  while (stack.length > 0 && visited < 2e3) {
-    const current = stack.pop();
-    if (!current) continue;
-    visited++;
-    let entries;
-    try {
-      entries = fs2.readdirSync(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const fullPath = path2.join(current, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(fullPath);
-      } else if (entry.isFile() && entry.name.startsWith("session-") && entry.name.endsWith(".json") && fullPath.includes(`${path2.sep}chats${path2.sep}`)) {
-        matches.push(fullPath);
+  const matches = indexedCandidates(
+    discoveryIndex,
+    `gemini:${tmpDir}`,
+    () => {
+      const found = [];
+      const stack = [tmpDir];
+      let visited = 0;
+      while (stack.length > 0 && visited < 2e3) {
+        const current = stack.pop();
+        if (!current) continue;
+        visited++;
+        let entries;
+        try {
+          entries = fs2.readdirSync(current, { withFileTypes: true });
+        } catch {
+          continue;
+        }
+        for (const entry of entries) {
+          const fullPath = path2.join(current, entry.name);
+          if (entry.isDirectory()) {
+            stack.push(fullPath);
+          } else if (entry.isFile() && entry.name.startsWith("session-") && entry.name.endsWith(".json") && fullPath.includes(`${path2.sep}chats${path2.sep}`)) {
+            found.push(fullPath);
+          }
+        }
       }
+      return found;
     }
-  }
-  return getNewestPath(matches, { minMtimeMs, excludePaths });
+  );
+  return getNewestIndexedPath(matches, { minMtimeMs, excludePaths });
 }
-function discoverAntigravityTranscriptFromHome(pid, minMtimeMs, excludePaths) {
+function discoverAntigravityTranscriptFromHome(pid, minMtimeMs, excludePaths, discoveryIndex) {
   const userHome = resolveUserHome(pid);
   if (!userHome) return null;
   const brainDir = path2.join(userHome, ".gemini", "antigravity-cli", "brain");
   if (!fs2.existsSync(brainDir)) return null;
-  const matches = [];
-  try {
-    const folders = fs2.readdirSync(brainDir, { withFileTypes: true });
-    for (const folder of folders) {
-      if (folder.isDirectory()) {
-        const transcriptPath = path2.join(brainDir, folder.name, ".system_generated", "logs", "transcript.jsonl");
-        if (fs2.existsSync(transcriptPath)) {
-          matches.push(transcriptPath);
+  const matches = indexedCandidates(
+    discoveryIndex,
+    `antigravity:${brainDir}`,
+    () => {
+      const found = [];
+      try {
+        const folders = fs2.readdirSync(brainDir, { withFileTypes: true });
+        for (const folder of folders) {
+          if (folder.isDirectory()) {
+            const transcriptPath = path2.join(brainDir, folder.name, ".system_generated", "logs", "transcript.jsonl");
+            if (fs2.existsSync(transcriptPath)) {
+              found.push(transcriptPath);
+            }
+          }
         }
+      } catch {
       }
+      return found;
     }
-  } catch {
-  }
-  return getNewestPath(matches, { minMtimeMs, excludePaths });
+  );
+  return getNewestIndexedPath(matches, { minMtimeMs, excludePaths });
 }
 function discoverAntigravityViaCwd(paneCwd, pid, excludePaths) {
   const userHome = resolveUserHome(pid);
@@ -3521,7 +4771,7 @@ function discoverAntigravityViaCwd(paneCwd, pid, excludePaths) {
   }
   return null;
 }
-function discoverViaCwd(paneCwd, pid, minMtimeMs, excludePaths) {
+function discoverViaCwd(paneCwd, pid, minMtimeMs, excludePaths, discoveryIndex) {
   const userHome = resolveUserHome(pid);
   if (!userHome) return null;
   const claudeProjectsDir = path2.join(userHome, ".claude", "projects");
@@ -3534,8 +4784,12 @@ function discoverViaCwd(paneCwd, pid, minMtimeMs, excludePaths) {
   const projectDirs = Array.from(possibleCwds).map((cwd) => path2.join(claudeProjectsDir, cwd.replace(/\//g, "-"))).filter((projectDir, index, arr) => arr.indexOf(projectDir) === index).filter((projectDir) => fs2.existsSync(projectDir));
   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, excludePaths });
+    const jsonlFiles = projectDirs.flatMap((projectDir) => indexedCandidates(
+      discoveryIndex,
+      `claude:${projectDir}`,
+      () => fs2.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => path2.join(projectDir, f))
+    ));
+    return getNewestIndexedPath(jsonlFiles, { minMtimeMs, excludePaths });
   } catch {
     return null;
   }
@@ -3561,10 +4815,15 @@ function discoverTranscriptFile(sessionId, agentType, forceRefresh = false, excl
   }
   return result;
 }
-function discoverTranscriptFileDetailed(sessionId, agentType, excludePaths) {
-  return discoverTranscriptFileImpl(sessionId, agentType, excludePaths);
+function discoverTranscriptFileDetailed(sessionId, agentType, excludePaths, discoveryIndex) {
+  return discoverTranscriptFileImpl(
+    sessionId,
+    agentType,
+    excludePaths,
+    discoveryIndex
+  );
 }
-function discoverTranscriptFileImpl(sessionId, agentType, excludePaths) {
+function discoverTranscriptFileImpl(sessionId, agentType, excludePaths, discoveryIndex) {
   const processPid = parseProcessPid(sessionId);
   if (processPid) {
     const t0 = performance.now();
@@ -3576,7 +4835,12 @@ function discoverTranscriptFileImpl(sessionId, agentType, excludePaths) {
     if (agentType === "Claude Code") {
       const t1 = performance.now();
       const startMs = getProcessStartEpochMs(processPid);
-      const cwdResult = discoverViaProcessCwd(processPid, startMs ? startMs - 6e4 : void 0, excludePaths);
+      const cwdResult = discoverViaProcessCwd(
+        processPid,
+        startMs ? startMs - 6e4 : void 0,
+        excludePaths,
+        discoveryIndex
+      );
       console.log(`[DISCOVER] Claude Code discovery for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
       if (cwdResult) return { path: cwdResult, viaProc: false };
     }
@@ -3585,7 +4849,12 @@ function discoverTranscriptFileImpl(sessionId, agentType, excludePaths) {
       const startMs = getProcessStartEpochMs(processPid);
       const command = getProcessCommand(processPid);
       if (commandMatchesAgent(command, agentType)) {
-        const codexResult = discoverCodexTranscriptFromHome(processPid, startMs ? startMs - 6e4 : void 0, excludePaths);
+        const codexResult = discoverCodexTranscriptFromHome(
+          processPid,
+          startMs ? startMs - 6e4 : void 0,
+          excludePaths,
+          discoveryIndex
+        );
         console.log(`[DISCOVER] Codex CLI discovery for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
         if (codexResult) return { path: codexResult, viaProc: false };
       }
@@ -3593,7 +4862,12 @@ function discoverTranscriptFileImpl(sessionId, agentType, excludePaths) {
     if (agentType === "Gemini CLI") {
       const t1 = performance.now();
       const startMs = getProcessStartEpochMs(processPid);
-      const geminiResult = discoverGeminiTranscriptFromHome(processPid, startMs ? startMs - 6e4 : void 0, excludePaths);
+      const geminiResult = discoverGeminiTranscriptFromHome(
+        processPid,
+        startMs ? startMs - 6e4 : void 0,
+        excludePaths,
+        discoveryIndex
+      );
       console.log(`[DISCOVER] Gemini CLI discovery for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
       if (geminiResult) return { path: geminiResult, viaProc: false };
     }
@@ -3611,7 +4885,12 @@ function discoverTranscriptFileImpl(sessionId, agentType, excludePaths) {
         }
       } catch {
       }
-      const antigravityResult = discoverAntigravityTranscriptFromHome(processPid, startMs ? startMs - 6e4 : void 0, excludePaths);
+      const antigravityResult = discoverAntigravityTranscriptFromHome(
+        processPid,
+        startMs ? startMs - 6e4 : void 0,
+        excludePaths,
+        discoveryIndex
+      );
       console.log(`[DISCOVER] Antigravity CLI discovery (home path) for PID ${processPid} took ${(performance.now() - t1).toFixed(2)} ms`);
       if (antigravityResult) return { path: antigravityResult, viaProc: false };
     }
@@ -3646,7 +4925,8 @@ function discoverTranscriptFileImpl(sessionId, agentType, excludePaths) {
           info.cwd,
           info.pid,
           info.startEpochMs ? info.startEpochMs - 6e4 : void 0,
-          excludePaths
+          excludePaths,
+          discoveryIndex
         );
         if (cwdResult) return { path: cwdResult, viaProc: false };
       }
@@ -3657,7 +4937,13 @@ function discoverTranscriptFileImpl(sessionId, agentType, excludePaths) {
           { env: cleanEnv, timeout: 5e3, encoding: "utf-8" }
         ).trim();
         if (paneCwd) {
-          const cwdResult = discoverViaCwd(paneCwd, panePid ?? void 0, void 0, excludePaths);
+          const cwdResult = discoverViaCwd(
+            paneCwd,
+            panePid ?? void 0,
+            void 0,
+            excludePaths,
+            discoveryIndex
+          );
           if (cwdResult) return { path: cwdResult, viaProc: false };
         }
       } catch {
@@ -3669,14 +4955,20 @@ function discoverTranscriptFileImpl(sessionId, agentType, excludePaths) {
         agentInfos.map((info) => discoverCodexTranscriptFromHome(
           info.pid,
           info.startEpochMs ? info.startEpochMs - 6e4 : void 0,
-          excludePaths
+          excludePaths,
+          discoveryIndex
         )).filter((value) => Boolean(value)),
         { excludePaths }
       );
       if (newestForAgent) return { path: newestForAgent, viaProc: false };
     }
     if (agentType === "Gemini CLI") {
-      const geminiResult = discoverGeminiTranscriptFromHome(panePid ?? void 0, void 0, excludePaths);
+      const geminiResult = discoverGeminiTranscriptFromHome(
+        panePid ?? void 0,
+        void 0,
+        excludePaths,
+        discoveryIndex
+      );
       if (geminiResult) return { path: geminiResult, viaProc: false };
     }
     if (agentType === "Antigravity CLI") {
@@ -3703,7 +4995,8 @@ function discoverTranscriptFileImpl(sessionId, agentType, excludePaths) {
         agentInfos.map((info) => discoverAntigravityTranscriptFromHome(
           info.pid,
           info.startEpochMs ? info.startEpochMs - 6e4 : void 0,
-          excludePaths
+          excludePaths,
+          discoveryIndex
         )).filter((value) => Boolean(value)),
         { excludePaths }
       );
@@ -3713,11 +5006,17 @@ function discoverTranscriptFileImpl(sessionId, agentType, excludePaths) {
   }
   return { path: null, viaProc: false };
 }
-var MAX_PARTIAL_BUFFER = 256 * 1024;
+var MAX_JSONL_RECORD_BYTES = 8 * 1024 * 1024;
+var READ_CHUNK_BYTES = 256 * 1024;
+var MAX_READ_BYTES_PER_PASS = 4 * 1024 * 1024;
+var ASYNC_REPLAY_THRESHOLD_BYTES = 1024 * 1024;
+var ASYNC_REPLAY_YIELD_RECORDS = 64;
 var MAX_REPLAY_TURNS = 1e3;
 var POLL_INTERVAL_MS = 800;
 var DOC_READ_DEBOUNCE_MS = 200;
+var V2_OP_BATCH_WINDOW_MS = 35;
 var REDISCOVERY_INTERVAL_MS = 5e3;
+var MIN_REDISCOVERY_STAGGER_MS = 250;
 var MARKDOWN_RESYNC_DRAIN_MS = 300;
 var ENABLE_RETRY_DELAYS_MS = [1e3, 2e3, 5e3];
 var TranscriptWatcher = class {
@@ -3728,6 +5027,8 @@ var TranscriptWatcher = class {
   offset = 0;
   inode = 0;
   partialLine = "";
+  discardingOversizedLine = false;
+  decoder = new import_string_decoder.StringDecoder("utf8");
   seq = 0;
   turns = [];
   /** V2 normalized snapshot state. */
@@ -3735,6 +5036,17 @@ var TranscriptWatcher = class {
   watcher = null;
   pollTimer = null;
   docReadDebounceTimer = null;
+  pendingOpsTimer = null;
+  immediateReadTimer = null;
+  pendingOps = [];
+  pendingOpsSeq = 0;
+  replaying = false;
+  suppressReplayV1Deltas = false;
+  suppressReplayV2Deltas = false;
+  replayInProgress = false;
+  replayReadPending = false;
+  replayGeneration = 0;
+  replayPromise = Promise.resolve();
   stopped = false;
   subscriberCount = 0;
   documentFingerprint = "";
@@ -3780,7 +5092,11 @@ var TranscriptWatcher = class {
   }
   /** Stop watching. */
   stop() {
+    this.flushPendingOps();
     this.stopped = true;
+    this.replayGeneration++;
+    this.replayInProgress = false;
+    this.replayReadPending = false;
     if (this.watcher) {
       this.watcher.close();
       this.watcher = null;
@@ -3793,13 +5109,23 @@ var TranscriptWatcher = class {
       clearTimeout(this.docReadDebounceTimer);
       this.docReadDebounceTimer = null;
     }
+    if (this.pendingOpsTimer) {
+      clearTimeout(this.pendingOpsTimer);
+      this.pendingOpsTimer = null;
+    }
+    if (this.immediateReadTimer) {
+      clearTimeout(this.immediateReadTimer);
+      this.immediateReadTimer = null;
+    }
   }
-  /** Get accumulated turns for replay (up to MAX_REPLAY_TURNS). */
+  /** Get accumulated turns for replay (up to MAX_REPLAY_TURNS).
+   * `fromSeq` is retained for API compatibility only: V1 sequence numbers no
+   * longer map to array indexes now that V2 operations are batched. A V1 sync
+   * must therefore use the full bounded, idempotent snapshot. */
   getReplayTurns(fromSeq) {
-    if (fromSeq !== void 0) {
-      return this.turns.filter((_, i) => i >= fromSeq).slice(-MAX_REPLAY_TURNS);
-    }
-    return this.turns.slice(-MAX_REPLAY_TURNS);
+    this.flushPendingOps();
+    void fromSeq;
+    return boundMarkdownTurnsForWire(this.turns.slice(-MAX_REPLAY_TURNS));
   }
   /** Get current sequence number. */
   get currentSeq() {
@@ -3807,24 +5133,310 @@ var TranscriptWatcher = class {
   }
   /** Get the V2 normalized snapshot. */
   getSnapshot() {
+    this.flushPendingOps();
     return trimSnapshot(this.snapshot);
   }
+  queueV2Ops(ops) {
+    if (ops.length === 0) return;
+    const wireBatches = boundTranscriptOpsForWire(ops);
+    for (const batch of wireBatches) {
+      if (this.pendingOps.length > 0 && utf8Bytes([...this.pendingOps, ...batch]) > MAX_TRANSCRIPT_OP_BATCH_BYTES) {
+        this.flushPendingOps();
+      }
+      if (this.pendingOps.length === 0) {
+        this.seq++;
+        this.pendingOpsSeq = this.seq;
+      }
+      this.pendingOps.push(...batch);
+      if (wireBatches.length > 1) this.flushPendingOps();
+    }
+    if (ops.some((op) => this.isCompletionBarrier(op))) {
+      this.flushPendingOps();
+      return;
+    }
+    if (!this.pendingOpsTimer) {
+      this.pendingOpsTimer = setTimeout(() => {
+        this.pendingOpsTimer = null;
+        this.flushPendingOps();
+      }, V2_OP_BATCH_WINDOW_MS);
+      if (typeof this.pendingOpsTimer.unref === "function") {
+        this.pendingOpsTimer.unref();
+      }
+    }
+  }
+  isCompletionBarrier(op) {
+    if (op.op === "complete_block" || op.op === "complete_turn") return true;
+    return op.op === "set_tool_state" && (op.isComplete === true || op.state === "completed" || op.state === "error" || op.state === "cancelled");
+  }
+  flushPendingOps() {
+    if (this.pendingOpsTimer) {
+      clearTimeout(this.pendingOpsTimer);
+      this.pendingOpsTimer = null;
+    }
+    if (this.pendingOps.length === 0) return;
+    const ops = this.pendingOps;
+    const seq = this.pendingOpsSeq;
+    this.pendingOps = [];
+    this.pendingOpsSeq = 0;
+    try {
+      this.snapshot = applyOps(this.snapshot, ops);
+      this.callbacks.onOps?.(ops, seq);
+    } catch (error) {
+      this.reportParserFailure(
+        this.parserV2?.name ?? "transcript-v2",
+        "line",
+        error
+      );
+    }
+  }
+  /**
+   * Parser/schema drift must never terminate the connector: terminal transport
+   * and transcript rendering share this process. Report the bad record without
+   * including transcript content, then let the watcher continue with later
+   * records.
+   */
+  reportParserFailure(parserName, phase, error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    const message = `${parserName} failed to parse transcript ${phase}: ${detail}`;
+    try {
+      if (this.callbacks.onError) {
+        this.callbacks.onError(message);
+      } else {
+        log7.warn("transcript parser failure; record skipped", {
+          parser: parserName,
+          phase,
+          error: detail
+        });
+      }
+    } catch (callbackError) {
+      log7.warn("transcript parser failure callback also failed", {
+        parser: parserName,
+        phase,
+        error: detail,
+        callbackError: callbackError instanceof Error ? callbackError.message : String(callbackError)
+      });
+    }
+  }
   /** Read and replay the full transcript from the start of the file. */
   replayFromStart() {
+    this.flushPendingOps();
     if (this.parser.parseDocument) {
       this.readDocument(true);
       return;
     }
+    const wantsV1 = this.callbacks.shouldProcessV1?.() ?? true;
+    const wantsV2 = this.callbacks.shouldProcessV2?.() ?? Boolean(this.callbacks.onOps || this.callbacks.onSnapshot);
+    let stat;
+    try {
+      stat = fs2.statSync(this.filePath);
+    } catch {
+      return;
+    }
+    const canEmitOneSnapshot = (!wantsV1 || Boolean(this.callbacks.onTurnsSnapshot)) && (!wantsV2 || Boolean(this.callbacks.onSnapshot));
+    if (stat.size >= ASYNC_REPLAY_THRESHOLD_BYTES && canEmitOneSnapshot) {
+      const generation = ++this.replayGeneration;
+      this.replayInProgress = true;
+      this.replayPromise = this.replayLineHistoryAsync(
+        stat.size,
+        stat.ino,
+        generation,
+        wantsV1,
+        wantsV2
+      ).catch((error) => {
+        this.reportParserFailure(
+          this.parserV2?.name ?? this.parser.name,
+          "document",
+          error
+        );
+      }).finally(() => {
+        if (generation !== this.replayGeneration) return;
+        this.replayInProgress = false;
+        if (this.replayReadPending && !this.stopped) {
+          this.replayReadPending = false;
+          this.scheduleImmediateRead();
+        }
+      });
+      return;
+    }
+    let content;
+    try {
+      content = fs2.readFileSync(this.filePath, "utf-8");
+    } catch {
+      return;
+    }
     const savedOffset = this.offset;
-    this.offset = 0;
+    this.offset = Buffer.byteLength(content);
     this.partialLine = "";
+    this.discardingOversizedLine = false;
+    this.decoder = new import_string_decoder.StringDecoder("utf8");
+    this.turns = [];
     this.snapshot = createEmptySnapshot(this.snapshot.sessionId);
-    this.readNewData();
-    this.rebuildV2SnapshotFromDocument();
+    this.replaying = true;
+    this.suppressReplayV1Deltas = wantsV1 && Boolean(this.callbacks.onTurnsSnapshot);
+    this.suppressReplayV2Deltas = Boolean(
+      wantsV2 && this.parserV2?.parseDocument && this.callbacks.onSnapshot
+    );
+    try {
+      if (wantsV1) this.processChunk(content);
+    } finally {
+      this.replaying = false;
+      this.suppressReplayV1Deltas = false;
+      this.suppressReplayV2Deltas = false;
+    }
+    let rebuiltV2 = false;
+    if (wantsV2 && this.parserV2?.parseDocument && this.callbacks.onSnapshot) {
+      rebuiltV2 = this.rebuildV2SnapshotFromDocument(content);
+    }
+    const emitV1Snapshot = wantsV1 && Boolean(this.callbacks.onTurnsSnapshot);
+    const emitV2Snapshot = rebuiltV2 && Boolean(this.callbacks.onSnapshot);
+    if (emitV1Snapshot || emitV2Snapshot) {
+      this.seq++;
+      if (emitV1Snapshot) {
+        this.callbacks.onTurnsSnapshot(
+          boundMarkdownTurnsForWire(this.turns.slice(-MAX_REPLAY_TURNS)),
+          this.seq
+        );
+      }
+      if (emitV2Snapshot) {
+        this.callbacks.onSnapshot(this.snapshot, this.seq);
+      }
+    }
     if (this.offset < savedOffset) {
       this.offset = savedOffset;
     }
   }
+  /** Await the current historical replay. Small replays resolve immediately. */
+  waitForReplay() {
+    return this.replayPromise;
+  }
+  async replayLineHistoryAsync(replayEnd, replayInode, generation, wantsV1, wantsV2) {
+    this.offset = replayEnd;
+    this.partialLine = "";
+    this.discardingOversizedLine = false;
+    this.decoder = new import_string_decoder.StringDecoder("utf8");
+    this.turns = [];
+    this.snapshot = createEmptySnapshot(this.snapshot.sessionId);
+    let carry = "";
+    let discardingOversizedLine = false;
+    let recordsSinceYield = 0;
+    let sourceBytesSinceYield = 0;
+    let pendingReplayOps = [];
+    const stream = fs2.createReadStream(this.filePath, {
+      start: 0,
+      end: Math.max(0, replayEnd - 1),
+      encoding: "utf8",
+      highWaterMark: READ_CHUNK_BYTES
+    });
+    for await (const rawChunk of stream) {
+      if (generation !== this.replayGeneration || this.stopped) {
+        stream.destroy();
+        return;
+      }
+      let chunk = String(rawChunk);
+      if (discardingOversizedLine) {
+        const recordEnd = chunk.indexOf("\n");
+        if (recordEnd < 0) continue;
+        discardingOversizedLine = false;
+        chunk = chunk.slice(recordEnd + 1);
+      }
+      const combined = carry + chunk;
+      let lineStart = 0;
+      let lineEnd = combined.indexOf("\n", lineStart);
+      while (lineEnd >= 0) {
+        const line = combined.slice(lineStart, lineEnd);
+        lineStart = lineEnd + 1;
+        const lineBytes = Buffer.byteLength(line, "utf8");
+        if (lineBytes > MAX_JSONL_RECORD_BYTES) {
+          this.reportOversizedRecord();
+        } else {
+          const trimmed = line.trim();
+          if (trimmed) {
+            this.parseHistoricalLine(
+              trimmed,
+              wantsV1,
+              wantsV2,
+              pendingReplayOps
+            );
+          }
+        }
+        recordsSinceYield++;
+        sourceBytesSinceYield += lineBytes;
+        if (recordsSinceYield >= ASYNC_REPLAY_YIELD_RECORDS || sourceBytesSinceYield >= MAX_READ_BYTES_PER_PASS) {
+          recordsSinceYield = 0;
+          sourceBytesSinceYield = 0;
+          if (pendingReplayOps.length > 0) {
+            this.snapshot = applyOps(this.snapshot, pendingReplayOps);
+            pendingReplayOps = [];
+          }
+          await new Promise((resolve) => setImmediate(resolve));
+          if (generation !== this.replayGeneration || this.stopped) {
+            stream.destroy();
+            return;
+          }
+        }
+        lineEnd = combined.indexOf("\n", lineStart);
+      }
+      carry = combined.slice(lineStart);
+      if (Buffer.byteLength(carry, "utf8") > MAX_JSONL_RECORD_BYTES) {
+        this.reportOversizedRecord();
+        carry = "";
+        discardingOversizedLine = true;
+      }
+    }
+    if (generation !== this.replayGeneration || this.stopped) return;
+    try {
+      const currentStat = fs2.statSync(this.filePath);
+      if (currentStat.ino !== replayInode || currentStat.size < replayEnd) {
+        this.restartAfterRotation(currentStat);
+        return;
+      }
+    } catch {
+      return;
+    }
+    if (pendingReplayOps.length > 0) {
+      this.snapshot = applyOps(this.snapshot, pendingReplayOps);
+    }
+    this.partialLine = carry;
+    this.discardingOversizedLine = discardingOversizedLine;
+    this.seq++;
+    if (wantsV1 && this.callbacks.onTurnsSnapshot) {
+      this.callbacks.onTurnsSnapshot(
+        boundMarkdownTurnsForWire(this.turns.slice(-MAX_REPLAY_TURNS)),
+        this.seq
+      );
+    }
+    if (wantsV2 && this.callbacks.onSnapshot) {
+      this.snapshot = trimSnapshot(this.snapshot);
+      this.callbacks.onSnapshot(this.snapshot, this.seq);
+    }
+  }
+  parseHistoricalLine(line, wantsV1, wantsV2, pendingReplayOps) {
+    if (wantsV2 && this.parserV2) {
+      try {
+        const ops = this.parserV2.parseLine(line);
+        if (ops.length > 0) pendingReplayOps.push(...ops);
+      } catch (error) {
+        this.reportParserFailure(this.parserV2.name, "line", error);
+      }
+    }
+    if (!wantsV1) return;
+    try {
+      const turn = this.parser.parseLine(line);
+      if (!turn) return;
+      this.turns.push(boundMarkdownTurnForWire({
+        turnId: turn.turnId,
+        role: turn.role,
+        content: turn.content,
+        tools: turn.tools,
+        timestamp: turn.timestamp
+      }));
+      if (this.turns.length > MAX_REPLAY_TURNS * 2) {
+        this.turns = this.turns.slice(-MAX_REPLAY_TURNS);
+      }
+    } catch (error) {
+      this.reportParserFailure(this.parser.name, "line", error);
+    }
+  }
   /**
    * If the V2 parser supports parseDocument (e.g. Codex), rebuild the V2
    * snapshot from the full file contents and notify subscribers. This is the
@@ -3832,24 +5444,31 @@ var TranscriptWatcher = class {
    * unblocks blank-on-attach for agents whose V1 parser is line-based but
    * whose V2 parser can replay the whole document. See #473.
    */
-  rebuildV2SnapshotFromDocument() {
-    if (!this.parserV2?.parseDocument || !this.callbacks.onSnapshot) return;
-    let content;
+  rebuildV2SnapshotFromDocument(content) {
+    if (!this.parserV2?.parseDocument) return false;
+    let ops;
     try {
-      content = fs2.readFileSync(this.filePath, "utf-8");
-    } catch {
-      return;
+      ops = this.parserV2.parseDocument(content);
+    } catch (error) {
+      this.reportParserFailure(this.parserV2.name, "document", error);
+      return false;
     }
-    const ops = this.parserV2.parseDocument(content);
     if (ops.length === 0 && this.snapshot.turnOrder.length > 0) {
-      return;
+      return false;
     }
-    let nextSnapshot = createEmptySnapshot(this.snapshot.sessionId);
-    if (ops.length > 0) {
-      nextSnapshot = applyOps(nextSnapshot, ops);
+    try {
+      let nextSnapshot = createEmptySnapshot(this.snapshot.sessionId);
+      if (ops.length > 0) {
+        for (const batch of boundTranscriptOpsForWire(ops)) {
+          nextSnapshot = applyOps(nextSnapshot, batch);
+        }
+      }
+      this.snapshot = nextSnapshot;
+      return true;
+    } catch (error) {
+      this.reportParserFailure(this.parserV2.name, "document", error);
+      return false;
     }
-    this.snapshot = trimSnapshot(nextSnapshot);
-    this.callbacks.onSnapshot(this.snapshot, this.seq);
   }
   startWatching() {
     try {
@@ -3882,17 +5501,54 @@ var TranscriptWatcher = class {
     try {
       const stat = fs2.statSync(this.filePath);
       if (stat.ino !== this.inode) {
-        this.inode = stat.ino;
-        this.offset = 0;
-        this.partialLine = "";
+        if (this.parser.parseDocument) {
+          this.resetReadCursor(stat);
+        } else {
+          this.restartAfterRotation(stat);
+        }
       } else if (stat.size < this.offset) {
-        this.offset = 0;
-        this.partialLine = "";
+        if (this.parser.parseDocument) {
+          this.resetReadCursor(stat);
+        } else {
+          this.restartAfterRotation(stat);
+        }
       }
     } catch {
     }
   }
+  resetReadCursor(stat) {
+    this.flushPendingOps();
+    this.inode = stat.ino;
+    this.offset = 0;
+    this.partialLine = "";
+    this.discardingOversizedLine = false;
+    this.decoder = new import_string_decoder.StringDecoder("utf8");
+  }
+  restartAfterRotation(stat) {
+    this.flushPendingOps();
+    this.replayGeneration++;
+    this.replayInProgress = false;
+    this.replayReadPending = false;
+    this.inode = stat.ino;
+    this.offset = stat.size;
+    this.partialLine = "";
+    this.discardingOversizedLine = false;
+    this.decoder = new import_string_decoder.StringDecoder("utf8");
+    this.turns = [];
+    this.snapshot = createEmptySnapshot(this.snapshot.sessionId);
+    if (this.callbacks.shouldProcessV1?.() !== false) {
+      this.callbacks.onTurnsSnapshot?.([], 0);
+    }
+    if ((this.callbacks.shouldProcessV2?.() ?? Boolean(this.callbacks.onSnapshot)) && this.callbacks.onSnapshot) {
+      this.callbacks.onSnapshot(this.snapshot, 0, true);
+    }
+    this.replayFromStart();
+  }
   readNewData() {
+    if (this.replayInProgress) {
+      this.replayReadPending = true;
+      return;
+    }
     if (this.parser.parseDocument) {
       this.readDocument(false);
       return;
@@ -3906,17 +5562,36 @@ var TranscriptWatcher = class {
     try {
       const stat = fs2.fstatSync(fd);
       if (stat.size <= this.offset) return;
-      const readSize = Math.min(stat.size - this.offset, 256 * 1024);
-      const buffer = Buffer.alloc(readSize);
-      const bytesRead = fs2.readSync(fd, buffer, 0, readSize, this.offset);
-      if (bytesRead === 0) return;
-      this.offset += bytesRead;
-      const chunk = buffer.subarray(0, bytesRead).toString("utf-8");
-      this.processChunk(chunk);
+      let remaining = Math.min(
+        stat.size - this.offset,
+        MAX_READ_BYTES_PER_PASS
+      );
+      while (remaining > 0) {
+        const readSize = Math.min(remaining, READ_CHUNK_BYTES);
+        const buffer = Buffer.allocUnsafe(readSize);
+        const bytesRead = fs2.readSync(fd, buffer, 0, readSize, this.offset);
+        if (bytesRead === 0) break;
+        this.offset += bytesRead;
+        remaining -= bytesRead;
+        this.processChunk(this.decoder.write(buffer.subarray(0, bytesRead)));
+      }
+      if (this.offset < stat.size) {
+        this.scheduleImmediateRead();
+      }
     } finally {
       fs2.closeSync(fd);
     }
   }
+  scheduleImmediateRead() {
+    if (this.immediateReadTimer || this.stopped) return;
+    this.immediateReadTimer = setTimeout(() => {
+      this.immediateReadTimer = null;
+      if (!this.stopped) this.readNewData();
+    }, 0);
+    if (typeof this.immediateReadTimer.unref === "function") {
+      this.immediateReadTimer.unref();
+    }
+  }
   readDocument(force) {
     let stat;
     try {
@@ -3933,68 +5608,142 @@ var TranscriptWatcher = class {
       return;
     }
     this.documentFingerprint = fingerprint;
-    const parsedTurns = this.parser.parseDocument?.(content) ?? [];
-    const v2Ops = this.parserV2?.parseDocument?.(content) ?? [];
+    let parsedTurns;
+    try {
+      parsedTurns = this.parser.parseDocument?.(content) ?? [];
+    } catch (error) {
+      this.reportParserFailure(this.parser.name, "document", error);
+      return;
+    }
+    let v2Ops;
+    try {
+      v2Ops = this.parserV2?.parseDocument?.(content) ?? [];
+    } catch (error) {
+      this.reportParserFailure(
+        this.parserV2?.name ?? "transcript-v2",
+        "document",
+        error
+      );
+      return;
+    }
     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,
-      role: turn.role,
-      content: turn.content,
-      tools: turn.tools,
-      timestamp: turn.timestamp
-    }));
-    this.callbacks.onTurnsSnapshot?.(this.turns, this.seq);
-    if (this.parserV2?.parseDocument && this.callbacks.onSnapshot) {
-      let nextSnapshot = createEmptySnapshot(this.snapshot.sessionId);
-      if (v2Ops.length > 0) {
-        nextSnapshot = applyOps(nextSnapshot, v2Ops);
+    try {
+      this.flushPendingOps();
+      this.seq++;
+      this.turns = parsedTurns.slice(-MAX_REPLAY_TURNS).map((turn) => boundMarkdownTurnForWire({
+        turnId: turn.turnId,
+        role: turn.role,
+        content: turn.content,
+        tools: turn.tools,
+        timestamp: turn.timestamp
+      }));
+      this.callbacks.onTurnsSnapshot?.(
+        boundMarkdownTurnsForWire(this.turns),
+        this.seq
+      );
+      if (this.parserV2?.parseDocument && this.callbacks.onSnapshot) {
+        let nextSnapshot = createEmptySnapshot(this.snapshot.sessionId);
+        if (v2Ops.length > 0) {
+          for (const batch of boundTranscriptOpsForWire(v2Ops)) {
+            nextSnapshot = applyOps(nextSnapshot, batch);
+          }
+        }
+        this.snapshot = nextSnapshot;
+        this.callbacks.onSnapshot(this.snapshot, this.seq);
       }
-      this.snapshot = trimSnapshot(nextSnapshot);
-      this.callbacks.onSnapshot(this.snapshot, this.seq);
+    } catch (error) {
+      this.reportParserFailure(
+        this.parserV2?.name ?? this.parser.name,
+        "document",
+        error
+      );
     }
   }
   processChunk(chunk) {
+    if (this.discardingOversizedLine) {
+      const recordEnd = chunk.indexOf("\n");
+      if (recordEnd < 0) return;
+      this.discardingOversizedLine = false;
+      chunk = chunk.slice(recordEnd + 1);
+    }
     const combined = this.partialLine + chunk;
     const lines = combined.split("\n");
     this.partialLine = lines.pop() ?? "";
-    if (this.partialLine.length > MAX_PARTIAL_BUFFER) {
-      this.callbacks.onError?.("Partial line buffer exceeded limit, discarding");
+    if (Buffer.byteLength(this.partialLine, "utf8") > MAX_JSONL_RECORD_BYTES) {
+      this.reportOversizedRecord();
       this.partialLine = "";
+      this.discardingOversizedLine = true;
     }
     for (const line of lines) {
+      if (Buffer.byteLength(line, "utf8") > MAX_JSONL_RECORD_BYTES) {
+        this.reportOversizedRecord();
+        continue;
+      }
       const trimmed = line.trim();
       if (!trimmed) continue;
-      if (this.parserV2 && this.callbacks.onOps) {
-        const ops = this.parserV2.parseLine(trimmed);
-        if (ops.length > 0) {
-          this.seq++;
-          this.snapshot = applyOps(this.snapshot, ops);
-          this.snapshot = trimSnapshot(this.snapshot);
-          this.callbacks.onOps(ops, this.seq);
-        }
-      }
-      const turn = this.parser.parseLine(trimmed);
-      if (turn) {
-        if (!this.parserV2 || !this.callbacks.onOps) {
-          this.seq++;
-        }
-        this.turns.push({
-          turnId: turn.turnId,
-          role: turn.role,
-          content: turn.content,
-          tools: turn.tools,
-          timestamp: turn.timestamp
-        });
-        if (this.turns.length > MAX_REPLAY_TURNS * 2) {
-          this.turns = this.turns.slice(-MAX_REPLAY_TURNS);
+      let v2Queued = false;
+      const deferV2ToDocumentReplay = this.replaying && this.suppressReplayV2Deltas;
+      const shouldProcessV2 = this.callbacks.shouldProcessV2?.() ?? Boolean(this.callbacks.onOps || this.callbacks.onSnapshot);
+      if (!deferV2ToDocumentReplay && this.parserV2 && shouldProcessV2 && (this.callbacks.onOps || this.callbacks.onSnapshot)) {
+        try {
+          const ops = this.parserV2.parseLine(trimmed);
+          if (ops.length > 0) {
+            this.queueV2Ops(ops);
+            v2Queued = true;
+          }
+        } catch (error) {
+          this.reportParserFailure(this.parserV2.name, "line", error);
         }
-        this.callbacks.onTurn(turn, this.seq);
       }
+      if (this.callbacks.shouldProcessV1?.() === false) continue;
+      try {
+        const turn = this.parser.parseLine(trimmed);
+        if (turn) {
+          const emitV1Delta = !this.replaying || !this.suppressReplayV1Deltas;
+          if (!v2Queued && emitV1Delta) {
+            this.flushPendingOps();
+            this.seq++;
+          }
+          const boundedTurn = boundMarkdownTurnForWire({
+            turnId: turn.turnId,
+            role: turn.role,
+            content: turn.content,
+            tools: turn.tools,
+            timestamp: turn.timestamp
+          });
+          this.turns.push(boundedTurn);
+          if (this.turns.length > MAX_REPLAY_TURNS * 2) {
+            this.turns = this.turns.slice(-MAX_REPLAY_TURNS);
+          }
+          if (emitV1Delta) {
+            this.callbacks.onTurn(boundedTurn, this.seq);
+          }
+        }
+      } catch (error) {
+        this.reportParserFailure(this.parser.name, "line", error);
+      }
+    }
+  }
+  reportOversizedRecord() {
+    const message = `Transcript JSONL record exceeded ${MAX_JSONL_RECORD_BYTES} bytes; record omitted and streaming resumed at the next line`;
+    try {
+      if (this.callbacks.onError) {
+        this.callbacks.onError(message);
+      } else {
+        log7.warn("oversized transcript record omitted", {
+          filePath: this.filePath,
+          maxBytes: MAX_JSONL_RECORD_BYTES
+        });
+      }
+    } catch (error) {
+      log7.warn("oversized transcript error callback threw", {
+        filePath: this.filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
   }
 };
@@ -4011,7 +5760,11 @@ function getParser(agentType) {
 }
 var TranscriptWatcherManager = class {
   active = /* @__PURE__ */ new Map();
-  rediscoveryTimers = /* @__PURE__ */ new Map();
+  /** One staggered round-robin scheduler replaces synchronized per-session timers. */
+  rediscoverySessions = /* @__PURE__ */ new Map();
+  rediscoveryTimer;
+  rediscoveryCursor = 0;
+  rediscoveryIndex;
   /** #542: sessions awaiting a markdown snapshot re-emit after a frame drop. */
   pendingMarkdownResync = /* @__PURE__ */ new Set();
   markdownResyncTimer;
@@ -4019,6 +5772,10 @@ var TranscriptWatcherManager = class {
   enableRetryTimers = /* @__PURE__ */ new Map();
   /** Index into ENABLE_RETRY_DELAYS_MS for the next scheduled attempt. */
   enableRetryAttempts = /* @__PURE__ */ new Map();
+  /** Desired subscriptions outlive transient discovery failures. Keeping this
+   * per viewer prevents one pane's disable from cancelling another pane's
+   * pending retry and lets a replacement watcher restore every subscriber. */
+  desiredSubscriptions = /* @__PURE__ */ new Map();
   sendFn;
   sendSnapshotFn;
   sendOpsFn;
@@ -4032,16 +5789,33 @@ var TranscriptWatcherManager = class {
     this.onEnableRetrySuccess = onEnableRetrySuccess;
   }
   /** Enable markdown streaming for a session. */
-  enableMarkdown(sessionId, agentType) {
+  enableMarkdown(sessionId, agentType, viewerId, schemaVersion) {
+    const subscriberKey = viewerId || "__legacy_anonymous__";
+    let desired = this.desiredSubscriptions.get(sessionId);
+    if (!desired) {
+      desired = /* @__PURE__ */ new Map();
+      this.desiredSubscriptions.set(sessionId, desired);
+    }
+    desired.set(subscriberKey, {
+      agentType,
+      schemaVersion: schemaVersion === 2 ? 2 : schemaVersion === 1 ? 1 : 0
+    });
+    if (!this.enableRetryTimers.has(sessionId) && !this.enableRetryAttempts.has(sessionId)) {
+      this.enableRetryAttempts.set(sessionId, 0);
+    }
     return this.enableMarkdownInternal(
       sessionId,
       agentType,
       /* isRetry */
-      false
+      false,
+      viewerId,
+      schemaVersion
     );
   }
-  enableMarkdownInternal(sessionId, agentType, isRetry) {
+  enableMarkdownInternal(sessionId, agentType, isRetry, viewerId, schemaVersion) {
     const requestedAgentType = agentType ?? "";
+    const subscriberKey = viewerId || "__legacy_anonymous__";
+    const requestedSchema = schemaVersion === 2 ? 2 : schemaVersion === 1 ? 1 : 0;
     const lockedSource = getSessionSourceLock(sessionId);
     if (lockedSource && lockedSource !== "file-watcher") {
       log7.info("native-stream consumer owns session; skipping file watch", {
@@ -4049,11 +5823,22 @@ var TranscriptWatcherManager = class {
         agentType,
         lockedSource
       });
-      this.cancelEnableRetry(sessionId);
+      this.removeDesiredSubscription(sessionId, subscriberKey);
+      this.cancelEnableRetryIfUnused(sessionId);
+      return { ok: false, reason: "unsupported_agent" };
+    }
+    const parser = getParser(agentType);
+    if (!parser) {
+      log7.info("no transcript parser for agent type", { agentType });
+      this.removeDesiredSubscription(sessionId, subscriberKey);
+      this.cancelEnableRetryIfUnused(sessionId);
       return { ok: false, reason: "unsupported_agent" };
     }
     const existing = this.active.get(sessionId);
     let replacingExisting = false;
+    let replacementSubscribers;
+    let existingToReplace;
+    let replacementFilePath;
     if (existing) {
       const newPath = discoverTranscriptFileDetailed(
         sessionId,
@@ -4064,34 +5849,31 @@ var TranscriptWatcherManager = class {
       const pathChanged = Boolean(newPath && newPath !== existing.filePath);
       const existingPathGone = !fs2.existsSync(existing.filePath);
       if (!agentChanged && !pathChanged && !existingPathGone) {
-        existing.watcher.addSubscriber();
+        if (!existing.subscribers.has(subscriberKey)) {
+          existing.watcher.addSubscriber();
+        }
+        existing.subscribers.set(subscriberKey, requestedSchema);
         this.cancelEnableRetry(sessionId);
         return { ok: true };
       }
-      existing.watcher.stop();
-      this.active.delete(sessionId);
-      this.stopRediscovery(sessionId);
-      replacingExisting = true;
+      replacementSubscribers = new Map(existing.subscribers);
+      replacementSubscribers.set(subscriberKey, requestedSchema);
       if (!newPath) {
         log7.info("no replacement transcript file found", { sessionId, agentType });
-        this.armEnableRetry(sessionId, agentType);
+        this.armEnableRetry(sessionId);
         return { ok: false, reason: "no_transcript" };
       }
+      existingToReplace = existing;
+      replacementFilePath = newPath;
     }
-    const parser = getParser(agentType);
-    if (!parser) {
-      log7.info("no transcript parser for agent type", { agentType });
-      this.cancelEnableRetry(sessionId);
-      return { ok: false, reason: "unsupported_agent" };
-    }
-    const filePath = discoverTranscriptFileDetailed(
+    const filePath = replacementFilePath ?? discoverTranscriptFileDetailed(
       sessionId,
       agentType,
       this.ownedPathsExcept(sessionId)
     ).path;
     if (!filePath) {
       log7.info("no transcript file found", { sessionId });
-      this.armEnableRetry(sessionId, agentType);
+      this.armEnableRetry(sessionId);
       return { ok: false, reason: "no_transcript" };
     }
     log7.info("watching transcript", { path: filePath, parser: parser.name });
@@ -4101,17 +5883,27 @@ var TranscriptWatcherManager = class {
       parser,
       {
         onTurn: (turn, seq) => {
-          this.sendFn(sessionId, turn, seq);
+          if (this.hasLegacySubscribers(sessionId)) {
+            this.sendFn(sessionId, turn, seq);
+          }
         },
         onOps: this.sendOpsFn ? (ops, seq) => {
-          this.sendOpsFn(sessionId, ops, seq);
+          if (this.hasV2Subscribers(sessionId)) {
+            this.sendOpsFn(sessionId, ops, seq);
+          }
         } : void 0,
         onTurnsSnapshot: (turns, seq) => {
-          this.sendSnapshotFn(sessionId, turns, seq);
+          if (this.hasLegacySubscribers(sessionId)) {
+            this.sendSnapshotFn(sessionId, turns, seq);
+          }
         },
-        onSnapshot: this.sendV2SnapshotFn ? (snapshot, seq) => {
-          this.sendV2SnapshotFn(sessionId, snapshot, seq);
+        onSnapshot: this.sendV2SnapshotFn ? (snapshot, seq, reset) => {
+          if (this.hasV2Subscribers(sessionId)) {
+            this.sendV2SnapshotFn(sessionId, snapshot, seq, reset);
+          }
         } : void 0,
+        shouldProcessV1: () => this.hasLegacySubscribers(sessionId),
+        shouldProcessV2: () => this.hasV2Subscribers(sessionId),
         onError: (error) => {
           log7.warn("transcript watcher error", { sessionId, error: String(error) });
         }
@@ -4121,13 +5913,32 @@ var TranscriptWatcherManager = class {
     );
     if (!watcher.start()) {
       log7.warn("failed to start watching", { path: filePath });
-      this.armEnableRetry(sessionId, agentType);
+      this.armEnableRetry(sessionId);
       return { ok: false, reason: "watch_failed" };
     }
+    const subscribers = replacementSubscribers ?? /* @__PURE__ */ new Map();
+    for (const [key, intent] of this.desiredSubscriptions.get(sessionId) ?? []) {
+      subscribers.set(key, intent.schemaVersion);
+    }
+    if (subscribers.size === 0) {
+      subscribers.set(subscriberKey, requestedSchema);
+    }
+    for (let i = 1; i < subscribers.size; i++) {
+      watcher.addSubscriber();
+    }
+    if (existingToReplace) {
+      existingToReplace.watcher.stop();
+      replacingExisting = true;
+    }
+    this.active.set(sessionId, {
+      watcher,
+      filePath,
+      agentType: agentType ?? "",
+      subscribers
+    });
     if (replacingExisting) {
       this.clearTranscriptState(sessionId);
     }
-    this.active.set(sessionId, { watcher, filePath, agentType: agentType ?? "" });
     watcher.replayFromStart();
     this.startRediscovery(sessionId, agentType);
     this.cancelEnableRetry(sessionId);
@@ -4148,24 +5959,39 @@ var TranscriptWatcherManager = class {
    * loading placeholder, and a subsequent prefer-markdown from the portal
    * (e.g. on reconnect or pane re-focus) will start a fresh attempt.
    */
-  armEnableRetry(sessionId, agentType) {
+  armEnableRetry(sessionId) {
+    const desired = this.desiredSubscriptions.get(sessionId);
+    if (!desired || desired.size === 0) {
+      this.cancelEnableRetry(sessionId);
+      return;
+    }
     const nextAttempt = this.enableRetryAttempts.get(sessionId) ?? 0;
     if (nextAttempt >= ENABLE_RETRY_DELAYS_MS.length) {
       this.cancelEnableRetry(sessionId);
       return;
     }
     const existing = this.enableRetryTimers.get(sessionId);
-    if (existing) clearTimeout(existing);
+    if (existing) return;
     const delay2 = ENABLE_RETRY_DELAYS_MS[nextAttempt];
     const timer = setTimeout(() => {
       this.enableRetryAttempts.set(sessionId, nextAttempt + 1);
       this.enableRetryTimers.delete(sessionId);
+      const currentDesired = this.desiredSubscriptions.get(sessionId);
+      const next = currentDesired?.entries().next();
+      if (!next || next.done) {
+        this.cancelEnableRetry(sessionId);
+        return;
+      }
+      const [subscriberKey, intent] = next.value;
+      const viewerId = subscriberKey === "__legacy_anonymous__" ? void 0 : subscriberKey;
       try {
         this.enableMarkdownInternal(
           sessionId,
-          agentType,
+          intent.agentType,
           /* isRetry */
-          true
+          true,
+          viewerId,
+          intent.schemaVersion
         );
       } catch (err) {
         log7.warn("enableMarkdown retry threw", { sessionId, err: String(err) });
@@ -4182,9 +6008,22 @@ var TranscriptWatcherManager = class {
     }
     this.enableRetryAttempts.delete(sessionId);
   }
+  removeDesiredSubscription(sessionId, subscriberKey) {
+    const desired = this.desiredSubscriptions.get(sessionId);
+    if (!desired) return;
+    desired.delete(subscriberKey);
+    if (desired.size === 0) this.desiredSubscriptions.delete(sessionId);
+  }
+  cancelEnableRetryIfUnused(sessionId) {
+    if ((this.desiredSubscriptions.get(sessionId)?.size ?? 0) === 0) {
+      this.cancelEnableRetry(sessionId);
+    }
+  }
   clearTranscriptState(sessionId) {
-    this.sendSnapshotFn(sessionId, [], 0);
-    if (this.sendV2SnapshotFn) {
+    if (this.hasLegacySubscribers(sessionId)) {
+      this.sendSnapshotFn(sessionId, [], 0);
+    }
+    if (this.hasV2Subscribers(sessionId) && this.sendV2SnapshotFn) {
       this.sendV2SnapshotFn(sessionId, createEmptySnapshot(sessionId), 0, true);
     }
   }
@@ -4204,15 +6043,52 @@ var TranscriptWatcherManager = class {
     }
     return owned;
   }
+  hasLegacySubscribers(sessionId) {
+    const session = this.active.get(sessionId);
+    if (!session) return true;
+    for (const schemaVersion of session.subscribers.values()) {
+      if (schemaVersion !== 2) return true;
+    }
+    return false;
+  }
+  hasV2Subscribers(sessionId) {
+    const session = this.active.get(sessionId);
+    if (!session) return false;
+    for (const schemaVersion of session.subscribers.values()) {
+      if (schemaVersion !== 1) return true;
+    }
+    return false;
+  }
   /** Disable markdown streaming for a session. */
-  disableMarkdown(sessionId) {
-    this.cancelEnableRetry(sessionId);
+  disableMarkdown(sessionId, viewerId) {
+    const subscriberKey = viewerId || "__legacy_anonymous__";
+    const desired = this.desiredSubscriptions.get(sessionId);
+    const stopWholeSession = !viewerId && !desired?.has(subscriberKey);
+    if (stopWholeSession) {
+      this.desiredSubscriptions.delete(sessionId);
+      this.cancelEnableRetry(sessionId);
+    } else {
+      this.removeDesiredSubscription(sessionId, subscriberKey);
+      this.cancelEnableRetryIfUnused(sessionId);
+    }
     const session = this.active.get(sessionId);
     if (!session) return;
+    if (!viewerId && !session.subscribers.has(subscriberKey)) {
+      session.subscribers.clear();
+      session.watcher.stop();
+      this.active.delete(sessionId);
+      this.stopRediscovery(sessionId);
+      this.pendingMarkdownResync.delete(sessionId);
+      log7.info("stopped watching transcript", { sessionId });
+      return;
+    }
+    if (!session.subscribers.has(subscriberKey)) return;
+    session.subscribers.delete(subscriberKey);
     const remaining = session.watcher.removeSubscriber();
     if (remaining > 0) {
       log7.info("viewer left transcript watcher; other viewers still subscribed", {
         sessionId,
+        viewerId,
         remaining
       });
       return;
@@ -4224,74 +6100,164 @@ var TranscriptWatcherManager = class {
   }
   /** Periodically check if the transcript file has changed (new conversation). */
   startRediscovery(sessionId, agentType) {
-    this.stopRediscovery(sessionId);
-    const timer = setInterval(() => {
-      const session = this.active.get(sessionId);
-      if (!session) {
-        this.stopRediscovery(sessionId);
-        return;
+    this.rediscoverySessions.set(sessionId, agentType);
+    this.rediscoveryCursor = 0;
+    this.rediscoveryIndex = void 0;
+    this.scheduleRediscovery(true);
+  }
+  scheduleRediscovery(restart = false) {
+    if (restart && this.rediscoveryTimer) {
+      clearTimeout(this.rediscoveryTimer);
+      this.rediscoveryTimer = void 0;
+    }
+    if (this.rediscoveryTimer || this.rediscoverySessions.size === 0) return;
+    const delay2 = Math.max(
+      MIN_REDISCOVERY_STAGGER_MS,
+      Math.ceil(REDISCOVERY_INTERVAL_MS / this.rediscoverySessions.size)
+    );
+    this.rediscoveryTimer = setTimeout(() => {
+      this.rediscoveryTimer = void 0;
+      this.runRediscoveryTick();
+    }, delay2);
+    if (typeof this.rediscoveryTimer.unref === "function") {
+      this.rediscoveryTimer.unref();
+    }
+  }
+  runRediscoveryTick() {
+    for (const sessionId2 of this.rediscoverySessions.keys()) {
+      if (!this.active.has(sessionId2)) {
+        this.rediscoverySessions.delete(sessionId2);
       }
-      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();
-      const parser = getParser(agentType);
-      if (!parser) return;
-      const newV2Parser = getParserV2(agentType);
-      const newWatcher = new TranscriptWatcher(
-        newPath,
-        parser,
-        {
-          onTurn: (turn, seq) => {
+    }
+    const sessionIds = [...this.rediscoverySessions.keys()];
+    if (sessionIds.length === 0) {
+      this.rediscoveryCursor = 0;
+      this.rediscoveryIndex = void 0;
+      return;
+    }
+    if (this.rediscoveryCursor >= sessionIds.length) {
+      this.rediscoveryCursor = 0;
+      this.rediscoveryIndex = void 0;
+    }
+    const sessionId = sessionIds[this.rediscoveryCursor];
+    const agentType = this.rediscoverySessions.get(sessionId);
+    const discoveryIndex = this.rediscoveryIndex ?? createTranscriptDiscoveryIndex();
+    this.rediscoveryIndex = discoveryIndex;
+    this.rediscoverSession(sessionId, agentType, discoveryIndex);
+    this.rediscoveryCursor++;
+    if (this.rediscoveryCursor >= sessionIds.length) {
+      this.rediscoveryCursor = 0;
+      this.rediscoveryIndex = void 0;
+    }
+    this.scheduleRediscovery();
+  }
+  rediscoverSession(sessionId, agentType, discoveryIndex) {
+    const session = this.active.get(sessionId);
+    if (!session) return;
+    const { path: newPath } = discoverTranscriptFileDetailed(
+      sessionId,
+      agentType,
+      this.ownedPathsExcept(sessionId),
+      discoveryIndex
+    );
+    if (!newPath || newPath === session.filePath) return;
+    log7.info("transcript file changed", { sessionId, newPath });
+    const parser = getParser(agentType);
+    if (!parser) return;
+    const newV2Parser = getParserV2(agentType);
+    const newWatcher = new TranscriptWatcher(
+      newPath,
+      parser,
+      {
+        onTurn: (turn, seq) => {
+          if (this.hasLegacySubscribers(sessionId)) {
             this.sendFn(sessionId, turn, seq);
-          },
-          onOps: this.sendOpsFn ? (ops, seq) => {
+          }
+        },
+        onOps: this.sendOpsFn ? (ops, seq) => {
+          if (this.hasV2Subscribers(sessionId)) {
             this.sendOpsFn(sessionId, ops, seq);
-          } : void 0,
-          onTurnsSnapshot: (turns, seq) => {
+          }
+        } : void 0,
+        onTurnsSnapshot: (turns, seq) => {
+          if (this.hasLegacySubscribers(sessionId)) {
             this.sendSnapshotFn(sessionId, turns, seq);
-          },
-          onSnapshot: this.sendV2SnapshotFn ? (snapshot, seq) => {
-            this.sendV2SnapshotFn(sessionId, snapshot, seq);
-          } : void 0,
-          onError: (error) => {
-            log7.warn("transcript watcher error", { sessionId, error: String(error) });
           }
         },
-        newV2Parser,
-        sessionId
-      );
-      if (!newWatcher.start()) {
-        log7.warn("failed to start watching new transcript", { newPath });
-        return;
-      }
-      this.sendSnapshotFn(sessionId, [], 0);
-      if (this.sendV2SnapshotFn) {
-        this.sendV2SnapshotFn(sessionId, createEmptySnapshot(sessionId), 0, true);
-      }
-      newWatcher.replayFromStart();
-      this.active.set(sessionId, { watcher: newWatcher, filePath: newPath, agentType: agentType ?? "" });
-    }, REDISCOVERY_INTERVAL_MS);
-    this.rediscoveryTimers.set(sessionId, timer);
+        onSnapshot: this.sendV2SnapshotFn ? (snapshot, seq, reset) => {
+          if (this.hasV2Subscribers(sessionId)) {
+            this.sendV2SnapshotFn(sessionId, snapshot, seq, reset);
+          }
+        } : void 0,
+        shouldProcessV1: () => this.hasLegacySubscribers(sessionId),
+        shouldProcessV2: () => this.hasV2Subscribers(sessionId),
+        onError: (error) => {
+          log7.warn("transcript watcher error", {
+            sessionId,
+            error: String(error)
+          });
+        }
+      },
+      newV2Parser,
+      sessionId
+    );
+    if (!newWatcher.start()) {
+      log7.warn("failed to start watching new transcript", { newPath });
+      return;
+    }
+    for (let i = 1; i < session.subscribers.size; i++) {
+      newWatcher.addSubscriber();
+    }
+    session.watcher.stop();
+    this.active.set(sessionId, {
+      watcher: newWatcher,
+      filePath: newPath,
+      agentType: agentType ?? "",
+      subscribers: session.subscribers
+    });
+    this.clearTranscriptState(sessionId);
+    newWatcher.replayFromStart();
   }
-  /** Stop the re-discovery timer for a session. */
+  /** Remove a session from the shared re-discovery scheduler. */
   stopRediscovery(sessionId) {
-    const timer = this.rediscoveryTimers.get(sessionId);
-    if (timer) {
-      clearInterval(timer);
-      this.rediscoveryTimers.delete(sessionId);
-    }
+    if (!this.rediscoverySessions.delete(sessionId)) return;
+    this.rediscoveryCursor = 0;
+    this.rediscoveryIndex = void 0;
+    this.scheduleRediscovery(true);
   }
-  /** Handle sync-markdown request — send replay snapshot (V1 + V2). */
-  handleSyncRequest(sessionId, fromSeq) {
+  /**
+   * Handle sync-markdown. V2 sync is always snapshot-only because the relay
+   * group is broadcast and the portal has no logical-op deduplication. A
+   * future `fromSeq` is therefore also answered with current idempotent state.
+   * Callers without a schema keep the legacy dual-snapshot behavior.
+   */
+  handleSyncRequest(sessionId, fromSeq, schemaVersion, viewerId) {
     const session = this.active.get(sessionId);
     if (!session) return;
-    const turns = session.watcher.getReplayTurns(fromSeq);
+    if (viewerId) {
+      const subscriberKey = viewerId;
+      if (session.subscribers.has(subscriberKey)) {
+        const requestedSchema = schemaVersion === 2 ? 2 : schemaVersion === 1 ? 1 : 0;
+        session.subscribers.set(subscriberKey, requestedSchema);
+        const intent = this.desiredSubscriptions.get(sessionId)?.get(subscriberKey);
+        if (intent) intent.schemaVersion = requestedSchema;
+      }
+    }
+    void fromSeq;
+    if (schemaVersion === 2) {
+      if (this.sendV2SnapshotFn) {
+        const snapshot = session.watcher.getSnapshot();
+        this.sendV2SnapshotFn(
+          sessionId,
+          snapshot,
+          session.watcher.currentSeq
+        );
+      }
+      return;
+    }
+    const turns = session.watcher.getReplayTurns();
     this.sendSnapshotFn(sessionId, turns, session.watcher.currentSeq);
+    if (schemaVersion === 1) return;
     if (this.sendV2SnapshotFn) {
       const snapshot = session.watcher.getSnapshot();
       this.sendV2SnapshotFn(sessionId, snapshot, session.watcher.currentSeq);
@@ -4303,15 +6269,16 @@ var TranscriptWatcherManager = class {
    * 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.
+   * reconnect. Re-emit bounded V1 and/or V2 snapshots according to active
+   * subscriber capabilities, draining one session per tick so recovery does
+   * not 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) {
+      const legacyPopulated = this.hasLegacySubscribers(sessionId) && session.watcher.getReplayTurns().length > 0;
+      const v2Subscribed = this.hasV2Subscribers(sessionId) && Boolean(this.sendV2SnapshotFn);
+      if (legacyPopulated || v2Subscribed) {
         this.pendingMarkdownResync.add(sessionId);
         queued = true;
       }
@@ -4331,12 +6298,22 @@ var TranscriptWatcherManager = class {
       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
-        );
+      if (session) {
+        if (this.hasLegacySubscribers(sessionId)) {
+          this.sendSnapshotFn(
+            sessionId,
+            session.watcher.getReplayTurns(),
+            session.watcher.currentSeq
+          );
+        }
+        if (this.hasV2Subscribers(sessionId) && this.sendV2SnapshotFn) {
+          this.sendV2SnapshotFn(
+            sessionId,
+            session.watcher.getSnapshot(),
+            session.watcher.currentSeq,
+            true
+          );
+        }
       }
     }, MARKDOWN_RESYNC_DRAIN_MS);
     if (typeof this.markdownResyncTimer.unref === "function") {
@@ -4355,16 +6332,22 @@ var TranscriptWatcherManager = class {
     this.stopMarkdownResync();
     for (const [sessionId, session] of this.active) {
       session.watcher.stop();
-      this.stopRediscovery(sessionId);
       log7.info("stopped transcript watcher", { sessionId });
     }
     this.active.clear();
-    this.rediscoveryTimers.clear();
+    this.rediscoverySessions.clear();
+    if (this.rediscoveryTimer) {
+      clearTimeout(this.rediscoveryTimer);
+      this.rediscoveryTimer = void 0;
+    }
+    this.rediscoveryCursor = 0;
+    this.rediscoveryIndex = void 0;
     for (const timer of this.enableRetryTimers.values()) {
       clearTimeout(timer);
     }
     this.enableRetryTimers.clear();
     this.enableRetryAttempts.clear();
+    this.desiredSubscriptions.clear();
   }
   /** Check if a session has an active watcher. */
   isWatching(sessionId) {
@@ -9378,6 +11361,80 @@ var KIND_TO_BINARY_LABEL = {
   codex: "Codex"
 };
 var activeSessions = /* @__PURE__ */ new Map();
+var MAX_NATIVE_RECOVERY_TOMBSTONES = 32;
+var nativeRecoverySnapshots = /* @__PURE__ */ new Map();
+function retainNativeRecoverySnapshot(session) {
+  const snapshot = trimSnapshot(session.snapshot);
+  nativeRecoverySnapshots.delete(session.sessionId);
+  nativeRecoverySnapshots.set(session.sessionId, {
+    snapshot,
+    seq: session.seq
+  });
+  while (nativeRecoverySnapshots.size > MAX_NATIVE_RECOVERY_TOMBSTONES) {
+    const oldest = nativeRecoverySnapshots.keys().next().value;
+    if (oldest === void 0) break;
+    nativeRecoverySnapshots.delete(oldest);
+  }
+}
+function publishNativeOps(session, ops, sendOps) {
+  try {
+    let nextSnapshot = session.snapshot;
+    for (const batch of boundTranscriptOpsForWire(ops)) {
+      nextSnapshot = applyOps(nextSnapshot, batch);
+    }
+    session.snapshot = nextSnapshot;
+  } catch (error) {
+    log14.warn("native transcript state update failed; delta omitted", {
+      sessionId: session.sessionId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return;
+  }
+  session.seq += 1;
+  try {
+    sendOps(session.sessionId, ops, session.seq);
+  } catch (error) {
+    log14.warn("native transcript delta send failed; snapshot retained for recovery", {
+      sessionId: session.sessionId,
+      seq: session.seq,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function getNativeTranscriptSnapshot(sessionId) {
+  const session = activeSessions.get(sessionId);
+  if (session) {
+    return {
+      snapshot: trimSnapshot(session.snapshot),
+      seq: session.seq
+    };
+  }
+  const recovery = nativeRecoverySnapshots.get(sessionId);
+  if (!recovery) return null;
+  return {
+    snapshot: trimSnapshot(recovery.snapshot),
+    seq: recovery.seq
+  };
+}
+function syncNativeTranscriptSnapshot(sessionId, sendSnapshot, forceReset = false) {
+  const current = getNativeTranscriptSnapshot(sessionId);
+  if (!current) return false;
+  const reset = forceReset || current.snapshot.turnOrder.length === 0;
+  sendSnapshot(
+    sessionId,
+    current.snapshot,
+    current.seq,
+    reset ? true : void 0
+  );
+  return true;
+}
+function getNativeTranscriptSnapshotSessionIds() {
+  const ids = [...activeSessions.keys()];
+  for (const sessionId of nativeRecoverySnapshots.keys()) {
+    if (!activeSessions.has(sessionId)) ids.push(sessionId);
+  }
+  return ids;
+}
 var defaultDeps = {
   detect: detectNativeCapabilities,
   startClaude: startClaudeNativeStream,
@@ -9502,8 +11559,10 @@ async function launchClaudeNative(options, sendOps) {
     command: `claude -p (native)`,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     seq: 0,
+    snapshot: createEmptySnapshot(sessionId),
     handle: null
   };
+  nativeRecoverySnapshots.delete(sessionId);
   activeSessions.set(sessionId, session);
   const extraEnv = deps.buildExtraEnv();
   try {
@@ -9519,8 +11578,9 @@ async function launchClaudeNative(options, sendOps) {
       },
       {
         onOps: (ops) => {
-          session.seq += 1;
-          sendOps(sessionId, ops, session.seq);
+          if (activeSessions.get(sessionId) === session) {
+            publishNativeOps(session, ops, sendOps);
+          }
         },
         onWarn: (msg) => {
           log14.warn("claude native warn", { sessionId, msg });
@@ -9539,16 +11599,16 @@ async function launchClaudeNative(options, sendOps) {
           log14.warn("claude native breaker opened; removing inventory entry", {
             sessionId
           });
-          if (activeSessions.has(sessionId)) {
-            session.seq += 1;
-            sendOps(
-              sessionId,
+          if (activeSessions.get(sessionId) === session) {
+            publishNativeOps(
+              session,
               buildFallbackStatusOps(
                 "Claude native stream stopped after repeated failures. Restart the session to retry.",
                 "error"
               ),
-              session.seq
+              sendOps
             );
+            retainNativeRecoverySnapshot(session);
             activeSessions.delete(sessionId);
           }
         }
@@ -9556,6 +11616,7 @@ async function launchClaudeNative(options, sendOps) {
     );
   } catch (err) {
     activeSessions.delete(sessionId);
+    nativeRecoverySnapshots.delete(sessionId);
     const detail = err instanceof Error ? err.message : String(err);
     log14.error("claude native launch threw", { sessionId, detail });
     return {
@@ -9640,8 +11701,10 @@ async function launchGeminiNative(options, sendOps) {
     command: `gemini -p (native)`,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     seq: 0,
+    snapshot: createEmptySnapshot(sessionId),
     handle: null
   };
+  nativeRecoverySnapshots.delete(sessionId);
   activeSessions.set(sessionId, session);
   const extraEnv = deps.buildGeminiExtraEnv();
   try {
@@ -9656,8 +11719,9 @@ async function launchGeminiNative(options, sendOps) {
       },
       {
         onOps: (ops) => {
-          session.seq += 1;
-          sendOps(sessionId, ops, session.seq);
+          if (activeSessions.get(sessionId) === session) {
+            publishNativeOps(session, ops, sendOps);
+          }
         },
         onWarn: (msg) => {
           log14.warn("gemini native warn", { sessionId, msg });
@@ -9672,16 +11736,16 @@ async function launchGeminiNative(options, sendOps) {
           log14.warn("gemini native breaker opened; removing inventory entry", {
             sessionId
           });
-          if (activeSessions.has(sessionId)) {
-            session.seq += 1;
-            sendOps(
-              sessionId,
+          if (activeSessions.get(sessionId) === session) {
+            publishNativeOps(
+              session,
               buildFallbackStatusOps(
                 "Gemini native stream stopped after repeated failures. Restart the session to retry.",
                 "error"
               ),
-              session.seq
+              sendOps
             );
+            retainNativeRecoverySnapshot(session);
             activeSessions.delete(sessionId);
           }
         }
@@ -9689,6 +11753,7 @@ async function launchGeminiNative(options, sendOps) {
     );
   } catch (err) {
     activeSessions.delete(sessionId);
+    nativeRecoverySnapshots.delete(sessionId);
     const detail = err instanceof Error ? err.message : String(err);
     log14.error("gemini native launch threw", { sessionId, detail });
     return {
@@ -9774,8 +11839,10 @@ async function launchCodexNative(options, sendOps) {
     command: transport === "app-server" ? `codex app-server (native)` : `codex exec (native)`,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     seq: 0,
+    snapshot: createEmptySnapshot(sessionId),
     handle: null
   };
+  nativeRecoverySnapshots.delete(sessionId);
   activeSessions.set(sessionId, session);
   const extraEnv = transport === "app-server" ? buildCodexAppServerExtraEnv() : deps.buildCodexExtraEnv();
   const onBreakerOpenHandler = () => {
@@ -9783,16 +11850,16 @@ async function launchCodexNative(options, sendOps) {
       sessionId,
       transport
     });
-    if (activeSessions.has(sessionId)) {
-      session.seq += 1;
-      sendOps(
-        sessionId,
+    if (activeSessions.get(sessionId) === session) {
+      publishNativeOps(
+        session,
         buildFallbackStatusOps(
           "Codex native stream stopped after repeated failures. Restart the session to retry.",
           "error"
         ),
-        session.seq
+        sendOps
       );
+      retainNativeRecoverySnapshot(session);
       activeSessions.delete(sessionId);
     }
   };
@@ -9812,8 +11879,9 @@ async function launchCodexNative(options, sendOps) {
         },
         {
           onOps: (ops) => {
-            session.seq += 1;
-            sendOps(sessionId, ops, session.seq);
+            if (activeSessions.get(sessionId) === session) {
+              publishNativeOps(session, ops, sendOps);
+            }
           },
           onWarn: (msg) => {
             log14.warn("codex app-server warn", { sessionId, msg });
@@ -9840,8 +11908,9 @@ async function launchCodexNative(options, sendOps) {
         },
         {
           onOps: (ops) => {
-            session.seq += 1;
-            sendOps(sessionId, ops, session.seq);
+            if (activeSessions.get(sessionId) === session) {
+              publishNativeOps(session, ops, sendOps);
+            }
           },
           onWarn: (msg) => {
             log14.warn("codex native warn", { sessionId, msg });
@@ -9858,6 +11927,7 @@ async function launchCodexNative(options, sendOps) {
     }
   } catch (err) {
     activeSessions.delete(sessionId);
+    nativeRecoverySnapshots.delete(sessionId);
     const detail = err instanceof Error ? err.message : String(err);
     log14.error("codex native launch threw", { sessionId, detail });
     return {
@@ -9884,6 +11954,7 @@ async function launchCodexNative(options, sendOps) {
         } catch {
         }
         activeSessions.delete(sessionId);
+        nativeRecoverySnapshots.delete(sessionId);
         return {
           ok: false,
           kind,
@@ -9910,7 +11981,8 @@ async function launchCodexNative(options, sendOps) {
 }
 function stopNativeSession(sessionId) {
   const session = activeSessions.get(sessionId);
-  if (!session) return false;
+  const removedRecovery = nativeRecoverySnapshots.delete(sessionId);
+  if (!session) return removedRecovery;
   try {
     session.handle?.stop();
   } catch (err) {
@@ -9926,6 +11998,7 @@ function stopNativeSession(sessionId) {
 function stopAllNativeSessions() {
   const ids = [...activeSessions.keys()];
   for (const id of ids) stopNativeSession(id);
+  nativeRecoverySnapshots.clear();
 }
 function isNativeSession(sessionId) {
   for (const prefix of Object.values(KIND_TO_SESSION_PREFIX)) {
@@ -10746,6 +12819,7 @@ async function claimHost(params) {
   return data;
 }
 async function negotiateAgent(params) {
+  const requestStartedAt = Date.now();
   const response = await fetch(`${params.portal}/api/agent/negotiate`, {
     method: "POST",
     headers: {
@@ -10754,6 +12828,7 @@ async function negotiateAgent(params) {
     },
     body: JSON.stringify({})
   });
+  const responseReceivedAt = Date.now();
   const data = await response.json();
   if (response.status === 401 || response.status === 403) {
     throw new AuthError(
@@ -10766,6 +12841,11 @@ async function negotiateAgent(params) {
   if (!data.url || !data.groups?.privateGroup || !data.groups?.registryGroup) {
     throw new Error("Negotiate response missing websocket URL or group info");
   }
+  delete data.serverClockOffsetMs;
+  if (Number.isSafeInteger(data.serverTimeMs)) {
+    const requestMidpoint = requestStartedAt + Math.round((responseReceivedAt - requestStartedAt) / 2);
+    data.serverClockOffsetMs = data.serverTimeMs - requestMidpoint;
+  }
   return data;
 }
 async function deregisterHost(params) {
@@ -11075,7 +13155,9 @@ var SessionStreamer = class {
    * never fires, and `resyncStream` deliberately does NOT restart pipe-pane —
    * so without this the pane is frozen until the stream is torn down by hand.
    *
-   * Batched into one `tmux list-panes -a` call so liveness costs one fork.
+   * Costs one batched `tmux list-panes -a` fork for pids, plus one `capture-pane`
+   * fork ONLY per currently-silent stream (flowing streams are provably alive and
+   * skip the hash) — so ~one fork/tick on a healthy host.
    */
   checkPipeLiveness() {
     const tmuxStreams = [...this.active.values()].filter(
@@ -11101,22 +13183,29 @@ var SessionStreamer = class {
         continue;
       }
       const bytesNow = stream.bytesReceived ?? 0;
-      const paneMoved = info.fingerprint !== stream.lastLivenessFingerprint;
       const fifoSilent = bytesNow === (stream.lastLivenessBytes ?? 0);
-      if (paneMoved && fifoSilent) {
-        stream.deadPipeStrikes = (stream.deadPipeStrikes ?? 0) + 1;
-        if (stream.deadPipeStrikes >= DEAD_PIPE_STRIKES && !backedOff) {
-          dead.push({
-            sessionId: stream.sessionId,
-            reason: "pipe-pane silent while pane active",
-            detail: { strikes: stream.deadPipeStrikes }
-          });
+      if (!fifoSilent) {
+        stream.deadPipeStrikes = 0;
+      } else {
+        const contentHash = this.paneContentHash(stream.paneTarget, stream.cleanEnv);
+        if (contentHash !== null) {
+          const paneMoved = stream.lastContentHash !== void 0 && contentHash !== stream.lastContentHash;
+          if (paneMoved) {
+            stream.deadPipeStrikes = (stream.deadPipeStrikes ?? 0) + 1;
+            if (stream.deadPipeStrikes >= DEAD_PIPE_STRIKES && !backedOff) {
+              dead.push({
+                sessionId: stream.sessionId,
+                reason: "pipe-pane silent while pane active",
+                detail: { strikes: stream.deadPipeStrikes }
+              });
+            }
+          } else {
+            stream.deadPipeStrikes = 0;
+          }
+          stream.lastContentHash = contentHash;
         }
-      } else {
-        stream.deadPipeStrikes = 0;
       }
       stream.lastLivenessBytes = bytesNow;
-      stream.lastLivenessFingerprint = info.fingerprint;
     }
     if (dead.length === 0) return;
     const [first, ...rest] = dead;
@@ -11460,7 +13549,7 @@ var SessionStreamer = class {
       try {
         this.sendResetFn?.(sessionId, withScrollback ? "full" : "repaint", targetViewerId);
         const alternateScreen = this.detectAlternateScreen(paneTarget, cleanEnv);
-        if (withScrollback) {
+        if (withScrollback && !alternateScreen) {
           send("\x1B[3J");
           try {
             const scrollback = (0, import_node_child_process2.execFileSync)(
@@ -11505,6 +13594,31 @@ var SessionStreamer = class {
       return false;
     }
   }
+  /** Cheap stable string hash (djb2) for content change-detection. */
+  hashString(s) {
+    let h = 5381;
+    for (let i = 0; i < s.length; i++) h = Math.imul(h, 33) + s.charCodeAt(i) | 0;
+    return (h >>> 0).toString(36) + ":" + s.length;
+  }
+  /**
+   * Hash of a pane's visible content (`capture-pane -p`). This is the watchdog's
+   * activity signal: unlike cursor/history it changes on ANY visible redraw,
+   * including in-place TUI updates (spinners, token counters, status bars) that
+   * a Claude/Gemini pane emits without moving the cursor. Null on tmux failure
+   * (the watchdog then skips the activity check for that tick).
+   */
+  paneContentHash(paneTarget, cleanEnv) {
+    try {
+      const out = (0, import_node_child_process2.execFileSync)(
+        "tmux",
+        ["capture-pane", "-t", paneTarget, "-p"],
+        { env: cleanEnv ?? this.tmuxEnv(), timeout: 5e3, encoding: "utf-8" }
+      );
+      return this.hashString(out);
+    } catch {
+      return null;
+    }
+  }
   /** Build a tmux-safe env (TMUX/TMUX_PANE stripped) for liveness queries. */
   tmuxEnv() {
     const env = { ...process.env };
@@ -11562,9 +13676,9 @@ var SessionStreamer = class {
    * 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) {
+  sendVisiblePane(send, paneTarget, cleanEnv, _alternateScreen) {
     try {
-      const captureArgs = alternateScreen ? ["capture-pane", "-a", "-t", paneTarget, "-p", "-e"] : ["capture-pane", "-t", paneTarget, "-p", "-e"];
+      const captureArgs = ["capture-pane", "-t", paneTarget, "-p", "-e"];
       const initial = (0, import_node_child_process2.execFileSync)(
         "tmux",
         captureArgs,
@@ -11658,10 +13772,8 @@ var SessionStreamer = class {
         return false;
       }
       const paneInfo = this.readPaneInfo(paneTarget, cleanEnv);
-      if (paneInfo) {
-        stream.panePid = paneInfo.panePid;
-        stream.lastLivenessFingerprint = paneInfo.fingerprint;
-      }
+      if (paneInfo) stream.panePid = paneInfo.panePid;
+      stream.lastContentHash = this.paneContentHash(paneTarget, cleanEnv) ?? void 0;
       stream.bytesReceived = 0;
       stream.lastLivenessBytes = 0;
       stream.deadPipeStrikes = 0;
@@ -11698,7 +13810,7 @@ var SessionStreamer = class {
       this.sendResetFn?.(sessionId, "full");
       const alternateScreen = this.detectAlternateScreen(paneTarget, cleanEnv);
       stream.alternateScreen = alternateScreen;
-      if (!opts?.skipScrollback) {
+      if (!opts?.skipScrollback && !alternateScreen) {
         this.sendFn(sessionId, "\x1B[3J");
         try {
           const scrollback = (0, import_node_child_process2.execFileSync)(
@@ -11979,7 +14091,104 @@ var SessionStreamer = class {
 };
 
 // src/crypto-channel.ts
-var import_node_crypto = require("crypto");
+var import_node_crypto2 = require("crypto");
+
+// src/crypto-binding.ts
+var CRYPTO_BINDING_V2_VERSION = 2;
+var CRYPTO_BINDING_V2_DOMAIN = "ragent/aead-binding/v2";
+var CRYPTO_BINDING_V2_DIRECTION = "portal-to-agent";
+var CRYPTO_BINDING_V2_MAX_VIEWER_ID_BYTES = 128;
+var CRYPTO_BINDING_V2_MAX_SESSION_ID_BYTES = 4096;
+var UINT16_MAX = 65535;
+var UINT32_MAX = 4294967295;
+var encoder = new TextEncoder();
+function encodedField(value, name) {
+  const bytes = encoder.encode(value);
+  if (bytes.byteLength > UINT16_MAX) {
+    throw new Error(`${name} exceeds the UInt16 length bound`);
+  }
+  return bytes;
+}
+function validateCryptoBindingV2(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("Crypto binding must be an object");
+  }
+  const binding = value;
+  if (binding.bindingVersion !== CRYPTO_BINDING_V2_VERSION) {
+    throw new Error("Unsupported crypto binding version");
+  }
+  if (binding.direction !== CRYPTO_BINDING_V2_DIRECTION) {
+    throw new Error("Invalid crypto binding direction");
+  }
+  if (binding.type !== "input" && binding.type !== "control") {
+    throw new Error("Invalid crypto binding message type");
+  }
+  if (binding.type === "input" && binding.action !== "" || binding.type === "control" && binding.action !== "upload-file") {
+    throw new Error("Invalid crypto binding action for message type");
+  }
+  if (typeof binding.viewerId !== "string" || binding.viewerId.length === 0) {
+    throw new Error("Crypto binding viewerId is required");
+  }
+  if (binding.viewerId.length > CRYPTO_BINDING_V2_MAX_VIEWER_ID_BYTES) {
+    throw new Error(
+      `Crypto binding viewerId exceeds ${CRYPTO_BINDING_V2_MAX_VIEWER_ID_BYTES} bytes`
+    );
+  }
+  if (!/^[A-Za-z0-9:_-]+$/.test(binding.viewerId)) {
+    throw new Error("Crypto binding viewerId contains unsupported characters");
+  }
+  if (typeof binding.sessionId !== "string" || binding.sessionId.length === 0) {
+    throw new Error("Crypto binding sessionId is required");
+  }
+  if (binding.sessionId.length > CRYPTO_BINDING_V2_MAX_SESSION_ID_BYTES) {
+    throw new Error(
+      `Crypto binding sessionId exceeds ${CRYPTO_BINDING_V2_MAX_SESSION_ID_BYTES} bytes`
+    );
+  }
+  if (encodedField(binding.viewerId, "viewerId").byteLength > CRYPTO_BINDING_V2_MAX_VIEWER_ID_BYTES) {
+    throw new Error(
+      `Crypto binding viewerId exceeds ${CRYPTO_BINDING_V2_MAX_VIEWER_ID_BYTES} bytes`
+    );
+  }
+  if (encodedField(binding.sessionId, "sessionId").byteLength > CRYPTO_BINDING_V2_MAX_SESSION_ID_BYTES) {
+    throw new Error(
+      `Crypto binding sessionId exceeds ${CRYPTO_BINDING_V2_MAX_SESSION_ID_BYTES} bytes`
+    );
+  }
+  if (!Number.isSafeInteger(binding.sentAtMs) || binding.sentAtMs < 0) {
+    throw new Error("Crypto binding sentAtMs must be a non-negative safe integer");
+  }
+  if (!Number.isInteger(binding.seq) || binding.seq < 1 || binding.seq > UINT32_MAX) {
+    throw new Error("Crypto binding seq must be a non-zero UInt32");
+  }
+}
+function buildCryptoBindingV2(binding) {
+  validateCryptoBindingV2(binding);
+  const fields = [
+    encodedField(CRYPTO_BINDING_V2_DOMAIN, "domain"),
+    encodedField(binding.direction, "direction"),
+    encodedField(binding.type, "type"),
+    encodedField(binding.action, "action"),
+    encodedField(binding.viewerId, "viewerId"),
+    encodedField(binding.sessionId, "sessionId")
+  ];
+  const byteLength = fields.reduce((total, field) => total + 2 + field.byteLength, 0) + 8 + 4;
+  const result = new Uint8Array(byteLength);
+  const view = new DataView(result.buffer);
+  let offset = 0;
+  for (const field of fields) {
+    view.setUint16(offset, field.byteLength, false);
+    offset += 2;
+    result.set(field, offset);
+    offset += field.byteLength;
+  }
+  view.setBigUint64(offset, BigInt(binding.sentAtMs), false);
+  offset += 8;
+  view.setUint32(offset, binding.seq, false);
+  return result;
+}
+
+// src/crypto-channel.ts
 var log18 = createLogger("crypto-channel");
 var AAD_BYTES = 4;
 function deriveAesKey(sessionKey) {
@@ -11993,11 +14202,20 @@ function seqToAad(seq) {
   buf.writeUInt32BE(seq, 0);
   return buf;
 }
-function encryptPayload(data, sessionKey, seq) {
+function payloadAad(seq, binding) {
+  if (!binding) return seqToAad(seq);
+  if (binding.seq !== seq) {
+    throw new Error(
+      `Crypto binding seq ${binding.seq} does not match payload seq ${seq}`
+    );
+  }
+  return buildCryptoBindingV2(binding);
+}
+function encryptPayload(data, sessionKey, seq, binding) {
   const key = deriveAesKey(sessionKey);
-  const iv = (0, import_node_crypto.randomBytes)(12);
-  const cipher = (0, import_node_crypto.createCipheriv)("aes-256-gcm", key, iv);
-  cipher.setAAD(seqToAad(seq));
+  const iv = (0, import_node_crypto2.randomBytes)(12);
+  const cipher = (0, import_node_crypto2.createCipheriv)("aes-256-gcm", key, iv);
+  cipher.setAAD(payloadAad(seq, binding));
   const encrypted = Buffer.concat([cipher.update(data, "utf-8"), cipher.final()]);
   const authTag = cipher.getAuthTag();
   const combined = Buffer.concat([encrypted, authTag]);
@@ -12007,7 +14225,7 @@ function encryptPayload(data, sessionKey, seq) {
     seq
   };
 }
-function decryptPayload(enc, iv, sessionKey, seq) {
+function decryptPayload(enc, iv, sessionKey, seq, binding) {
   try {
     const key = deriveAesKey(sessionKey);
     const ivBuf = Buffer.from(iv, "base64");
@@ -12015,8 +14233,8 @@ function decryptPayload(enc, iv, sessionKey, seq) {
     if (combined.length < 16) return null;
     const ciphertext = combined.subarray(0, combined.length - 16);
     const authTag = combined.subarray(combined.length - 16);
-    const decipher = (0, import_node_crypto.createDecipheriv)("aes-256-gcm", key, ivBuf);
-    decipher.setAAD(seqToAad(seq));
+    const decipher = (0, import_node_crypto2.createDecipheriv)("aes-256-gcm", key, ivBuf);
+    decipher.setAAD(payloadAad(seq, binding));
     decipher.setAuthTag(authTag);
     const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
     return decrypted.toString("utf-8");
@@ -12036,10 +14254,15 @@ var SequenceTracker = class {
     this.last += 1;
     return this.last;
   }
-  /** Receiver: accept if strictly greater than last-seen; else reject. */
-  accept(seq) {
+  /** Receiver: validate without mutating replay state. */
+  canAccept(seq) {
     if (!Number.isInteger(seq) || seq < 1 || seq > 4294967295) return false;
     if (seq <= this.last) return false;
+    return true;
+  }
+  /** Receiver: commit an already-authenticated sequence number. */
+  accept(seq) {
+    if (!this.canAccept(seq)) return false;
     this.last = seq;
     return true;
   }
@@ -12367,22 +14590,89 @@ var ShellManager = class {
 var os7 = __toESM(require("os"));
 var import_child_process5 = require("child_process");
 var import_ws2 = __toESM(require("ws"));
+var INVENTORY_CACHE_TTL_MS = 1e3;
 var InventoryManager = class {
   lastSentFingerprint = "";
   lastHttpHeartbeatAt = 0;
   prevCpuSnapshot = null;
+  cachedSessions = null;
+  cachedSessionsAt = 0;
+  cachedScope = "";
+  inventoryRefresh = null;
+  confirmedMisses = /* @__PURE__ */ new Map();
   options;
   constructor(options) {
     this.options = options;
   }
   /** Update options (e.g., after token refresh). */
   updateOptions(options) {
+    const nextScope = `${options.hostId}\0${options.command}`;
+    if (nextScope !== this.inventoryScope()) {
+      this.cachedSessions = null;
+      this.cachedSessionsAt = 0;
+      this.cachedScope = "";
+      this.confirmedMisses.clear();
+    }
     this.options = options;
   }
+  inventoryScope() {
+    return `${this.options.hostId}\0${this.options.command}`;
+  }
+  cacheIsFresh(now2 = Date.now()) {
+    return this.cachedSessions !== null && this.cachedScope === this.inventoryScope() && now2 - this.cachedSessionsAt < INVENTORY_CACHE_TTL_MS;
+  }
+  rememberInventory(sessions, scope = this.inventoryScope()) {
+    this.cachedSessions = sessions;
+    this.cachedSessionsAt = Date.now();
+    this.cachedScope = scope;
+    this.confirmedMisses.clear();
+    return sessions;
+  }
+  /** Collect inventory at most once concurrently. Callers awaiting the same
+   * refresh share both the process scan and its result. */
+  refreshInventory() {
+    const scope = this.inventoryScope();
+    if (this.inventoryRefresh?.scope === scope) return this.inventoryRefresh.promise;
+    const hostId = this.options.hostId;
+    const command = this.options.command;
+    const refresh = collectSessionInventory(hostId, command).then((sessions) => this.inventoryScope() === scope ? this.rememberInventory(sessions, scope) : sessions).finally(() => {
+      if (this.inventoryRefresh?.promise === refresh) this.inventoryRefresh = null;
+    });
+    this.inventoryRefresh = { scope, promise: refresh };
+    return refresh;
+  }
+  /** Return the recent inventory, refreshing it when stale or explicitly
+   * requested. Primarily public so control paths can share the scan cache. */
+  async getSessionInventory(forceRefresh = false) {
+    if (!forceRefresh && this.cacheIsFresh()) return this.cachedSessions;
+    return this.refreshInventory();
+  }
+  /** Find a session using the recent inventory. A fresh cache miss gets one
+   * refresh so a just-created pane is not hidden until TTL expiry. Confirmed
+   * misses are negatively cached for the same short TTL. */
+  async getSessionById(sessionId) {
+    const now2 = Date.now();
+    if (this.cacheIsFresh(now2)) {
+      const cached = this.cachedSessions.find((session) => session.id === sessionId);
+      if (cached) return cached;
+      const missAt = this.confirmedMisses.get(sessionId);
+      if (missAt !== void 0 && now2 - missAt < INVENTORY_CACHE_TTL_MS) {
+        return void 0;
+      }
+      const refreshed2 = await this.refreshInventory();
+      const found2 = refreshed2.find((session) => session.id === sessionId);
+      if (!found2) this.confirmedMisses.set(sessionId, Date.now());
+      return found2;
+    }
+    const refreshed = await this.refreshInventory();
+    const found = refreshed.find((session) => session.id === sessionId);
+    if (!found) this.confirmedMisses.set(sessionId, Date.now());
+    return found;
+  }
   /** Announce to the registry group via WebSocket. */
   async announceToRegistry(ws, registryGroup, type = "heartbeat", sessions) {
     if (ws.readyState !== import_ws2.default.OPEN || !registryGroup) return;
-    const finalSessions = sessions || await collectSessionInventory(this.options.hostId, this.options.command);
+    const finalSessions = sessions ? this.rememberInventory(sessions) : await this.getSessionInventory();
     const vitals = this.collectVitals();
     sendToGroup(ws, registryGroup, {
       type,
@@ -12400,7 +14690,7 @@ var InventoryManager = class {
    * and HTTP heartbeat as needed.
    */
   async syncInventory(ws, groups, force = false) {
-    const sessions = await collectSessionInventory(this.options.hostId, this.options.command);
+    const sessions = await this.getSessionInventory(force);
     const fingerprint = sessionInventoryFingerprint(sessions);
     const changed = fingerprint !== this.lastSentFingerprint;
     const checkpointDue = Date.now() - this.lastHttpHeartbeatAt > HTTP_HEARTBEAT_MS;
@@ -12461,14 +14751,19 @@ var InventoryManager = class {
 
 // src/connection-manager.ts
 var import_ws3 = __toESM(require("ws"));
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var log21 = createLogger("connection");
 var OPPORTUNISTIC_INVENTORY_SYNC_MS = 1200;
 var MIN_INVENTORY_SYNC_GAP_MS = 1500;
+var MAX_RX_VIEWERS = 256;
+var MAX_VIEWER_ID_BYTES = 128;
+var MAX_BINDING_AGE_MS = 10 * 60 * 1e3;
+var MAX_BINDING_FUTURE_MS = 2 * 60 * 1e3;
 var ConnectionManager = class {
   activeSocket = null;
   activeGroups = { privateGroup: "", registryGroup: "" };
   sessionKey = null;
+  serverClockOffsetMs = 0;
   reconnectDelay = DEFAULT_RECONNECT_DELAY_MS;
   /** Outbound frame counter; reset on every new handshake. See #310. */
   txSeq = new SequenceTracker();
@@ -12481,7 +14776,7 @@ var ConnectionManager = class {
    * 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)();
+  streamEpoch = (0, import_node_crypto3.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
@@ -12497,10 +14792,19 @@ var ConnectionManager = class {
    * the field.
    */
   getRxSeqForViewer(viewerId) {
-    const isValid = typeof viewerId === "string" && viewerId.length > 0;
-    const key = isValid ? viewerId : "_legacy";
+    const normalized = this.normalizeViewerId(viewerId);
+    if (normalized === null) return null;
+    const isValid = normalized !== "_legacy";
+    const key = normalized;
     let tracker = this.rxSeqByViewer.get(key);
-    if (!tracker) {
+    if (tracker) {
+      this.rxSeqByViewer.delete(key);
+      this.rxSeqByViewer.set(key, tracker);
+    } else {
+      if (this.rxSeqByViewer.size >= MAX_RX_VIEWERS) {
+        const oldest = this.rxSeqByViewer.keys().next().value;
+        if (oldest !== void 0) this.rxSeqByViewer.delete(oldest);
+      }
       tracker = new SequenceTracker();
       this.rxSeqByViewer.set(key, tracker);
       if (!isValid) {
@@ -12509,6 +14813,67 @@ var ConnectionManager = class {
     }
     return tracker;
   }
+  /** Authenticate ciphertext before allocating or advancing replay state. */
+  authenticateInboundFrame(enc, iv, seq, viewerId, bindingContext) {
+    if (!this.sessionKey) return { ok: false, reason: "missing_key" };
+    if (!Number.isInteger(seq) || seq < 1 || seq > 4294967295) {
+      return { ok: false, reason: "invalid_seq" };
+    }
+    let binding;
+    let authenticatedViewerKey;
+    const frameBindingVersion = bindingContext?.bindingVersion;
+    if (frameBindingVersion === CRYPTO_BINDING_V2_VERSION) {
+      if (!bindingContext) return { ok: false, reason: "invalid_binding" };
+      if (typeof viewerId !== "string" || typeof bindingContext.sessionId !== "string") {
+        return { ok: false, reason: "invalid_binding" };
+      }
+      binding = {
+        bindingVersion: CRYPTO_BINDING_V2_VERSION,
+        direction: CRYPTO_BINDING_V2_DIRECTION,
+        type: bindingContext.type,
+        action: bindingContext.action,
+        viewerId,
+        sessionId: bindingContext.sessionId,
+        sentAtMs: bindingContext.sentAtMs,
+        seq
+      };
+      try {
+        validateCryptoBindingV2(binding);
+      } catch {
+        return { ok: false, reason: "invalid_binding" };
+      }
+      authenticatedViewerKey = binding.viewerId;
+      const trustedNow = Date.now() + this.serverClockOffsetMs;
+      if (binding.sentAtMs < trustedNow - MAX_BINDING_AGE_MS || binding.sentAtMs > trustedNow + MAX_BINDING_FUTURE_MS) {
+        return { ok: false, reason: "stale_binding" };
+      }
+    } else if (frameBindingVersion !== void 0 && frameBindingVersion !== 1) {
+      return { ok: false, reason: "invalid_binding" };
+    }
+    const plaintext = decryptPayload(enc, iv, this.sessionKey, seq, binding);
+    if (plaintext === null) return { ok: false, reason: "decrypt_failed" };
+    const tracker = this.getRxSeqForViewer(authenticatedViewerKey ?? viewerId);
+    if (!tracker) return { ok: false, reason: "invalid_viewer" };
+    const viewerKey = authenticatedViewerKey ?? this.normalizeViewerId(viewerId);
+    if (!tracker.accept(seq)) {
+      return {
+        ok: false,
+        reason: "replayed",
+        viewerKey,
+        lastSeen: tracker.lastSeq
+      };
+    }
+    return { ok: true, plaintext, viewerKey };
+  }
+  normalizeViewerId(viewerId) {
+    if (viewerId === void 0 || viewerId === null) return "_legacy";
+    if (typeof viewerId !== "string") return "_legacy";
+    if (viewerId.length > MAX_VIEWER_ID_BYTES) return null;
+    const normalized = viewerId.trim();
+    if (normalized.length === 0) return "_legacy";
+    if (Buffer.byteLength(normalized, "utf8") > MAX_VIEWER_ID_BYTES) return null;
+    return normalized;
+  }
   wsHeartbeatTimer = null;
   inventorySyncTimer = null;
   inventorySyncKickTimer = null;
@@ -12530,7 +14895,7 @@ var ConnectionManager = class {
     return this.activeSocket !== null && this.activeSocket.readyState === import_ws3.default.OPEN;
   }
   /** Set the active socket and groups from a negotiate result. */
-  setConnection(ws, groups, sessionKey) {
+  setConnection(ws, groups, sessionKey, crypto4) {
     this.activeSocket = ws;
     this.activeGroups = groups;
     if (sessionKey !== this.sessionKey) {
@@ -12538,6 +14903,7 @@ var ConnectionManager = class {
       this.rxSeqByViewer.clear();
     }
     this.sessionKey = sessionKey;
+    this.serverClockOffsetMs = Number.isFinite(crypto4?.serverClockOffsetMs) ? crypto4.serverClockOffsetMs : 0;
   }
   /** Reset reconnect delay on successful connection. */
   resetReconnectDelay() {
@@ -13360,6 +15726,7 @@ async function installLatestCliFromNpm() {
 var log23 = createLogger("control");
 var TMUX_RESYNC_DEBOUNCE_MS = 150;
 var TMUX_INPUT_COALESCE_MS = 4;
+var MAX_MARKDOWN_GENERATION_ENTRIES = 2048;
 function collectProcessTreePids(rootPid, visited = /* @__PURE__ */ new Set()) {
   if (visited.has(rootPid)) return [];
   visited.add(rootPid);
@@ -13403,15 +15770,22 @@ var ControlDispatcher = class {
   _approvalEnforcer = null;
   tmuxResizeState = /* @__PURE__ */ new Map();
   tmuxInputBuffers = /* @__PURE__ */ new Map();
+  markdownGlobalGeneration = 0;
+  /** Globally unique within this dispatcher, preventing ABA when a bounded
+   * generation-map entry is evicted and the same viewer later reconnects. */
+  markdownGenerationSequence = 0;
+  markdownSessionGenerations = /* @__PURE__ */ new Map();
+  markdownViewerGenerations = /* @__PURE__ */ new Map();
   /** Send V2 delta ops produced by an rAgent-launched native-stream
    *  consumer. Same shape as TranscriptWatcherManager's `sendOpsFn` so both
    *  sources funnel through the same WebSocket helper in `agent.ts`. */
   sendNativeOps = null;
+  sendNativeSnapshot = null;
   /** Set to true when a reconnect was requested (restart-agent, disconnect). */
   reconnectRequested = false;
   /** Set to false to stop the agent. */
   shouldRun = true;
-  constructor(shell, streamer, inventory, connection, options, transcriptWatcher, sendNativeOps) {
+  constructor(shell, streamer, inventory, connection, options, transcriptWatcher, sendNativeOps, sendNativeSnapshot) {
     this.shell = shell;
     this.streamer = streamer;
     this.inventory = inventory;
@@ -13419,6 +15793,7 @@ var ControlDispatcher = class {
     this.options = options;
     this.transcriptWatcher = transcriptWatcher ?? null;
     this.sendNativeOps = sendNativeOps ?? null;
+    this.sendNativeSnapshot = sendNativeSnapshot ?? null;
   }
   /** Install or replace the native-stream ops callback. Used by the agent
    *  runner so native ops route through the same encryption/transport path
@@ -13541,6 +15916,7 @@ var ControlDispatcher = class {
         return;
       case "restart-agent":
       case "disconnect":
+        this.invalidateAllMarkdownIntents();
         this.reconnectRequested = true;
         this.streamer.stopAll();
         if (this.connection.activeSocket?.readyState === import_ws4.default.OPEN) {
@@ -13551,6 +15927,7 @@ var ControlDispatcher = class {
         await this.updateAgentFromNpm();
         return;
       case "stop-agent":
+        this.invalidateAllMarkdownIntents();
         this.shouldRun = false;
         this.streamer.stopAll();
         requestStopSelfService();
@@ -13560,6 +15937,7 @@ var ControlDispatcher = class {
         return;
       case "stop-session":
         if (!sessionId) return;
+        this.invalidateMarkdownIntent(sessionId);
         if (sessionId.startsWith("pty:")) {
           this.shell.restart();
           await this.syncInventory();
@@ -13587,6 +15965,7 @@ var ControlDispatcher = class {
         return;
       case "kill-process":
         if (!sessionId) return;
+        this.invalidateMarkdownIntent(sessionId);
         {
           const pid = parseProcessPid2(sessionId);
           if (pid === null) {
@@ -13633,9 +16012,10 @@ var ControlDispatcher = class {
         return;
       case "stop-detached": {
         if (this.transcriptWatcher) {
-          const sessions = await collectSessionInventory(this.options.hostId, this.options.command);
+          const sessions = await this.inventory.getSessionInventory(true);
           for (const session of sessions) {
             if (session.type === "tmux" && session.status === "detached") {
+              this.invalidateMarkdownIntent(session.id);
               this.transcriptWatcher.disableMarkdown(session.id);
             }
           }
@@ -13657,17 +16037,35 @@ var ControlDispatcher = class {
         return;
       case "stop-stream":
         if (sessionId) {
+          this.invalidateMarkdownIntent(sessionId, viewerId ?? void 0);
           this.streamer.stopStream(sessionId, viewerId ?? void 0);
-          this.transcriptWatcher?.disableMarkdown(sessionId);
+          if (viewerId) this.transcriptWatcher?.disableMarkdown(sessionId, viewerId);
+          else this.transcriptWatcher?.disableMarkdown(sessionId);
         }
         return;
       case "prefer-markdown":
-        this.handlePreferMarkdown(sessionId, payload);
+        await this.handlePreferMarkdown(sessionId, payload);
         return;
       case "sync-markdown":
+        if (sessionId && isNativeSession(sessionId)) {
+          if (this.sendNativeSnapshot) {
+            syncNativeTranscriptSnapshot(sessionId, this.sendNativeSnapshot);
+          }
+          return;
+        }
         if (sessionId && this.transcriptWatcher) {
           const fromSeq = typeof payload.fromSeq === "number" ? payload.fromSeq : void 0;
-          this.transcriptWatcher.handleSyncRequest(sessionId, fromSeq);
+          const schemaVersion = payload.schemaVersion === 1 || payload.schemaVersion === 2 ? payload.schemaVersion : void 0;
+          if (schemaVersion !== void 0 || viewerId) {
+            this.transcriptWatcher.handleSyncRequest(
+              sessionId,
+              fromSeq,
+              schemaVersion,
+              viewerId ?? void 0
+            );
+          } else {
+            this.transcriptWatcher.handleSyncRequest(sessionId, fromSeq);
+          }
         }
         return;
       case "upload-file":
@@ -13822,11 +16220,25 @@ var ControlDispatcher = class {
       });
     }
   }
-  handlePreferMarkdown(sessionId, payload) {
+  async handlePreferMarkdown(sessionId, payload) {
     if (!sessionId || !this.transcriptWatcher) return;
     const enabled = payload.enabled === true;
+    const viewerId = typeof payload.viewerId === "string" && payload.viewerId.trim() ? payload.viewerId.trim() : void 0;
+    const schemaVersion = payload.schemaVersion === 1 || payload.schemaVersion === 2 ? payload.schemaVersion : void 0;
+    if (!enabled) {
+      this.invalidateMarkdownIntent(sessionId, viewerId);
+      if (!isNativeSession(sessionId)) {
+        if (viewerId) this.transcriptWatcher.disableMarkdown(sessionId, viewerId);
+        else this.transcriptWatcher.disableMarkdown(sessionId);
+      }
+      return;
+    }
+    const intent = this.beginMarkdownIntent(sessionId, viewerId);
     if (isNativeSession(sessionId)) {
       if (enabled) {
+        if (this.sendNativeSnapshot) {
+          syncNativeTranscriptSnapshot(sessionId, this.sendNativeSnapshot);
+        }
         this.sendMarkdownStatus({
           type: "markdown",
           subtype: "status",
@@ -13837,8 +16249,33 @@ var ControlDispatcher = class {
       return;
     }
     if (enabled) {
-      const agentType = typeof payload.agentType === "string" ? payload.agentType : void 0;
-      const result = this.transcriptWatcher.enableMarkdown(sessionId, agentType);
+      const requestedAgentType = typeof payload.agentType === "string" ? payload.agentType : void 0;
+      let agentType = requestedAgentType;
+      try {
+        const liveAgentType = (await this.inventory.getSessionById(sessionId))?.agentType;
+        if (liveAgentType) {
+          agentType = liveAgentType;
+          if (requestedAgentType && requestedAgentType !== liveAgentType) {
+            log23.info("corrected stale transcript agent type from live inventory", {
+              sessionId,
+              requestedAgentType,
+              liveAgentType
+            });
+          }
+        }
+      } catch (error) {
+        log23.warn("could not resolve live transcript agent type", {
+          sessionId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      if (!this.isCurrentMarkdownIntent(intent)) return;
+      const result = schemaVersion !== void 0 || viewerId ? this.transcriptWatcher.enableMarkdown(
+        sessionId,
+        agentType,
+        viewerId,
+        schemaVersion
+      ) : this.transcriptWatcher.enableMarkdown(sessionId, agentType);
       if (!result.ok) {
         this.sendMarkdownStatus({
           type: "markdown",
@@ -13856,10 +16293,77 @@ var ControlDispatcher = class {
           status: "enabled"
         });
       }
-    } else {
-      this.transcriptWatcher.disableMarkdown(sessionId);
     }
   }
+  markdownViewerKey(sessionId, viewerId) {
+    return `${sessionId}\0${viewerId || "__legacy_anonymous__"}`;
+  }
+  beginMarkdownIntent(sessionId, viewerId) {
+    const viewerKey = this.markdownViewerKey(sessionId, viewerId);
+    let sessionGeneration = this.markdownSessionGenerations.get(sessionId);
+    if (sessionGeneration === void 0) {
+      sessionGeneration = this.nextMarkdownGeneration();
+    }
+    this.setBoundedMarkdownGeneration(
+      this.markdownSessionGenerations,
+      sessionId,
+      sessionGeneration
+    );
+    const viewerGeneration = this.nextMarkdownGeneration();
+    this.setBoundedMarkdownGeneration(
+      this.markdownViewerGenerations,
+      viewerKey,
+      viewerGeneration
+    );
+    return {
+      globalGeneration: this.markdownGlobalGeneration,
+      sessionGeneration,
+      viewerGeneration,
+      sessionId,
+      viewerKey
+    };
+  }
+  invalidateMarkdownIntent(sessionId, viewerId) {
+    if (viewerId) {
+      const viewerKey = this.markdownViewerKey(sessionId, viewerId);
+      this.setBoundedMarkdownGeneration(
+        this.markdownViewerGenerations,
+        viewerKey,
+        this.nextMarkdownGeneration()
+      );
+      return;
+    }
+    this.setBoundedMarkdownGeneration(
+      this.markdownSessionGenerations,
+      sessionId,
+      this.nextMarkdownGeneration()
+    );
+    const viewerPrefix = `${sessionId}\0`;
+    for (const key of this.markdownViewerGenerations.keys()) {
+      if (key.startsWith(viewerPrefix)) this.markdownViewerGenerations.delete(key);
+    }
+  }
+  nextMarkdownGeneration() {
+    this.markdownGenerationSequence++;
+    return this.markdownGenerationSequence;
+  }
+  setBoundedMarkdownGeneration(generations, key, generation) {
+    generations.delete(key);
+    generations.set(key, generation);
+    while (generations.size > MAX_MARKDOWN_GENERATION_ENTRIES) {
+      const oldest = generations.keys().next();
+      if (oldest.done) break;
+      generations.delete(oldest.value);
+    }
+  }
+  invalidateAllMarkdownIntents() {
+    this.markdownGlobalGeneration++;
+    this.markdownSessionGenerations.clear();
+    this.markdownViewerGenerations.clear();
+  }
+  isCurrentMarkdownIntent(intent) {
+    return intent.globalGeneration === this.markdownGlobalGeneration && intent.sessionGeneration === (this.markdownSessionGenerations.get(intent.sessionId) ?? 0) && intent.viewerGeneration === (this.markdownViewerGenerations.get(intent.viewerKey) ?? 0);
+  }
   sendMarkdownStatus(payload) {
     const ws = this.connection.activeSocket;
     const group = this.connection.activeGroups.privateGroup;
@@ -13868,6 +16372,7 @@ var ControlDispatcher = class {
   }
   /** Stop all transcript watchers (called on disconnect/cleanup). */
   stopTranscriptWatchers() {
+    this.invalidateAllMarkdownIntents();
     this.transcriptWatcher?.stopAll();
   }
   async syncInventory(force = false) {
@@ -14167,7 +16672,7 @@ function validateProvisionRequest(payload) {
 }
 
 // src/approval-policy.ts
-var import_node_crypto3 = require("crypto");
+var import_node_crypto4 = require("crypto");
 function hasToken(cmd, token) {
   const lower = cmd.toLowerCase();
   const t = token.toLowerCase();
@@ -14274,7 +16779,7 @@ function matchPolicy(command, _policy = DEFAULT_APPROVAL_POLICY, hostId = "", se
   for (const matcher of MATCHERS) {
     if (matcher.test(command)) {
       return {
-        requestId: (0, import_node_crypto3.randomUUID)(),
+        requestId: (0, import_node_crypto4.randomUUID)(),
         hostId,
         sessionId,
         action: matcher.action,
@@ -14577,6 +17082,65 @@ var ApprovalEnforcer = class {
   }
 };
 
+// src/native-transcript-recovery.ts
+var NATIVE_TRANSCRIPT_RECOVERY_DRAIN_MS = 300;
+var NativeTranscriptRecoveryDrain = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  pending = /* @__PURE__ */ new Set();
+  timer = null;
+  stopped = false;
+  /** Merge the current authoritative session IDs into the pending work set. */
+  request() {
+    if (this.stopped) return;
+    for (const sessionId of this.options.listSessionIds()) {
+      if (sessionId.length > 0) this.pending.add(sessionId);
+    }
+    this.schedule();
+  }
+  /** Permanently stop the drain and release all queued recovery work. */
+  cancel() {
+    this.stopped = true;
+    this.pending.clear();
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  schedule() {
+    if (this.stopped || this.timer || this.pending.size === 0) return;
+    this.timer = setTimeout(
+      () => {
+        this.timer = null;
+        this.drainOne();
+      },
+      this.options.intervalMs ?? NATIVE_TRANSCRIPT_RECOVERY_DRAIN_MS
+    );
+    if (typeof this.timer.unref === "function") this.timer.unref();
+  }
+  drainOne() {
+    if (this.stopped || this.pending.size === 0) return;
+    if (this.options.canSend?.() === false || this.options.isQueueHigh()) {
+      this.schedule();
+      return;
+    }
+    const next = this.pending.values().next();
+    if (next.done) return;
+    const sessionId = next.value;
+    try {
+      this.options.syncSession(sessionId);
+      this.pending.delete(sessionId);
+    } catch (error) {
+      this.pending.delete(sessionId);
+      this.pending.add(sessionId);
+      this.options.onError?.(sessionId, error);
+    }
+    this.schedule();
+  }
+};
+
 // src/agent.ts
 var log25 = createLogger("agent");
 var MAX_TRANSPORT_CHUNK_BYTES = 24 * 1024;
@@ -14654,6 +17218,26 @@ function splitTransportChunks(data, maxBytes = MAX_TRANSPORT_CHUNK_BYTES) {
   }
   return chunks;
 }
+function parseAuthenticatedUploadControlPayload(plaintext, outer) {
+  let parsed;
+  try {
+    parsed = JSON.parse(plaintext);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const inner = parsed;
+  if (outer.action !== "upload-file" || inner.action !== outer.action || inner.sessionId !== outer.sessionId || inner.viewerId !== outer.viewerId) {
+    return null;
+  }
+  return {
+    ...inner,
+    action: outer.action,
+    sessionId: outer.sessionId,
+    viewerId: outer.viewerId,
+    _verifiedEncrypted: true
+  };
+}
 async function runAgent(rawOptions) {
   const options = resolveRunOptions(rawOptions);
   if (!options.agentToken) {
@@ -14677,6 +17261,7 @@ async function runAgent(rawOptions) {
   }
   const outputBuffer = new OutputBuffer();
   const ptySessionId = `pty:${options.hostId}`;
+  let nativeTranscriptRecovery = null;
   const sessionStreamer = new SessionStreamer(
     (sessionId, data, viewerId) => {
       if (!conn.isReady()) {
@@ -14727,6 +17312,7 @@ async function runAgent(rawOptions) {
     },
     () => {
       transcriptWatcher.resyncMarkdownAfterDrop();
+      nativeTranscriptRecovery?.request();
     },
     // #556 follow-up: lets the streamer gate resync delivery + the pipe-liveness
     // watchdog on a confirmed-OPEN socket, so resync bytes aren't buffered then
@@ -14749,41 +17335,98 @@ async function runAgent(rawOptions) {
       }
     }
   };
+  const sendTranscriptSnapshot = (sessionId, snapshot, seq, reset) => {
+    if (!conn.isReady()) return;
+    const safeSnapshot = trimSnapshot(snapshot);
+    const payload = {
+      type: "markdown",
+      subtype: "snapshot",
+      schemaVersion: 2,
+      sessionId,
+      seq,
+      snapshot: safeSnapshot,
+      ...reset ? { reset: true } : {}
+    };
+    if (conn.sessionKey) {
+      const contentStr = JSON.stringify(payload);
+      const { enc, iv, seq: frameSeq } = encryptPayload(
+        contentStr,
+        conn.sessionKey,
+        conn.txSeq.next()
+      );
+      sendToGroup(
+        conn.activeSocket,
+        conn.activeGroups.privateGroup,
+        { type: "markdown", enc, iv, seq: frameSeq, sessionId },
+        { markdownSubtype: "snapshot", markdownSchemaVersion: 2, sessionId, reset }
+      );
+    } else {
+      sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, payload);
+    }
+  };
+  nativeTranscriptRecovery = new NativeTranscriptRecoveryDrain({
+    listSessionIds: getNativeTranscriptSnapshotSessionIds,
+    syncSession: (sessionId) => syncNativeTranscriptSnapshot(
+      sessionId,
+      sendTranscriptSnapshot,
+      true
+    ),
+    isQueueHigh: () => getQueuePressure().isHigh,
+    canSend: () => conn.isReady(),
+    onError: (sessionId, error) => {
+      log25.warn("native transcript recovery send failed; retrying", {
+        sessionId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
   const transcriptWatcher = new TranscriptWatcherManager(
     (sessionId, turn, seq) => {
       if (!conn.isReady()) return;
+      const safeTurn = boundMarkdownTurnForWire(turn);
       const payload = {
         type: "markdown",
         subtype: "delta",
         sessionId,
         seq,
-        turnId: turn.turnId,
-        role: turn.role,
-        content: turn.content,
-        tools: turn.tools,
-        timestamp: turn.timestamp
+        turnId: safeTurn.turnId,
+        role: safeTurn.role,
+        content: safeTurn.content,
+        tools: safeTurn.tools,
+        timestamp: safeTurn.timestamp
       };
       if (conn.sessionKey) {
         const contentStr = JSON.stringify(payload);
         const { enc, iv, seq: frameSeq } = encryptPayload(contentStr, conn.sessionKey, conn.txSeq.next());
-        sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, { type: "markdown", enc, iv, seq: frameSeq, sessionId });
+        sendToGroup(
+          conn.activeSocket,
+          conn.activeGroups.privateGroup,
+          { type: "markdown", enc, iv, seq: frameSeq, sessionId },
+          { markdownSubtype: "delta", markdownSchemaVersion: 1, sessionId }
+        );
       } else {
         sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, payload);
       }
     },
     (sessionId, turns, seq) => {
       if (!conn.isReady()) return;
+      const safeTurns = boundMarkdownTurnsForWire(turns);
       const payload = {
         type: "markdown",
         subtype: "snapshot",
         sessionId,
         seq,
-        turns
+        turns: safeTurns
       };
       if (conn.sessionKey) {
         const contentStr = JSON.stringify(payload);
         const { enc, iv, seq: frameSeq } = encryptPayload(contentStr, conn.sessionKey, conn.txSeq.next());
-        sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, { type: "markdown", enc, iv, seq: frameSeq, sessionId });
+        sendToGroup(
+          conn.activeSocket,
+          conn.activeGroups.privateGroup,
+          { type: "markdown", enc, iv, seq: frameSeq, sessionId },
+          { markdownSubtype: "snapshot", markdownSchemaVersion: 1, sessionId }
+        );
       } else {
         sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, payload);
       }
@@ -14791,45 +17434,30 @@ async function runAgent(rawOptions) {
     // V2: send block-level delta ops
     (sessionId, ops, seq) => {
       if (!conn.isReady()) return;
-      const payload = {
-        type: "markdown",
-        subtype: "delta",
-        schemaVersion: 2,
-        sessionId,
-        seq,
-        ops
-      };
-      if (conn.sessionKey) {
-        const contentStr = JSON.stringify(payload);
-        const { enc, iv, seq: frameSeq } = encryptPayload(contentStr, conn.sessionKey, conn.txSeq.next());
-        sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, { type: "markdown", enc, iv, seq: frameSeq, sessionId });
-      } else {
-        sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, payload);
-      }
-    },
-    // V2: send full snapshot. `reset` marks an explicit clear (new conversation
-    // / transcript file rotation on pane reuse) so the portal's snapshot guard
-    // lets an empty snapshot wipe stale content instead of rejecting it. See the
-    // `reset` field on TranscriptSnapshotMessage (#538) and shouldApplyTranscriptSnapshot.
-    (sessionId, snapshot, seq, reset) => {
-      if (!conn.isReady()) return;
-      const payload = {
-        type: "markdown",
-        subtype: "snapshot",
-        schemaVersion: 2,
-        sessionId,
-        seq,
-        snapshot,
-        ...reset ? { reset: true } : {}
-      };
-      if (conn.sessionKey) {
-        const contentStr = JSON.stringify(payload);
-        const { enc, iv, seq: frameSeq } = encryptPayload(contentStr, conn.sessionKey, conn.txSeq.next());
-        sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, { type: "markdown", enc, iv, seq: frameSeq, sessionId });
-      } else {
-        sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, payload);
+      for (const safeOps of boundTranscriptOpsForWire(ops)) {
+        const payload = {
+          type: "markdown",
+          subtype: "delta",
+          schemaVersion: 2,
+          sessionId,
+          seq,
+          ops: safeOps
+        };
+        if (conn.sessionKey) {
+          const contentStr = JSON.stringify(payload);
+          const { enc, iv, seq: frameSeq } = encryptPayload(contentStr, conn.sessionKey, conn.txSeq.next());
+          sendToGroup(
+            conn.activeSocket,
+            conn.activeGroups.privateGroup,
+            { type: "markdown", enc, iv, seq: frameSeq, sessionId },
+            { markdownSubtype: "delta", markdownSchemaVersion: 2, sessionId }
+          );
+        } else {
+          sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, payload);
+        }
       }
     },
+    sendTranscriptSnapshot,
     // #483: when a deferred enableMarkdown retry succeeds, flip the portal
     // status from "unavailable" back to "enabled" so the markdown view
     // drops the loading placeholder without a user-driven reconnect.
@@ -14846,30 +17474,36 @@ async function runAgent(rawOptions) {
   );
   const sendNativeOps = (sessionId, ops, seq) => {
     if (!conn.isReady()) return;
-    const payload = {
-      type: "markdown",
-      subtype: "delta",
-      schemaVersion: 2,
-      sessionId,
-      seq,
-      ops
-    };
-    if (conn.sessionKey) {
-      const contentStr = JSON.stringify(payload);
-      const { enc, iv, seq: frameSeq } = encryptPayload(
-        contentStr,
-        conn.sessionKey,
-        conn.txSeq.next()
-      );
-      sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, {
+    for (const safeOps of boundTranscriptOpsForWire(ops)) {
+      const payload = {
         type: "markdown",
-        enc,
-        iv,
-        seq: frameSeq,
-        sessionId
-      });
-    } else {
-      sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, payload);
+        subtype: "delta",
+        schemaVersion: 2,
+        sessionId,
+        seq,
+        ops: safeOps
+      };
+      if (conn.sessionKey) {
+        const contentStr = JSON.stringify(payload);
+        const { enc, iv, seq: frameSeq } = encryptPayload(
+          contentStr,
+          conn.sessionKey,
+          conn.txSeq.next()
+        );
+        sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, {
+          type: "markdown",
+          enc,
+          iv,
+          seq: frameSeq,
+          sessionId
+        }, {
+          markdownSubtype: "delta",
+          markdownSchemaVersion: 2,
+          sessionId
+        });
+      } else {
+        sendToGroup(conn.activeSocket, conn.activeGroups.privateGroup, payload);
+      }
     }
   };
   const shell = new ShellManager(options.command, sendOutput);
@@ -14881,12 +17515,14 @@ async function runAgent(rawOptions) {
     conn,
     options,
     transcriptWatcher,
-    sendNativeOps
+    sendNativeOps,
+    sendTranscriptSnapshot
   );
   shell.spawn();
   const onSignal = () => {
     dispatcher.shouldRun = false;
     dispatcher.stopTranscriptWatchers();
+    nativeTranscriptRecovery?.cancel();
     stopAllNativeSessions();
     conn.cleanup({ stopStreams: true });
     shell.stop();
@@ -14914,7 +17550,10 @@ async function runAgent(rawOptions) {
         };
         await new Promise((resolve) => {
           const ws = new import_ws5.default(negotiated.url, "json.webpubsub.azure.v1");
-          conn.setConnection(ws, groups, negotiated.sessionKey ?? null);
+          conn.setConnection(ws, groups, negotiated.sessionKey ?? null, {
+            cryptoBindingVersion: negotiated.cryptoBindingVersion,
+            serverClockOffsetMs: negotiated.serverClockOffsetMs
+          });
           let connectedAt = 0;
           if (negotiated.sessionKey) {
             const enforcer = new ApprovalEnforcer({
@@ -14949,6 +17588,7 @@ async function runAgent(rawOptions) {
               // sequence trackers so restarted frames aren't dropped forever.
               streamEpoch: conn.streamEpoch
             });
+            nativeTranscriptRecovery?.request();
             conn.replayBufferedOutput((chunk) => {
               for (const outputChunk of splitTransportChunks(chunk)) {
                 if (conn.sessionKey) {
@@ -15003,23 +17643,33 @@ async function runAgent(rawOptions) {
                 let inputData = null;
                 if (typeof payload.enc === "string" && typeof payload.iv === "string" && conn.sessionKey) {
                   const inSeq = typeof payload.seq === "number" ? payload.seq : null;
-                  const rxSeq = conn.getRxSeqForViewer(payload.viewerId);
                   if (inSeq === null) {
                     log25.warn("rejecting encrypted input frame without seq (#310)");
-                  } else if (!rxSeq.accept(inSeq)) {
-                    log25.warn("rejecting replayed/out-of-order input", {
-                      seq: inSeq,
-                      lastSeen: rxSeq.lastSeq,
-                      viewerId: typeof payload.viewerId === "string" ? payload.viewerId : "_legacy"
-                    });
                   } else {
-                    inputData = decryptPayload(
+                    const authenticated = conn.authenticateInboundFrame(
                       payload.enc,
                       payload.iv,
-                      conn.sessionKey,
-                      inSeq
+                      inSeq,
+                      payload.viewerId,
+                      {
+                        bindingVersion: payload.bindingVersion,
+                        sentAtMs: payload.sentAtMs,
+                        type: "input",
+                        action: "",
+                        sessionId: payload.sessionId
+                      }
                     );
-                    if (inputData === null) {
+                    if (authenticated.ok) {
+                      inputData = authenticated.plaintext;
+                    } else if (authenticated.reason === "replayed") {
+                      log25.warn("rejecting replayed/out-of-order input", {
+                        seq: inSeq,
+                        lastSeen: authenticated.lastSeen,
+                        viewerId: authenticated.viewerKey
+                      });
+                    } else if (authenticated.reason === "invalid_viewer") {
+                      log25.warn("rejecting input with invalid viewerId");
+                    } else {
                       log25.warn("failed to decrypt input \u2014 ignoring");
                     }
                   }
@@ -15043,39 +17693,53 @@ async function runAgent(rawOptions) {
               } else if (payload.type === "control" && typeof payload.action === "string") {
                 let controlPayload = payload;
                 if (typeof payload.enc === "string" && typeof payload.iv === "string" && conn.sessionKey) {
+                  if (payload.action !== "upload-file") {
+                    log25.warn("rejecting encrypted control with unsupported outer action");
+                    return;
+                  }
                   const inSeq = typeof payload.seq === "number" ? payload.seq : null;
-                  const rxSeq = conn.getRxSeqForViewer(payload.viewerId);
                   if (inSeq === null) {
                     log25.warn("rejecting encrypted control frame without seq");
                     return;
                   }
-                  if (!rxSeq.accept(inSeq)) {
+                  const authenticated = conn.authenticateInboundFrame(
+                    payload.enc,
+                    payload.iv,
+                    inSeq,
+                    payload.viewerId,
+                    {
+                      bindingVersion: payload.bindingVersion,
+                      sentAtMs: payload.sentAtMs,
+                      type: "control",
+                      action: payload.action,
+                      sessionId: payload.sessionId
+                    }
+                  );
+                  if (!authenticated.ok && authenticated.reason === "replayed") {
                     log25.warn("rejecting replayed/out-of-order control", {
                       seq: inSeq,
-                      lastSeen: rxSeq.lastSeq,
-                      viewerId: typeof payload.viewerId === "string" ? payload.viewerId : "_legacy"
+                      lastSeen: authenticated.lastSeen,
+                      viewerId: authenticated.viewerKey
                     });
                     return;
                   }
-                  const decrypted = decryptPayload(
-                    payload.enc,
-                    payload.iv,
-                    conn.sessionKey,
-                    inSeq
-                  );
-                  if (decrypted === null) {
+                  if (!authenticated.ok) {
                     log25.warn("failed to decrypt control \u2014 ignoring");
                     return;
                   }
-                  try {
-                    controlPayload = {
-                      ...JSON.parse(decrypted),
-                      _verifiedEncrypted: true
-                    };
-                  } catch {
-                    log25.warn("failed to parse encrypted control payload");
+                  const verifiedUpload = parseAuthenticatedUploadControlPayload(
+                    authenticated.plaintext,
+                    {
+                      action: payload.action,
+                      sessionId: payload.sessionId,
+                      viewerId: payload.viewerId
+                    }
+                  );
+                  if (!verifiedUpload) {
+                    log25.warn("rejecting encrypted control with mismatched or invalid inner envelope");
                     return;
                   }
+                  controlPayload = verifiedUpload;
                 } else if (conn.sessionKey && payload.action === "upload-file") {
                   log25.warn("rejecting plaintext attachment upload while encrypted channel is active");
                   return;
@@ -15155,6 +17819,7 @@ async function runAgent(rawOptions) {
     }
   } finally {
     dispatcher.stopTranscriptWatchers();
+    nativeTranscriptRecovery?.cancel();
     stopAllNativeSessions();
     conn.cleanup({ stopStreams: true });
     shell.stop();