tmux-ide 2.9.10 → 2.9.12

package/packages/daemon/src/terminal/session-runtime/terminal-replica-interpreter.ts

@@ -53,6 +53,23 @@ import {
 } from "../graphics/kitty-graphics.ts";
 import type { TerminalGraphicsState } from "@tmux-ide/contracts";
 
+// Bound parser work per turn without changing byte-stream semantics. This is a
+// batch bound, not a producer queue cap: upstream pressure must preserve bytes.
+const MAX_INGEST_BATCH_BYTES = 256 * 1024;
+type PendingWrite = {
+  data: Uint8Array;
+  offset: number;
+  resolve: () => void;
+  reject: (error: unknown) => void;
+};
+type WriteGroup = {
+  entries: PendingWrite[];
+  bytes: number;
+  scheduled: boolean;
+  flushQueued: boolean;
+  trace: SessionRuntimeTraceContext | null;
+};
+
 type CloseReason = "pane-closed" | "session-restarted" | "runtime-disposed";
 export type TerminalReplicaInterpreterOperation =
   | {
@@ -167,13 +184,7 @@ export class TerminalReplicaInterpreter {
   #needsSeed = true;
   #closed = false;
   #walkCount = 0;
-  #pendingWrites: Array<{
-    data: Uint8Array;
-    trace: SessionRuntimeTraceContext | null;
-    resolve: () => void;
-    reject: (error: unknown) => void;
-  }> = [];
-  #writeFlushScheduled = false;
+  #pendingWrites: WriteGroup | null = null;
   #widgetGate = false;
   // kitty graphics: images outlive reseeds; the scanner owns split APCs.
   readonly #kittyScanner = new KittyApcScanner();
@@ -252,18 +263,27 @@ export class TerminalReplicaInterpreter {
     if (operation.type === "write") {
       const data = operation.data.slice();
       const trace = operation.trace ?? null;
-      const pendingTrace = this.#pendingWrites[0]?.trace ?? null;
       if (
-        this.#pendingWrites.length > 0 &&
-        (pendingTrace?.traceId ?? null) !== (trace?.traceId ?? null)
+        this.#pendingWrites &&
+        (this.#pendingWrites.trace?.traceId ?? null) !== (trace?.traceId ?? null)
       )
         this.#flushWrites();
+      const group = (this.#pendingWrites ??= {
+        entries: [],
+        bytes: 0,
+        scheduled: false,
+        flushQueued: false,
+        trace,
+      });
       const promise = new Promise<void>((resolve, reject) => {
-        this.#pendingWrites.push({ data, trace, resolve, reject });
+        group.entries.push({ data, offset: 0, resolve, reject });
+        group.bytes += data.length;
       });
-      if (!this.#writeFlushScheduled) {
-        this.#writeFlushScheduled = true;
-        this.#scheduler.microtask(() => this.#flushWrites());
+      // Leave this group open while the parser awaits its callback. Scheduling
+      // it once on the FIFO lets later arrivals join the next bounded batch.
+      if (!group.scheduled && !group.flushQueued) {
+        group.flushQueued = true;
+        this.#scheduler.microtask(() => this.#scheduleWriteGroup(group));
       }
       return promise;
     }
@@ -528,7 +548,27 @@ export class TerminalReplicaInterpreter {
     // turn, so a frame split into dozens of %output chunks would otherwise
     // serialize dozens of turns and fall behind a 30 fps image stream.
     if (scanned.forward.byteLength === 0) return;
-    await this.#writeToBackend(this.#backend, scanned.forward);
+    // Scanning can prepend an escape retained from the previous chunk. Bound
+    // the actual parser calls too, and union damage across every fragment.
+    for (let offset = 0; offset < scanned.forward.length; offset += MAX_INGEST_BATCH_BYTES) {
+      await this.#writeToBackend(
+        this.#backend,
+        scanned.forward.subarray(offset, offset + MAX_INGEST_BATCH_BYTES),
+      );
+      // The parser resets its dirty tracker per write. Synchronized output and
+      // bounded fragments can both span writes before canonical publication.
+      const dirty = this.#backend.dirtyRange();
+      const pending = this.#pendingWriteDirty;
+      this.#pendingWriteDirty =
+        pending === null
+          ? dirty
+          : pending === undefined || dirty === undefined
+            ? undefined
+            : {
+                start: Math.min(pending.start, dirty.start),
+                end: Math.max(pending.end, dirty.end),
+              };
+    }
     if (this.#observability.enabled)
       this.#observability.recordSpan(
         "parse",
@@ -537,19 +577,6 @@ export class TerminalReplicaInterpreter {
         this.#observability.nowMicros(),
         trace,
       );
-    // The parser resets its dirty tracker per write. Synchronized output may
-    // span many writes before publication, so retain their union until commit.
-    const dirty = this.#backend.dirtyRange();
-    const pending = this.#pendingWriteDirty;
-    this.#pendingWriteDirty =
-      pending === null
-        ? dirty
-        : pending === undefined || dirty === undefined
-          ? undefined
-          : {
-              start: Math.min(pending.start, dirty.start),
-              end: Math.max(pending.end, dirty.end),
-            };
     // DEC synchronized-output is atomic: no intermediate frame leaks.
     if (this.#backend.requiresNativeReseed()) {
       this.#commit(false);
@@ -574,6 +601,7 @@ export class TerminalReplicaInterpreter {
     if (this.#syncRecovery || this.#closed) return;
     this.#syncRecovery = this.#scheduler.timer(() => {
       this.#syncRecovery = null;
+      this.#flushWrites();
       const run = this.#tail.then(async () => {
         if (this.#closed || !this.#backend.modes().synchronizedOutput) return;
         // Recovery is synthetic parser maintenance, not pane output caused by
@@ -859,24 +887,54 @@ export class TerminalReplicaInterpreter {
     }
   }
 
+  /** Seal the current group at every trace, control and idle barrier. */
   #flushWrites(): void {
-    this.#writeFlushScheduled = false;
-    if (this.#pendingWrites.length === 0) return;
-    const pending = this.#pendingWrites.splice(0);
-    const length = pending.reduce((total, entry) => total + entry.data.length, 0);
-    const data = new Uint8Array(length);
-    let offset = 0;
-    for (const entry of pending) {
-      data.set(entry.data, offset);
-      offset += entry.data.length;
-    }
-    const trace = pending.find(({ trace }) => trace !== null)?.trace ?? null;
-    const run = this.#tail.then(() => this.#write(data, trace));
+    const group = this.#pendingWrites;
+    this.#pendingWrites = null;
+    if (group) this.#scheduleWriteGroup(group);
+  }
+
+  #scheduleWriteGroup(group: WriteGroup): void {
+    if (group.scheduled) return;
+    group.scheduled = true;
+    const run = this.#tail.then(async () => {
+      try {
+        while (group.entries.length > 0) {
+          const length = Math.min(group.bytes, MAX_INGEST_BATCH_BYTES);
+          const data = new Uint8Array(length);
+          const completed: PendingWrite[] = [];
+          let offset = 0;
+          for (const entry of group.entries) {
+            const take = Math.min(entry.data.length - entry.offset, length - offset);
+            data.set(entry.data.subarray(entry.offset, entry.offset + take), offset);
+            offset += take;
+            entry.offset += take;
+            if (entry.offset === entry.data.length) completed.push(entry);
+            else break;
+            if (offset === length && length > 0) break;
+          }
+          group.entries.splice(0, completed.length);
+          group.bytes -= length;
+          try {
+            await this.#write(data, group.trace);
+          } catch (error) {
+            for (const entry of completed) entry.reject(error);
+            throw error;
+          }
+          for (const entry of completed) entry.resolve();
+        }
+      } catch (error) {
+        // Reject every remaining fragment in the failed group; later FIFO
+        // controls (including recovery reseeds and close) still execute.
+        for (const entry of group.entries) entry.reject(error);
+        group.entries.length = 0;
+        group.bytes = 0;
+        throw error;
+      } finally {
+        if (this.#pendingWrites === group) this.#pendingWrites = null;
+      }
+    });
     this.#tail = run.catch(() => undefined);
-    void run.then(
-      () => pending.forEach((entry) => entry.resolve()),
-      (error) => pending.forEach((entry) => entry.reject(error)),
-    );
   }
 
   #observeMarkerBytes(data: Uint8Array): void {

package/packages/daemon/src/terminal/session-runtime/terminal-replica-owner.ts

@@ -259,6 +259,12 @@ export class SessionRuntimeTerminalReplicaOwner {
     return this.#disposed ? null : this.#publishedIncarnation;
   }
 
+  /** Screen recapture does not replace the terminal lifetime. Keep its input fence
+   * while resizing; disposal or a new owner still invalidates held input. */
+  inputAdmissionIncarnation(): string | null {
+    return this.#disposed ? null : this.#publishedIncarnation;
+  }
+
   qualificationSnapshot(): TerminalReplicaQualificationSnapshot {
     const seed = this.#interpreter.currentSeed();
     return Object.freeze({

package/packages/daemon/src/terminal/session-runtime/transport-binding.ts

@@ -13,6 +13,7 @@ import {
   type SessionRuntimeSemanticIntent,
   type SessionRuntimeTerminalInput,
   type CausalCellProbeV1,
+  type PaneStreamInputLifetime,
   type TerminalDeliveryOffer,
   type TerminalDeliveryServerMessage,
 } from "@tmux-ide/contracts";
@@ -428,6 +429,7 @@ export class SessionRuntimeTransportBinding {
     performanceTraceId?: string,
     causalProbe?: CausalCellProbeV1,
     onCausalResult?: (result: CausalCellLedgerResult) => void,
+    expectedLifetime?: PaneStreamInputLifetime,
   ): void {
     this.assertController(semanticPaneId);
     const lease = this.#shared.lease;
@@ -451,6 +453,7 @@ export class SessionRuntimeTransportBinding {
               onCausalResult?.(result);
             }
           : onCausalResult,
+        expectedLifetime,
       );
     } catch (error) {
       if (causalProbe) this.#causalCellProbes.delete(causalProbe.traceId);

package/packages/daemon/src/tui/mirror/open-tui-workspace-runtime-port.ts

@@ -144,6 +144,8 @@ export const OPEN_TUI_HOST_CLIENT_ID = `opentui:${process.pid}`;
 export type OpenTuiWorkspaceLayout = Extract<PaneStreamServerFrame, { type: "layout" }>;
 
 export interface OpenTuiWorkspaceLayoutSnapshot {
+  /** Renderer-local provenance, stamped only by the host presentation adapter. */
+  readonly rendererEpoch?: number;
   /** Live link authority; absent until an atomic stream snapshot arrives. */
   readonly windowLinks?: WindowLinkTopology | null;
   readonly current: OpenTuiWorkspaceLayout | null;
@@ -530,6 +532,10 @@ class WireTerminalEndpoint {
       return;
     }
     if (this.#unavailable) return;
+    if (message.type === "terminal.projection") {
+      this.#failConnection(new Error("Unsolicited alternate-screen projection"));
+      return;
+    }
     if (message.type === "terminal.delivery") {
       this.#acceptEnvelope(message);
       return;

package/packages/daemon/src/tui/mirror/runtime/application-generation-starter.ts

@@ -104,9 +104,25 @@ export function createApplicationAgentNavigator(options: {
   return async (sessionName: string, paneId: string, source: Source = "mouse") => {
     const token = ++navigationToken;
     const currentOwner = options.sessionOwner();
+    const snapshot = currentOwner.snapshot();
+    // A renderer rebind keeps its semantic control connection. Reserve this
+    // exact target synchronously; the controller fences and bounds first send.
+    const retainedControl = (() => {
+      try {
+        return (
+          snapshot?.status === "rebinding" &&
+          snapshot.connection?.workspaceName === sessionName &&
+          snapshot.daemonGeneration &&
+          snapshot.client &&
+          Number.isSafeInteger(snapshot.client.getSnapshot().generation)
+        );
+      } catch {
+        return false;
+      }
+    })();
     if (
       currentOwner.sessionName() === sessionName &&
-      applicationGenerationNavigationKey(currentOwner.snapshot()) !== null
+      (applicationGenerationNavigationKey(snapshot) !== null || retainedControl)
     ) {
       // Sidebar agents belong to the already-live workspace. Select their pane
       // before returning control to OpenTUI so the very next key cannot leak to

package/packages/daemon/src/tui/mirror/runtime/application-machine-agent-navigation.ts

@@ -1,3 +1,4 @@
+import { retainsAgentControl } from "./application-retained-agent.ts";
 import {
   createApplicationHomeAgentNavigator,
   type HomeAgentNavigationSource,
@@ -39,6 +40,20 @@ export function createApplicationMachineAgentNavigator(options: {
       const selected = () => options.selectedMachineId() === machineId;
       const generation = () =>
         selected() && options.generationMachineId() === machineId ? options.generation() : null;
+      if (
+        selected() &&
+        options.isCurrentTarget(machineId, target) &&
+        options.sessionName() === target.sessionName &&
+        retainsAgentControl(generation(), target)
+      ) {
+        // Reserve before the next key; the terminal controller waits for a fresh
+        // coherent runtime and remains the only owner of physical input.
+        options.selectPane(target.paneId!, source);
+        options.showTerminals(source);
+        options.setNote(null);
+        opening = false;
+        return Promise.resolve({ opened: true });
+      }
       current = createApplicationHomeAgentNavigator({
         isCurrentTarget: (row) => selected() && options.isCurrentTarget(machineId, row),
         currentGeneration() {

package/packages/daemon/src/tui/mirror/runtime/application-machine-navigation.ts

@@ -1,3 +1,4 @@
+import { retainsAgentControl } from "./application-retained-agent.ts";
 import type { OpenTuiGenerationHostSnapshot } from "./open-tui-generation-host.ts";
 import type { TmuxServerScope } from "@tmux-ide/contracts";
 import { fleetHostColor } from "./fleet-presentation.ts";
@@ -90,7 +91,12 @@ export function createApplicationMachineNavigation(options: {
   const [tabRevision, setTabRevision] = createSignal(0);
   const history: string[] = [...saved().recent].reverse();
   let historyIndex = history.length - 1;
-  const select = (id: string, expectedLiveSessionId?: string, server?: TmuxServerScope) => {
+  const select = (
+    id: string,
+    expectedLiveSessionId?: string,
+    server?: TmuxServerScope,
+    retainedAgent?: ApplicationMachineAgent,
+  ) => {
     if (!manager.getMachine(id)) return false;
     if (manager.snapshot().selectedMachineId !== id) {
       navigation++;
@@ -100,9 +106,17 @@ export function createApplicationMachineNavigation(options: {
       else options.resetWorkspace(id, expectedLiveSessionId);
       manager.select(id);
     } else if (expectedLiveSessionId) {
+      const active = options.attachedGeneration?.() ?? null;
+      const retained =
+        retainedAgent && retainsAgentControl(active, retainedAgent)
+          ? {
+              liveSessionId: active!.connection!.liveSessionId,
+              daemonGeneration: active!.daemonGeneration,
+              ...(active!.connection!.server ? { server: active!.connection!.server } : {}),
+            }
+          : null;
       const attached =
-        options.attachedTarget?.() ??
-        attachedMachineNavigationTarget(options.attachedGeneration?.() ?? null);
+        options.attachedTarget?.() ?? attachedMachineNavigationTarget(active) ?? retained;
       const sameAuthority =
         attached?.liveSessionId === expectedLiveSessionId &&
         (server
@@ -357,7 +371,7 @@ export function createApplicationMachineNavigation(options: {
         return;
       }
       options.cancelOpen();
-      if (!select(id, selectedSession?.liveSessionId, selectedSession?.server)) return;
+      if (!select(id, selectedSession?.liveSessionId, selectedSession?.server, row)) return;
       if (selectedSession) setActiveSessionKey(selectedSession.id);
       navigation++;
       setFocused(false);

package/packages/daemon/src/tui/mirror/runtime/application-retained-agent.ts

@@ -0,0 +1,29 @@
+import type { OpenTuiGenerationHostSnapshot } from "./open-tui-generation-host.ts";
+import type { HomeAgentNavigationTarget } from "./application-home-agent-navigation.ts";
+
+/** Selection intent may wait on this exact retained control; input cannot use it yet. */
+export function retainsAgentControl(
+  active: OpenTuiGenerationHostSnapshot | null,
+  target: HomeAgentNavigationTarget,
+): boolean {
+  if (
+    active?.status !== "rebinding" ||
+    !active.client ||
+    !target.paneId ||
+    active.daemonGeneration !== target.daemonInstanceId ||
+    active.connection?.workspaceName !== target.sessionName ||
+    active.connection.liveSessionId !== target.liveSessionId
+  )
+    return false;
+  try {
+    const state = active.client.getSnapshot();
+    return (
+      Number.isSafeInteger(state.generation) &&
+      state.semantic?.sidebar.agents.some(
+        (agent) => agent.id === target.agentId && agent.paneId === target.paneId,
+      ) === true
+    );
+  } catch {
+    return false;
+  }
+}

package/packages/daemon/src/tui/mirror/runtime/application-terminal-interaction-controller.ts

@@ -1,3 +1,5 @@
+import { rendererProbe } from "./renderer-probe.ts";
+import { createTerminalSelectionWaiter } from "./terminal-selection-waiter.ts";
 import { WorkspaceWindowLinkSelectResultSchemaZ } from "@tmux-ide/contracts";
 import { windowLinkForPane, windowLinkTarget } from "./application-terminal-workspace-policy.ts";
 import { createHash, randomUUID } from "node:crypto";
@@ -350,6 +352,10 @@ export function createApplicationTerminalInteractionController(
     left.generation === right.generation &&
     left.workspace === right.workspace;
   let selectedControl: ControlIdentity | null = null;
+  const selectionWaiter = createTerminalSelectionWaiter();
+  let observedLayoutEpoch: number | null = null;
+  let selectionGeneration: OpenTuiGenerationHostSnapshot | null = null;
+  let selectionLayout = options.layout();
   const waitingInput = new Set<{
     control: ControlIdentity;
     weight: number;
@@ -823,10 +829,30 @@ export function createApplicationTerminalInteractionController(
       "semanticPaneId" | "generation" | "incarnation" | "revision" | "stateHash"
     >;
   }>({
-    select: async (paneId) => {
+    select: async (paneId): Promise<boolean> => {
       finishLinkSelection(false);
+      const initial = options.generation();
+      const selectionControl = controlIdentity(initial);
+      const selectionVersion = paneInput.selectionVersion;
+      const selectionCurrent = (): boolean =>
+        paneInput.selectionVersion === selectionVersion &&
+        sameControl(selectionControl, controlIdentity(selectionGeneration));
+      const panePresent = () =>
+        selectionLayout.windows.some((window) => window.panes.some((pane) => pane.pane === paneId));
+      if (initial?.status === "rebinding") {
+        // Reserve the optimistic target now, but send its FIRST mutation only
+        // after this same control connection has a coherent terminal runtime.
+        const ready = await selectionWaiter.wait(() => {
+          if (!selectionCurrent()) return false;
+          const active = selectionGeneration;
+          if (active?.status !== "live" || observedLayoutEpoch !== active.rendererEpoch)
+            return "pending";
+          return panePresent();
+        });
+        if (!ready || !selectionCurrent()) return false;
+      }
       const expected = liveSelectionTarget();
-      const selectionControl = controlIdentity(options.generation());
+      let dispatchedRendererEpoch: number | undefined;
       const selecting = pendingWindowSwitch;
       const operationId = selecting?.traceId;
       const selectionFailure: { current: PaneSelectionFailure | null } = { current: null };
@@ -845,8 +871,37 @@ export function createApplicationTerminalInteractionController(
               selectionFailure.current = failure;
             },
             windowLinkForPane(options.layout(), paneId) ?? undefined,
+            () => {
+              dispatchedRendererEpoch = options.generation()?.rendererEpoch;
+            },
           )
         : null;
+      if (
+        receipt === null &&
+        selectionFailure.current?.reason === "topology-changed" &&
+        selectionCurrent()
+      ) {
+        // The daemon may have selected the pane before retiring its stream.
+        // Observe the replacement runtime; never resubmit an uncertain command
+        // or manufacture an operation receipt. Input still waits on this promise.
+        const confirmed = await selectionWaiter.wait(() => {
+          if (!selectionCurrent()) return false;
+          const active = selectionGeneration;
+          if (
+            active?.status !== "live" ||
+            active.rendererEpoch === dispatchedRendererEpoch ||
+            observedLayoutEpoch !== active.rendererEpoch
+          )
+            return "pending";
+          if (!panePresent()) return false;
+          const current = selectionLayout.current;
+          const activePanes = current?.panes.filter((pane) => pane.active) ?? [];
+          if (!current?.currentWindow || activePanes.length !== 1) return "pending";
+          return activePanes[0]?.pane === paneId ? true : "pending";
+        });
+        if (selecting && pendingWindowSwitch === selecting) pendingWindowSwitch = null;
+        return confirmed && selectionCurrent();
+      }
       if (selecting && pendingWindowSwitch === selecting) {
         const receiptAtMicros = options.detailedWindowSwitchTiming ? diagnosticNowMicros() : null;
         if (selecting.timing) selecting.timing.receiptAtMicros = receiptAtMicros;
@@ -996,22 +1051,30 @@ export function createApplicationTerminalInteractionController(
       }
       return outcome.status === "sent";
     },
-    onFocusedPane: options.setFocusedPane,
+    onFocusedPane: (pane) => {
+      rendererProbe()?.cancel("selection-changed", nowMicros());
+      options.setFocusedPane(pane);
+    },
   });
 
   return {
     cancelPendingInput() {
+      rendererProbe()?.cancel("input-cancelled", nowMicros());
+      selectionWaiter.cancel();
       finishLinkSelection(false);
       paneInput.invalidateSelection();
       for (const entry of waitingInput) entry.settle(false);
     },
     adoptGeneration(snapshot) {
+      selectionGeneration = snapshot;
       const control = controlIdentity(snapshot);
       if (!sameControl(selectedControl, control)) {
+        rendererProbe()?.cancel("control-changed", nowMicros());
         finishLinkSelection(false);
         paneInput.invalidateSelection();
       }
       selectedControl = control;
+      selectionWaiter.reconcile();
       if (waitingInput.size > 0 && snapshot?.status === "live" && snapshot.fastLane) {
         // Old waiters resume first; input admitted synchronously by the next
         // layout publication must not overtake them in this microtask turn.
@@ -1061,6 +1124,7 @@ export function createApplicationTerminalInteractionController(
           next.fastLane !== inputAuthorityIdentity.fastLane ||
           next.adapter !== inputAuthorityIdentity.adapter);
       if (next === null || replaced) {
+        rendererProbe()?.cancel("generation-changed", nowMicros());
         finishLinkSelection(false);
         pendingWindowSwitch = null;
         pendingWindowRename = null;
@@ -1074,6 +1138,9 @@ export function createApplicationTerminalInteractionController(
       inputAuthorityIdentity = next;
     },
     adoptLayout(snapshot) {
+      selectionLayout = snapshot;
+      observedLayoutEpoch = snapshot.rendererEpoch ?? null;
+      selectionWaiter.reconcile();
       reconcileLinkSelection(snapshot);
       paneInput.adoptCanonicalPane(snapshot.current ? paneForWindow(snapshot.current) : null);
       const currentWindow = snapshot.current?.semanticWindowId ?? snapshot.current?.windowName;
@@ -1165,6 +1232,7 @@ export function createApplicationTerminalInteractionController(
     selectPane: (paneId) => {
       finishLinkSelection(false);
       paneInput.selectPane(paneId);
+      selectionWaiter.reconcile();
     },
     async unlinkWindowLink(target) {
       const expected = liveSelectionTarget();
@@ -1303,10 +1371,25 @@ export function createApplicationTerminalInteractionController(
       }
     },
     sendInput: async (input, parserOrigin) => {
-      await paneInput.sendInput({ input, parserOrigin });
+      const probe = rendererProbe();
+      const state = probe
+        ? (options.generation()?.fastLane?.lane.paneState(paneInput.focusedPane ?? "") ?? null)
+        : null;
+      const measured = probe?.admit(input, state, nowMicros());
+      const sent = await paneInput.sendInput({ input: measured ?? input, parserOrigin });
+      if (measured && !sent) probe?.cancel("dispatch-rejected", nowMicros());
+    },
+    sendInputToPane: async (paneId, input, parserOrigin) => {
+      const probe = rendererProbe();
+      const state = probe ? (options.generation()?.fastLane?.lane.paneState(paneId) ?? null) : null;
+      const measured = probe?.admit(input, state, nowMicros());
+      const sent = await paneInput.sendInputToPane(paneId, {
+        input: measured ?? input,
+        parserOrigin,
+      });
+      if (measured && !sent) probe?.cancel("dispatch-rejected", nowMicros());
+      return sent;
     },
-    sendInputToPane: (paneId, input, parserOrigin) =>
-      paneInput.sendInputToPane(paneId, { input, parserOrigin }),
     beginResizePointerIngress(input) {
       if (!options.diagnosticsEnabled) return null;
       const atMicros = diagnosticNowMicros();

package/packages/daemon/src/tui/mirror/runtime/application-terminal-workspace.tsx

@@ -1,3 +1,4 @@
+import { rendererProbe } from "./renderer-probe.ts";
 import { paneInteractionDisplayDestination } from "../ui/pane-interaction-presentation.ts";
 import type { InteractionObservationStatus, NativePaneIdentity } from "@tmux-ide/contracts";
 import { interactionPaneEndpointKey } from "@tmux-ide/core";
@@ -1350,6 +1351,7 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
       return;
     }
     if (event.type === "scroll") {
+      const probeAt = rendererProbe() ? Math.floor(performance.now() * 1000) : 0;
       // A held selection owns the gesture even when the pointer crosses a sibling.
       const activeSelection = selecting;
       const selectionCell =
@@ -1359,7 +1361,10 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
         activeSelection && selectionCell
           ? { frame: activeSelection.frame, ...selectionCell }
           : paneContentAt(point);
-      const before = props.onWheelObservation && hit ? scrollback.offset(hit.frame.paneId) : null;
+      const before =
+        (props.onWheelObservation || rendererProbe()) && hit
+          ? scrollback.offset(hit.frame.paneId)
+          : null;
       const observe = (route: string): void => {
         props.onWheelObservation?.({
           paneId: hit?.frame.paneId ?? null,
@@ -1457,6 +1462,20 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
           scrollback.seek(hit.frame.paneId, { ...origin, y: next.originY });
           setKeyboardCopy({ ...keyboard, cursor: next.cursor });
         } else scrollback.move(hit.frame.paneId, motion.lines);
+        if (rendererProbe() && identity && before !== null)
+          rendererProbe()?.scroll(
+            {
+              pane: hit.frame.paneId,
+              generation: identity.generation,
+              incarnation: identity.incarnation,
+              cols: snapshot.cols,
+              rows: snapshot.rows,
+            },
+            snapshot,
+            before,
+            scrollback.offset(hit.frame.paneId),
+            probeAt,
+          );
         observe("local-history");
         if (selecting?.paneId === hit.frame.paneId) updatePointerSelection(selecting.pointer);
         else {

package/packages/daemon/src/tui/mirror/runtime/open-tui-generation-host.ts

@@ -560,7 +560,7 @@ export function createOpenTuiGenerationHost(
       // desired state against the fresh socket on the following live publish.
       publish({ ...snapshot, status: "rebinding" });
       owner.stopPresentation?.();
-      owner.stopPresentation = runtime ? presentation.adopt(runtime) : null;
+      owner.stopPresentation = runtime ? presentation.adopt(runtime, rendererEpoch + 1) : null;
       owner.runtime = runtime;
       owner.authorityClient = runtime ? runtimeAuthorityClient(owner.bundle, runtime) : null;
       if (!runtime) presentation.clear();
@@ -580,7 +580,7 @@ export function createOpenTuiGenerationHost(
     }
     if (candidate !== owner) return;
     if (runtime) {
-      owner.stopPresentation = presentation.adopt(runtime);
+      owner.stopPresentation = presentation.adopt(runtime, rendererEpoch + 1);
       diagnose?.("host-internal-snapshot-publication", {
         publicationPhase: "presentation-adopted",
         daemonGeneration: owner.bundle.connection.target.daemon.instanceId,