tmux-ide 2.9.9 → 2.9.11

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,13 @@ export class SessionRuntimeTerminalReplicaOwner {
     return this.#disposed ? null : this.#publishedIncarnation;
   }
 
+  /** Scalar admission fence; unavailable while canonical replacement is pending. */
+  inputAdmissionIncarnation(): string | null {
+    return this.#disposed || this.#reseed || this.#waitingForGeometryCapture
+      ? 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;

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,4 @@
+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 +351,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 +828,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 +870,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;
@@ -1001,17 +1055,20 @@ export function createApplicationTerminalInteractionController(
 
   return {
     cancelPendingInput() {
+      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)) {
         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.
@@ -1074,6 +1131,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 +1225,7 @@ export function createApplicationTerminalInteractionController(
     selectPane: (paneId) => {
       finishLinkSelection(false);
       paneInput.selectPane(paneId);
+      selectionWaiter.reconcile();
     },
     async unlinkWindowLink(target) {
       const expected = liveSelectionTarget();

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,

package/packages/daemon/src/tui/mirror/runtime/runtime-layout-presentation.ts

@@ -11,7 +11,7 @@ export interface OpenTuiRuntimeLayoutPresentation {
   getWindowSnapshot(): OpenTuiWorkspaceLayoutSnapshot;
   subscribe(listener: (layout: OpenTuiTerminalLayout | null) => void): () => void;
   subscribeWindows(listener: (layout: OpenTuiWorkspaceLayoutSnapshot) => void): () => void;
-  adopt(port: OpenTuiLayoutPort): () => void;
+  adopt(port: OpenTuiLayoutPort, rendererEpoch: number): () => void;
   clear(): void;
   dispose(): void;
 }
@@ -66,21 +66,24 @@ export function createOpenTuiRuntimeLayoutPresentation(): OpenTuiRuntimeLayoutPr
       listener(windows);
       return () => windowListeners.delete(listener);
     },
-    adopt(port) {
+    adopt(port, rendererEpoch) {
       if (disposed) return () => undefined;
       let candidate = true;
       let candidateStop: (() => void) | null = null;
       candidateStop = port.onLayout((layout) => {
         if (disposed || !candidate || !layout.current) return;
+        // A port may reuse its snapshot object. Own the provenance wrapper so
+        // a preparing runtime cannot relabel the retained coherent frame.
+        const presented = Object.freeze({ ...layout, rendererEpoch });
         if (currentPort !== port) {
           const previousStop = stopLayout;
           currentPort = port;
           stopLayout = candidateStop;
-          publish(layout);
+          publish(presented);
           previousStop?.();
           return;
         }
-        publish(layout);
+        publish(presented);
       });
       // `onLayout` intentionally seeds synchronously. Capture the disposer
       // after that first callback has promoted this candidate.

package/packages/daemon/src/tui/mirror/runtime/select-terminal-pane.ts

@@ -20,6 +20,7 @@ export type PaneSelectionFailure = Readonly<{
     | "generation-replaced"
     | "operation-timeout"
     | "transport-rejected"
+    | "topology-changed"
     | "receipt-invalid";
   backendReason?:
     | "pane_inventory_not_ready"
@@ -42,6 +43,7 @@ export async function selectTerminalPane(
   operationId?: string,
   onFailure?: (failure: PaneSelectionFailure) => void,
   windowLink?: WindowLinkTarget,
+  onDispatch?: () => void,
 ): Promise<PaneSelectionReceipt | null> {
   const fail = (failure: PaneSelectionFailure): null => {
     try {
@@ -62,7 +64,12 @@ export async function selectTerminalPane(
       : undefined;
     return fail({
       stage,
-      reason: code === "operation-timeout" ? "operation-timeout" : "transport-rejected",
+      reason:
+        code === "operation-timeout"
+          ? "operation-timeout"
+          : code === "topology-changed" && stage === "dispatch"
+            ? "topology-changed"
+            : "transport-rejected",
       ...(backendReason ? { backendReason } : {}),
     });
   };
@@ -90,6 +97,7 @@ export async function selectTerminalPane(
     if (!isCurrent()) return fail({ stage: "pre-dispatch", reason: "generation-replaced" });
     let result: unknown;
     try {
+      onDispatch?.();
       result = await expected.client.dispatch({
         kind: "semantic-intent",
         ...(operationId ? { operationId } : {}),

package/packages/daemon/src/tui/mirror/runtime/terminal-selection-waiter.ts

@@ -0,0 +1,36 @@
+/** One bounded selection observation; never submits or repeats a mutation. */
+export function createTerminalSelectionWaiter() {
+  let pending: {
+    check: () => boolean | "pending";
+    finish: (selected: boolean) => void;
+  } | null = null;
+  const cancel = () => pending?.finish(false);
+  const reconcile = () => {
+    const waiting = pending;
+    if (!waiting) return;
+    const result = waiting.check();
+    if (result !== "pending") waiting.finish(result);
+  };
+  return {
+    cancel,
+    reconcile,
+    wait(check: () => boolean | "pending"): Promise<boolean> {
+      cancel();
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => waiting.finish(false), 5000);
+        timer.unref?.();
+        const waiting = {
+          check,
+          finish(selected: boolean) {
+            if (pending !== waiting) return;
+            pending = null;
+            clearTimeout(timer);
+            resolve(selected);
+          },
+        };
+        pending = waiting;
+        reconcile();
+      });
+    },
+  };
+}