tmux-ide 2.9.2 → 2.9.3

package/packages/daemon/src/terminal/mirror/session-channel.ts

@@ -123,7 +123,10 @@ const STRUCTURAL_NOTIFICATIONS = new Set([
   "window-add",
   "window-close",
   "window-renamed",
+  "unlinked-window-add",
   "unlinked-window-close",
+  "session-renamed",
+  "sessions-changed",
 ]);
 const NATIVE_CLIENT_NOTIFICATIONS = new Set([
   "client-attached",
@@ -239,6 +242,10 @@ export interface MirrorFlowRecoveryObservation {
 }
 
 export interface SessionChannelOptions {
+  onWindowMembership?: (windows: readonly string[]) => void;
+  hasSharedWindowConflict?: () => boolean;
+  beforeIdentityRepair?: () => Promise<void>;
+  onWindowTopologyChanged?: () => void;
   ownedViewer?: Pick<OwnedViewerAdapter, "bindIo" | "tryDispatch" | "dispose"> &
     Partial<Pick<OwnedViewerAdapter, "atomicSnapshotEpoch">>;
   executeWindowLinkGuard?: (args: string[]) => Promise<{ status: number | null; stdout: string }>;
@@ -441,6 +448,7 @@ function layoutIdentitiesEqual(left: WindowLayout, right: WindowLayout): boolean
 }
 
 interface WindowSyncStage {
+  readonly observedAuthorityOrdinal: number;
   readonly windows: Map<string, WindowRecord>;
   readonly layouts: Map<string, ParsedLayout & { zoomed: boolean; unzoomed?: ParsedLayout }>;
   readonly currentWindow: string;
@@ -502,6 +510,7 @@ export class SessionChannel {
   private nativeClientProbePending = false;
   // Native captures fence every geometry event; inventory fences identity only.
   private windowAuthorityOrdinal = 0;
+  private readonly layoutNotificationOrdinals = new Map<string, number>();
   private windowIdentityOrdinal = 0;
   private paneIncarnation = 0;
   private recoveryOrdinal = 0;
@@ -1186,9 +1195,31 @@ export class SessionChannel {
     }
     this.input.flush();
     this.clearWindowViewports();
+    this.restoreWindowSizing(this.attachedIdentity?.runtimeSessionId ?? `=${this.opts.session}`);
     this.io.send(`refresh-client -C ${cols}x${rows}`);
   }
 
+  private restoreWindowSizing(target: string): void {
+    if (!this.geometryParticipating) return;
+    // resize-window pins a window (including through inherited session options).
+    // Evaluate inside the existing control connection: no shell, polling, or extra
+    // request/response round trip. The shell also pre-fits hidden windows;
+    // only the active window may have its manual policy repaired.
+    const quoted = tmuxSingleQuote(target);
+    // if-shell emits its own reply and the selected branch emits another.
+    // Keep both branches at one command so either policy consumes exactly two
+    // FIFO slots; a discard-only send would misroute the next capture replies.
+    this.io.commandListInline(
+      `if-shell -F -t ${quoted} '#{&&:#{window_active},#{==:#{window-size},manual}}' ` +
+        tmuxSingleQuote(`set-option -w -t ${quoted} window-size latest`) +
+        " " +
+        tmuxSingleQuote(`display-message -p -t ${quoted} ''`),
+      2,
+      1,
+      () => {},
+    );
+  }
+
   /**
    * Experimental: window-specific overrides stay private to this control client.
    * Native tmux still falls back to the client size for unscoped neighbours;
@@ -1214,6 +1245,7 @@ export class SessionChannel {
     const previous = this.fittedWindows.get(window.runtimeId);
     if (previous?.cols === cols && previous.rows === rows) return;
     this.input.flush();
+    this.restoreWindowSizing(window.runtimeId);
     this.io.send(`refresh-client -C ${window.runtimeId}:${cols}x${rows}`);
     this.fittedWindows.set(window.runtimeId, { cols, rows });
   }
@@ -1288,6 +1320,7 @@ export class SessionChannel {
       pane.subs.clear();
     }
     this.pendingLayoutOutput.clear();
+    this.layoutNotificationOrdinals.clear();
     this.layoutSubscribers.clear();
     this.layoutAuthoritySubscribers.clear();
     await this.io.dispose();
@@ -2851,6 +2884,15 @@ export class SessionChannel {
   }
 
   private onNotify(name: string, rest: string): void {
+    if (
+      name === "window-add" ||
+      name === "window-close" ||
+      name === "unlinked-window-add" ||
+      name === "unlinked-window-close" ||
+      name === "session-renamed" ||
+      name === "sessions-changed"
+    )
+      this.opts.onWindowTopologyChanged?.();
     if (name === "subscription-changed") {
       const policy =
         /^tmux-ide-scroll-on-clear\s+\$[0-9]+\s+@[0-9]+\s+[0-9]+\s+(%[0-9]+)\s+:\s+([01])\s*$/u.exec(
@@ -2976,6 +3018,7 @@ export class SessionChannel {
         this.scheduleSync(); // never guess from a failed parse
         return;
       }
+      this.layoutNotificationOrdinals.set(change.windowId, this.windowAuthorityOrdinal);
       const pendingLayout = {
         ...parsed,
         zoomed: change.zoomed,
@@ -3294,8 +3337,10 @@ export class SessionChannel {
       previousCurrentWindow,
       syncOrdinal,
     );
-    for (const pane of this.panesByRuntime.values())
+    for (const pane of this.panesByRuntime.values()) {
+      if (pane.windowRuntimeId && this.pendingLayoutOutput.has(pane.windowRuntimeId)) continue;
       for (const sub of pane.subs) sub.resumeLayoutCapture?.(syncOrdinal);
+    }
     this.discovery.discover(listed);
   }
 
@@ -3593,6 +3638,29 @@ export class SessionChannel {
     previousCurrentWindow = this.currentWindow,
     syncOrdinal?: number,
   ): void {
+    // Control notifications in the same read chunk run before a promise-based
+    // inventory read resumes. Preserve newer geometry (and its pending border
+    // query) rather than letting that older inventory erase the notification.
+    const newerLayouts = new Set(
+      [...this.layoutNotificationOrdinals]
+        .filter(([, ordinal]) => ordinal > stage.observedAuthorityOrdinal)
+        .map(([runtimeId]) => runtimeId),
+    );
+    if (newerLayouts.size > 0) {
+      stage = { ...stage, windows: new Map(stage.windows), layouts: new Map(stage.layouts) };
+      for (const runtimeId of newerLayouts) {
+        const currentLayout = this.layoutByWindow.get(runtimeId);
+        const currentWindow = this.windowsByRuntime.get(runtimeId);
+        const stagedWindow = stage.windows.get(runtimeId);
+        if (currentLayout && currentWindow && stagedWindow) {
+          stage.layouts.set(runtimeId, currentLayout);
+          stage.windows.set(runtimeId, {
+            ...stagedWindow,
+            paneBorderStatus: currentWindow.paneBorderStatus,
+          });
+        }
+      }
+    }
     this.windowLinkAuthority?.reconcile(stage.links);
     this.latestWindowStage = stage;
     const changedWindows = new Set<string>();
@@ -3647,8 +3715,14 @@ export class SessionChannel {
           ),
         );
     for (const runtimeId of this.pendingLayoutOutput.keys())
-      if (!stage.windows.has(runtimeId)) this.pendingLayoutOutput.delete(runtimeId);
-    for (const runtimeId of layoutEmits) this.releasePendingLayout(runtimeId, syncOrdinal);
+      if (!stage.windows.has(runtimeId) && !newerLayouts.has(runtimeId))
+        this.pendingLayoutOutput.delete(runtimeId);
+    for (const runtimeId of this.layoutNotificationOrdinals.keys())
+      if (!stage.windows.has(runtimeId) && !newerLayouts.has(runtimeId))
+        this.layoutNotificationOrdinals.delete(runtimeId);
+    for (const runtimeId of layoutEmits)
+      if (!newerLayouts.has(runtimeId) || !this.pendingLayoutOutput.has(runtimeId))
+        this.releasePendingLayout(runtimeId, syncOrdinal);
     this.emitLayoutAuthority();
   }
 
@@ -3686,6 +3760,7 @@ export class SessionChannel {
   }
 
   private async stageWindows(target = this.opts.session): Promise<WindowSyncStage> {
+    const observedAuthorityOrdinal = this.windowAuthorityOrdinal;
     const lines = await this.io.request(
       `list-windows -t "${target}" -F "#{window_id}\t#{qa:@tmux_ide_window_id}\t#{qa:window_name}\t#{window_active}\t#{window_visible_layout}\t#{?window_zoomed_flag,1,0}\t#{pane-border-status}\t#{window_layout}\t#{mode-keys}\t#{window_index}"`,
     );
@@ -3791,6 +3866,10 @@ export class SessionChannel {
       if (!unzoomed) throw new Error(`full window layout for ${this.opts.session} is malformed`);
       nextLayoutByWindow.set(row.runtimeId, { ...parsed, zoomed: row.zoomed, unzoomed });
     }
+    // Publish validated physical membership before any identity repair writes.
+    // The receiving session may introduce duplicate stamps by linking a window.
+    this.opts.onWindowMembership?.([...backingRows.keys()]);
+    await this.opts.beforeIdentityRepair?.();
     // Valid unique stamps are identity; missing/invalid/duplicated stamps are
     // ALL regenerated and stamped back (the pane policy, applied to windows).
     const stampCounts = new Map<string, number>();
@@ -3808,7 +3887,7 @@ export class SessionChannel {
       let semanticId: string | null = null;
       if (row.stamp && stampCounts.get(row.stamp) === 1) {
         semanticId = row.stamp;
-      } else {
+      } else if (!this.opts.hasSharedWindowConflict?.()) {
         repairedIdentity = true;
         let candidate: string | null = null;
         for (let attempt = 0; attempt < 32 && !candidate; attempt += 1) {
@@ -3846,6 +3925,7 @@ export class SessionChannel {
       });
     }
     return {
+      observedAuthorityOrdinal,
       windows: next,
       layouts: nextLayoutByWindow,
       currentWindow: nextCurrentWindow,
@@ -3864,6 +3944,10 @@ export class SessionChannel {
     listed: ReadonlySet<string>,
   ): Promise<boolean> {
     if (this.disposed) return false;
+    if (this.opts.hasSharedWindowConflict?.()) {
+      this.settleFirstJoin();
+      return false;
+    }
     const snapshots: WorkspaceTmuxPaneSnapshot[] = descriptors
       .filter((descriptor) => listed.has(descriptor.runtimePaneId))
       .map((descriptor) => ({
@@ -4005,6 +4089,10 @@ export class SessionChannel {
     descriptors: readonly SessionPaneDescriptor[],
     layouts: ReadonlyMap<string, ParsedLayout & { zoomed: boolean; unzoomed?: ParsedLayout }>,
   ): Promise<boolean> {
+    if (this.opts.hasSharedWindowConflict?.())
+      throw new Error(
+        "Linked windows across controlled sessions are unsupported. Unlink the shared window before controlling this session.",
+      );
     const rectForRuntime = (runtimePaneId: string): WorkspacePaneRect => {
       for (const layout of layouts.values()) {
         const leaf = layout.leaves.find(({ id }) => id === runtimePaneId);

package/packages/daemon/src/terminal/mirror/shared-window-index.ts

@@ -0,0 +1,42 @@
+/** Event-fed physical window membership for one pinned tmux server. */
+export class SharedWindowIndex<Owner> {
+  readonly #windows = new Map<string, Set<Owner>>();
+  readonly #owners = new Map<Owner, Set<string>>();
+  readonly #conflicts = new Set<Owner>();
+
+  conflicted(owner: Owner): boolean {
+    return this.#conflicts.has(owner);
+  }
+
+  update(owner: Owner, windows: readonly string[]): Map<Owner, boolean> {
+    const previous = this.#owners.get(owner) ?? new Set<string>();
+    const next = new Set(windows);
+    const affected = new Set<Owner>([owner]);
+    for (const window of new Set([...previous, ...next])) {
+      for (const peer of this.#windows.get(window) ?? []) affected.add(peer);
+      if (previous.has(window) && !next.has(window)) {
+        const peers = this.#windows.get(window)!;
+        peers.delete(owner);
+        if (!peers.size) this.#windows.delete(window);
+      }
+      if (next.has(window)) {
+        const peers = this.#windows.get(window) ?? new Set<Owner>();
+        peers.add(owner);
+        this.#windows.set(window, peers);
+      }
+    }
+    if (next.size) this.#owners.set(owner, next);
+    else this.#owners.delete(owner);
+    const changed = new Map<Owner, boolean>();
+    for (const peer of affected) {
+      const conflict = [...(this.#owners.get(peer) ?? [])].some(
+        (window) => (this.#windows.get(window)?.size ?? 0) > 1,
+      );
+      if (conflict === this.#conflicts.has(peer)) continue;
+      if (conflict) this.#conflicts.add(peer);
+      else this.#conflicts.delete(peer);
+      changed.set(peer, conflict);
+    }
+    return changed;
+  }
+}

package/packages/daemon/src/terminal/pane-stream/pane-stream-websocket.ts

@@ -2219,7 +2219,18 @@ export class PaneStreamLiveConnection {
         !this.#sessionRuntimeBinding.authoritySnapshot
       )
         return this.#failProtocol("protocol-error");
-      const lease = this.#sessionRuntimeBinding.requestAuthority(frame.authority);
+      let lease: SessionRuntimeAuthorityLease | null = null;
+      try {
+        lease = this.#sessionRuntimeBinding.requestAuthority(frame.authority);
+      } catch (error) {
+        // Topology changes can temporarily prevent ownership. Reject this
+        // request without letting an expected conflict terminate the daemon.
+        if (
+          !(error instanceof SessionRuntimeControllerLeaseError) ||
+          error.code !== "controller-conflict"
+        )
+          return this.#failProtocol("input-rejected");
+      }
       if (lease) this.#requestedAuthorities.add(frame.authority);
       this.#sendFrame(null, {
         type: "authority-receipt",

package/packages/daemon/src/terminal/session-runtime/multiplexer-backend.ts

@@ -26,6 +26,7 @@ export interface SessionRuntimeMultiplexerBackendOptions {
     | "bindExecutionSource"
     | "assertExecutionHandle"
     | "submitPaneCredentialIntent"
+    | "verifyWindowOwnership"
   >;
   readonly resolveSession: (workspaceName: string) => string | null;
   readonly resolvePaneSourceBinding?: (
@@ -192,6 +193,7 @@ export function createSessionRuntimeMultiplexerBackend(
       if (!ownerAuthorized) {
         throw new Error("Semantic mutation requires a live host, pane, or owner principal");
       }
+      await options.registry.verifyWindowOwnership();
       const owner = acquireOwner(session);
       try {
         let lease: ReturnType<SessionRuntimeConsumer["acquireController"]>;

package/packages/daemon/src/terminal/session-runtime/registry.ts

@@ -273,7 +273,10 @@ export class SessionRuntimeRegistry implements PaneStreamMirror {
   readonly #createTraceCorrelator: (scheduler: SessionRuntimeScheduler) => RuntimeTraceCorrelator;
   readonly #sessions = new Map<string, SessionRuntime>();
   readonly #proofPrewarmOwnership = new Map<SessionRuntime, { owned: boolean; claims: number }>();
-  readonly #trustedInventoryTokens = new WeakMap<object, SessionRuntime>();
+  readonly #trustedInventoryTokens = new WeakMap<
+    object,
+    { runtime: SessionRuntime; epoch: number }
+  >();
   readonly #executionHandles = new WeakMap<object, ExecutionHandleState>();
   readonly #stopExitObserver: () => void;
   #disposed = false;
@@ -397,6 +400,10 @@ export class SessionRuntimeRegistry implements PaneStreamMirror {
     this.#mirror = new MirrorService({
       ...options.mirror,
       ...diagnosticMirrorOptions,
+      onSharedWindowConflict: (session, conflict) => {
+        options.mirror?.onSharedWindowConflict?.(session, conflict);
+        if (conflict) this.#sessions.get(session)?.invalidateSharedWindowAuthority();
+      },
       onNativeClientActivity: (session) => {
         options.mirror?.onNativeClientActivity?.(session);
         this.#sessions.get(session)?.noteNativeGeometryActivity();
@@ -433,6 +440,7 @@ export class SessionRuntimeRegistry implements PaneStreamMirror {
     signal?.throwIfAborted();
     const runtime = this.#runtime(session);
     await abortable(runtime.whenReady(), signal);
+    await abortable(this.#mirror.verifyRegisteredWindows(), signal);
     if (this.#sessions.get(session) !== runtime) {
       throw new Error(`SessionRuntime ${session} was retired while prewarming`);
     }
@@ -493,6 +501,7 @@ export class SessionRuntimeRegistry implements PaneStreamMirror {
         throw new Error(`SessionRuntime ${session} is attached to a different tmux identity`);
       }
       signal?.throwIfAborted();
+      await abortable(this.#mirror.verifyRegisteredWindows(), signal);
       runtime.qualifyTrustedInventory(runtimeSessionId);
     } finally {
       this.#releaseProofPrewarmRuntime(runtime);
@@ -521,28 +530,34 @@ export class SessionRuntimeRegistry implements PaneStreamMirror {
     if (!runtime?.trustedInventoryQualified()) {
       throw new Error(`SessionRuntime ${session} has no proof-qualified inventory authority`);
     }
+    const epoch = runtime.trustedInventoryEpoch;
     const inventory = await this.#observeTerminalAttempt(
       "terminal-trusted-inventory-attempt",
       abortable(runtime.describeTrustedInventory(), signal),
     );
-    if (this.#sessions.get(session) !== runtime || !runtime.trustedInventoryQualified()) {
+    if (
+      this.#sessions.get(session) !== runtime ||
+      !runtime.trustedInventoryQualified() ||
+      runtime.trustedInventoryEpoch !== epoch
+    ) {
       throw new Error(`SessionRuntime ${session} changed during trusted inventory discovery`);
     }
     if (!inventory) {
       throw new Error(`SessionRuntime ${session} lost its retained inventory authority`);
     }
     const token = Object.freeze({});
-    this.#trustedInventoryTokens.set(token, runtime);
+    this.#trustedInventoryTokens.set(token, { runtime, epoch });
     return Object.freeze({ inventory, token });
   }
 
   isTrustedSessionInventoryCandidateCurrent(session: string, token: object): boolean {
     if (this.#disposed) return false;
-    const runtime = this.#trustedInventoryTokens.get(token);
+    const candidate = this.#trustedInventoryTokens.get(token);
     return (
-      runtime !== undefined &&
-      this.#sessions.get(session) === runtime &&
-      runtime.trustedInventoryQualified()
+      candidate !== undefined &&
+      this.#sessions.get(session) === candidate.runtime &&
+      candidate.runtime.trustedInventoryEpoch === candidate.epoch &&
+      candidate.runtime.trustedInventoryQualified()
     );
   }
 
@@ -567,6 +582,18 @@ export class SessionRuntimeRegistry implements PaneStreamMirror {
     return this.#mirror.executeWindowLinkAction(session, request);
   }
 
+  /** Resolve pending ownership before an asynchronous owner-authorized mutation. */
+  async verifyWindowOwnership(): Promise<void> {
+    await this.#mirror.verifyRegisteredWindows();
+  }
+
+  /** Install the bounded registered-session membership reader. */
+  setRegisteredWindowReader(
+    reader: import("../mirror/registered-window-guard.ts").RegisteredWindowReader,
+  ): ReturnType<MirrorService["setRegisteredWindowReader"]> {
+    return this.#mirror.setRegisteredWindowReader(reader);
+  }
+
   /** Retire one no-longer-registered session without disturbing siblings. */
   async retireSession(session: string): Promise<void> {
     const runtime = this.#sessions.get(session);
@@ -1105,6 +1132,11 @@ class SessionRuntime {
   readonly #releasedLeases = new Set<string>();
   #disposed = false;
   #trustedInventoryRuntimeSessionId: string | null = null;
+  #trustedInventoryEpoch = 0;
+
+  get trustedInventoryEpoch(): number {
+    return this.#trustedInventoryEpoch;
+  }
   #activeCausalCellProbes = 0;
 
   constructor(
@@ -1195,6 +1227,7 @@ class SessionRuntime {
     clientId: string,
     authority: SessionRuntimeAuthorityKind,
   ): SessionRuntimeAuthorityLease | null {
+    this.assertNoSharedWindow();
     if (authority === "input" && this.#controllerClientId !== clientId) {
       // Input's executable proof is the compatibility controller lease. The
       // transport synchronization seam must establish/handoff it first.
@@ -1261,6 +1294,7 @@ class SessionRuntime {
   }
 
   acquireController(clientId: string): SessionRuntimeControllerLease {
+    this.assertNoSharedWindow();
     this.#assertConnected(clientId);
     if (this.#controllerClientId === clientId) {
       this.#authority.updatePresence(clientId, "foreground");
@@ -1335,6 +1369,7 @@ class SessionRuntime {
   }
 
   assertController(lease: SessionRuntimeControllerLease, callerClientId?: string): void {
+    this.assertNoSharedWindow();
     const parsedLease = this.#validatedLease(lease);
     if (
       parsedLease.generation !== this.generation ||
@@ -1547,6 +1582,7 @@ class SessionRuntime {
     rows: number,
     semanticWindowId?: string,
   ): void {
+    this.assertNoSharedWindow();
     const parsed = SessionRuntimeAuthorityLeaseSchemaZ.parse(lease);
     let exact: SessionRuntimeAuthorityLease;
     try {
@@ -1594,6 +1630,7 @@ class SessionRuntime {
   }
 
   qualifyTrustedInventory(runtimeSessionId: string): void {
+    this.assertNoSharedWindow();
     if (this.#disposed || !this.#retention) {
       throw new Error(`SessionRuntime ${this.session} is not retained`);
     }
@@ -1601,7 +1638,11 @@ class SessionRuntime {
   }
 
   trustedInventoryQualified(): boolean {
-    return !this.#disposed && this.#trustedInventoryRuntimeSessionId !== null;
+    return (
+      !this.#disposed &&
+      this.#trustedInventoryRuntimeSessionId !== null &&
+      !this.#mirror.hasSharedWindowConflict(this.session)
+    );
   }
 
   async describeTrustedInventory(): Promise<TrustedMirrorSessionInventory | null> {
@@ -1812,8 +1853,28 @@ class SessionRuntime {
     this.#publishAuthority();
   }
 
+  private assertNoSharedWindow(): void {
+    const message = this.#mirror.windowOwnershipMessage(this.session);
+    if (message) {
+      throw new SessionRuntimeControllerLeaseError("controller-conflict", message);
+    }
+  }
+
+  invalidateSharedWindowAuthority(): void {
+    this.#trustedInventoryRuntimeSessionId = null;
+    this.#trustedInventoryEpoch += 1;
+    this.#clearController();
+    for (const clientId of this.#consumersByClientId.keys()) {
+      for (const authority of ["input", "focus", "geometry"] as const)
+        this.#authority.release(clientId, authority);
+    }
+    this.#completedHandoffs.clear();
+    this.#publishAuthority();
+  }
+
   noteControlExit(): void {
     this.#trustedInventoryRuntimeSessionId = null;
+    this.#trustedInventoryEpoch += 1;
     const retention = this.#retention;
     this.#retention = null;
     this.#startPromise = null;
@@ -1833,6 +1894,7 @@ class SessionRuntime {
     if (this.#disposed) return;
     this.#disposed = true;
     this.#trustedInventoryRuntimeSessionId = null;
+    this.#trustedInventoryEpoch += 1;
     const consumers = [...this.#consumers];
     await Promise.allSettled(consumers.map((consumer) => consumer.close()));
     this.#clearController();

package/packages/daemon/src/terminal/session-runtime/semantic-mutation-executor.ts

@@ -509,7 +509,9 @@ export class SessionSemanticMutationExecutor {
     if (this.#observability.enabled && this.#options.traceAuthority) {
       try {
         trace = this.#observability.beginTrace(
-          intent.verb === "workspace.pane.select" ? "window-switch" : "semantic-mutation",
+          intent.verb === "workspace.pane.select" || intent.verb === "workspace.window.link.select"
+            ? "window-switch"
+            : "semantic-mutation",
           this.#options.traceAuthority,
           operationId,
         );

package/packages/daemon/src/tui/mirror/dialog-model.ts

@@ -16,6 +16,8 @@
  * Rows span the box interior in x: [left+1, left+width-1).
  */
 import { fuzzyFilter } from "../team/fuzzy.ts";
+import { wrapText } from "./terminal-text.ts";
+export { wrapText } from "./terminal-text.ts";
 
 // ── Specs ────────────────────────────────────────────────────────────────────
 
@@ -176,38 +178,6 @@ export function dialogPos(
   };
 }
 
-/** PURE — greedy word-wrap for the confirm body (never returns empty for
- *  non-empty text; words longer than the width hard-break). */
-export function wrapText(text: string, width: number): string[] {
-  if (width <= 0) return [text];
-  const out: string[] = [];
-  for (const para of text.split("\n")) {
-    let line = "";
-    for (const word of para.split(/\s+/).filter(Boolean)) {
-      if (line.length === 0) {
-        let w = word;
-        while (w.length > width) {
-          out.push(w.slice(0, width));
-          w = w.slice(width);
-        }
-        line = w;
-      } else if (line.length + 1 + word.length <= width) {
-        line += ` ${word}`;
-      } else {
-        out.push(line);
-        let w = word;
-        while (w.length > width) {
-          out.push(w.slice(0, width));
-          w = w.slice(width);
-        }
-        line = w;
-      }
-    }
-    if (line.length > 0 || para.length === 0) out.push(line);
-  }
-  return out.length > 0 ? out : [""];
-}
-
 /** PURE — the interior text width of the box (borders + 1-cell padding each side). */
 export function dialogInnerW(width: number): number {
   return width - 4;

package/packages/daemon/src/tui/mirror/runtime/application-daemon-authority-owner.ts

@@ -20,6 +20,7 @@ import {
   openSshDaemonTransport,
   probeSshDaemonIdentity,
 } from "../../../lib/ssh-daemon-transport.ts";
+import { tuiPerfMark } from "./application-performance-log.ts";
 
 type Connection = Awaited<ReturnType<typeof openSshDaemonTransport>>;
 type Listener = (generation: string | null) => void;
@@ -136,6 +137,13 @@ export function createApplicationDaemonAuthority(
   const statusListeners = new Set<() => void>();
   const updateStatus = (next: FleetConnectionStatus) => {
     diagnostic = Object.freeze(next);
+    tuiPerfMark("machine-connection-status", {
+      machine: label,
+      ...next,
+      instanceId: remote?.instanceId ?? null,
+      pid: remote?.pid ?? null,
+      port: remote?.port ?? null,
+    });
     for (const listener of statusListeners) {
       try {
         listener();

package/packages/daemon/src/tui/mirror/runtime/application-home-fleet.ts

@@ -80,6 +80,22 @@ export function projectHomeFleet(
       machine.state !== "ready" ||
       !groups.find((group) => group.machineId === machine.id)?.available,
   );
+  const activityPending = (machineId: string) => {
+    const observation = groups.find((group) => group.machineId === machineId)?.observation;
+    // A live observation whose binding is no longer available belongs to a
+    // retiring endpoint; its replacement must publish before it is current.
+    return !observation || observation.phase === "loading" || observation.phase === "live";
+  };
+  const coverageNotes = missing.map((machine) => {
+    if (machine.state !== "ready") return `${machine.label}: ${machine.state}`;
+    const observation = groups.find((group) => group.machineId === machine.id)?.observation;
+    const status = activityPending(machine.id)
+      ? "loading agent activity"
+      : observation?.phase === "partial"
+        ? "agent activity incomplete"
+        : "agent activity unavailable";
+    return `${machine.label}: connected; ${status}`;
+  });
   const query = filter.query?.trim().toLocaleLowerCase() ?? "";
   const matching = query
     ? rows.filter((row) =>
@@ -98,7 +114,8 @@ export function projectHomeFleet(
     phase: missing.length
       ? rows.length || observedSessions
         ? "partial"
-        : machines.some((machine) => machine.state === "connecting")
+        : machines.some((machine) => machine.state === "connecting") ||
+            missing.some((machine) => machine.state === "ready" && activityPending(machine.id))
           ? "loading"
           : "unavailable"
       : "live",
@@ -111,7 +128,7 @@ export function projectHomeFleet(
     refreshingSessionKeys: [],
     unavailableSessionKeys: [...unavailable],
     note: missing.length
-      ? `${missing.map((machine) => `${machine.label}: ${machine.state === "ready" ? "partial observations" : machine.state}`).join(" · ")} · unavailable rows show last observed activity`
+      ? `${coverageNotes.join(" · ")}${unavailable.size > 0 ? " · unavailable rows show last observed activity" : ""}`
       : rows.length === 0 && filter.attentionOnly
         ? "No agents need attention in this view."
         : null,

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

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util";
 import { machineResourceKey } from "@tmux-ide/core";
 import {
   applicationMachineAuthorityManager,
@@ -69,7 +70,7 @@ export function createApplicationMachineAgents(options: {
   let started = false;
   const publish = () => {
     if (disposed) return;
-    snapshot = Object.freeze(
+    const next = Object.freeze(
       catalog.groups.map((group) => {
         const entry = entries.get(group.id);
         const current = !!entry && entry.binding === bindingFor(entry.handle);
@@ -95,6 +96,10 @@ export function createApplicationMachineAgents(options: {
         });
       }),
     );
+    // Fresh authority checks above still run on every observation. Identical
+    // presentation data must not invalidate the Home/sidebar/tab subscribers.
+    if (isDeepStrictEqual(snapshot, next)) return;
+    snapshot = next;
     for (const listener of listeners) {
       try {
         listener(snapshot);