tmux-ide 2.9.2 → 2.9.4

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/integrations/claude-agent-teams.ts

@@ -0,0 +1,334 @@
+/**
+ * Claude Code agent teams — opt-out enablement in the user's Claude settings.
+ *
+ * Agent teams let one Claude Code session spawn teammates; with
+ * `teammateMode: "auto"` Claude puts them in split panes when it runs inside
+ * tmux (in-process elsewhere), which is exactly what tmux-ide shows and
+ * routes. The installer enables this by default and `tmux-ide integration
+ * agent-teams enable|disable|status` manages it explicitly.
+ *
+ * Rules (pure, in {@link mergeAgentTeams}):
+ * - `env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` is set to "1" only when absent.
+ *   An explicit off value ("0", "false", false, 0…) is the user's opt-out: the
+ *   installer never overrides it and touches nothing else. Only an explicit
+ *   `tmux-ide integration agent-teams enable` (overrideOptOut) turns it back on.
+ * - `teammateMode: "auto"` is set only when `teammateMode` is absent.
+ * - Every other key is preserved. Nothing changed → nothing written.
+ *
+ * Writes (io) reuse the hooks integration's settings path resolution, including
+ * the `TMUX_IDE_CLAUDE_SETTINGS` override: one-time timestamped backup before
+ * the first modification, then an atomic temp-file + rename. Invalid JSON is
+ * reported and never rewritten.
+ */
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  statSync,
+  copyFileSync,
+  unlinkSync,
+  writeFileSync,
+  accessSync,
+  constants,
+} from "node:fs";
+import { basename, delimiter, dirname, join } from "node:path";
+import { resolveRuntimeNamespace, runtimeOwnedPath } from "../../lib/runtime-namespace.ts";
+
+export const AGENT_TEAMS_ENV = "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS";
+export const DEFAULT_TEAMMATE_MODE = "auto";
+const BACKUP_INFIX = ".tmux-ide-backup-";
+
+type Settings = Record<string, unknown>;
+
+export type AgentTeamsSetting = "enabled" | "disabled-by-user" | "not-configured";
+
+/** PURE — an explicit off value is the user's opt-out. */
+export function isOptOut(value: unknown): boolean {
+  if (value === false || value === 0) return true;
+  return typeof value === "string" && /^\s*(0|false|off|no)\s*$/iu.test(value);
+}
+
+function envOf(settings: Settings): Record<string, unknown> | undefined {
+  const env = settings.env;
+  if (env === undefined) return undefined;
+  if (!env || typeof env !== "object" || Array.isArray(env))
+    throw new Error("settings env must be an object");
+  return env as Record<string, unknown>;
+}
+
+/** PURE — how the settings currently stand for agent teams. */
+export function agentTeamsSetting(settings: Settings): AgentTeamsSetting {
+  const value = envOf(settings)?.[AGENT_TEAMS_ENV];
+  if (value === undefined) return "not-configured";
+  return isOptOut(value) ? "disabled-by-user" : "enabled";
+}
+
+export interface AgentTeamsMerge {
+  readonly settings: Settings;
+  /** Human-readable `key=value` list of what was set; empty when unchanged. */
+  readonly changes: readonly string[];
+  readonly setting: AgentTeamsSetting;
+}
+
+/**
+ * PURE — enable agent teams without overriding anything the user chose, unless
+ * `overrideOptOut` (the user explicitly asked to enable) replaces their "0".
+ */
+export function mergeAgentTeams(
+  settings: Settings,
+  { overrideOptOut = false }: { readonly overrideOptOut?: boolean } = {},
+): AgentTeamsMerge {
+  const setting = agentTeamsSetting(settings);
+  if (setting === "disabled-by-user" && !overrideOptOut) return { settings, changes: [], setting };
+  const changes: string[] = [];
+  let next: Settings = settings;
+  if (setting !== "enabled") {
+    next = { ...next, env: { ...(envOf(settings) ?? {}), [AGENT_TEAMS_ENV]: "1" } };
+    changes.push(`env.${AGENT_TEAMS_ENV}=1`);
+  }
+  if (!("teammateMode" in settings)) {
+    next = { ...next, teammateMode: DEFAULT_TEAMMATE_MODE };
+    changes.push(`teammateMode=${DEFAULT_TEAMMATE_MODE}`);
+  }
+  return { settings: next, changes, setting: "enabled" };
+}
+
+/** PURE — record an explicit opt-out ("0"), which later enables respect. */
+export function disableAgentTeams(settings: Settings): AgentTeamsMerge {
+  if (agentTeamsSetting(settings) === "disabled-by-user")
+    return { settings, changes: [], setting: "disabled-by-user" };
+  return {
+    settings: { ...settings, env: { ...(envOf(settings) ?? {}), [AGENT_TEAMS_ENV]: "0" } },
+    changes: [`env.${AGENT_TEAMS_ENV}=0`],
+    setting: "disabled-by-user",
+  };
+}
+
+export interface AgentTeamsPaths {
+  /** Claude Code's user settings file. */
+  readonly settingsPath: string;
+  /** Claude Code's home (~/.claude); its presence means Claude is installed. */
+  readonly claudeDir: string;
+}
+
+export function agentTeamsPaths(): AgentTeamsPaths {
+  const namespace = resolveRuntimeNamespace();
+  return { settingsPath: namespace.claudeSettingsPath, claudeDir: namespace.claudeDir };
+}
+
+/** `claude` on PATH, without spawning anything. */
+export function claudeOnPath(path = process.env.PATH ?? ""): boolean {
+  return path
+    .split(delimiter)
+    .filter(Boolean)
+    .some((dir) => {
+      try {
+        accessSync(join(dir, "claude"), constants.X_OK);
+        return statSync(join(dir, "claude")).isFile();
+      } catch {
+        return false;
+      }
+    });
+}
+
+export class InvalidClaudeSettingsError extends Error {}
+
+function readSettings(path: string): { settings: Settings; exists: boolean } {
+  if (!existsSync(path)) return { settings: {}, exists: false };
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      throw new Error("not an object");
+    envOf(parsed as Settings);
+    return { settings: parsed as Settings, exists: true };
+  } catch {
+    throw new InvalidClaudeSettingsError(
+      `${path} is not valid settings JSON — fix or move it, then retry`,
+    );
+  }
+}
+
+/** Existing one-time backup, if tmux-ide already made one for this file. */
+function existingBackup(settingsPath: string): string | null {
+  const dir = dirname(settingsPath);
+  const prefix = `${basename(settingsPath)}${BACKUP_INFIX}`;
+  try {
+    const found = readdirSync(dir).find((name) => name.startsWith(prefix));
+    return found ? join(dir, found) : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeSettings(path: string, settings: Settings, exists: boolean): string | null {
+  mkdirSync(dirname(path), { recursive: true });
+  let backup: string | null = null;
+  if (exists) {
+    backup = existingBackup(path);
+    if (!backup) {
+      const stamp = new Date()
+        .toISOString()
+        .replace(/[-:]/gu, "")
+        .replace(/\.\d+Z$/u, "Z");
+      backup = `${path}${BACKUP_INFIX}${stamp}`;
+      copyFileSync(path, backup);
+    }
+  }
+  const temporary = join(dirname(path), `.${basename(path)}.tmux-ide-${process.pid}.tmp`);
+  try {
+    writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}\n`, { mode: 0o600 });
+    if (exists) chmodSync(temporary, statSync(path).mode & 0o777);
+    renameSync(temporary, path);
+  } catch (error) {
+    try {
+      unlinkSync(temporary);
+    } catch {
+      /* already renamed or never written */
+    }
+    throw error;
+  }
+  return backup;
+}
+
+export interface AgentTeamsResult {
+  readonly action:
+    | "enabled"
+    | "disabled"
+    | "unchanged"
+    | "disabled-by-user"
+    | "skipped"
+    | "invalid";
+  readonly settingsPath: string;
+  readonly changes: readonly string[];
+  readonly backup: string | null;
+  readonly claudeDetected: boolean;
+  readonly message: string;
+}
+
+function detected(paths: AgentTeamsPaths, onPath: () => boolean): boolean {
+  return existsSync(paths.claudeDir) || onPath();
+}
+
+function guarded(paths: AgentTeamsPaths | undefined): AgentTeamsPaths {
+  if (!paths && resolveRuntimeNamespace().development)
+    throw new Error("Development agent-teams changes require explicit fixture paths");
+  const resolved = paths ?? agentTeamsPaths();
+  runtimeOwnedPath(resolved.settingsPath);
+  return resolved;
+}
+
+/** Enable agent teams when Claude Code is installed and the user hasn't opted out. */
+export function enableClaudeAgentTeams(
+  paths?: AgentTeamsPaths,
+  onPath: () => boolean = () => claudeOnPath(),
+  { overrideOptOut = false }: { readonly overrideOptOut?: boolean } = {},
+): AgentTeamsResult {
+  const resolved = guarded(paths);
+  const { settingsPath } = resolved;
+  const base = { settingsPath, changes: [], backup: null } as const;
+  if (!detected(resolved, onPath))
+    return {
+      ...base,
+      action: "skipped",
+      claudeDetected: false,
+      message: `Claude Code not found (no ${resolved.claudeDir}, no claude on PATH); agent teams not configured.`,
+    };
+  let read: ReturnType<typeof readSettings>;
+  try {
+    read = readSettings(settingsPath);
+  } catch (error) {
+    return { ...base, action: "invalid", claudeDetected: true, message: (error as Error).message };
+  }
+  const merged = mergeAgentTeams(read.settings, { overrideOptOut });
+  if (merged.setting === "disabled-by-user")
+    return {
+      ...base,
+      action: "disabled-by-user",
+      claudeDetected: true,
+      message:
+        `Claude Code agent teams are disabled by user in ${settingsPath} (${AGENT_TEAMS_ENV}); ` +
+        "left unchanged. Enable explicitly: tmux-ide integration agent-teams enable",
+    };
+  if (merged.changes.length === 0)
+    return {
+      ...base,
+      action: "unchanged",
+      claudeDetected: true,
+      message: `Claude Code agent teams already enabled in ${settingsPath}.`,
+    };
+  const backup = writeSettings(settingsPath, merged.settings, read.exists);
+  return {
+    settingsPath,
+    changes: merged.changes,
+    backup,
+    action: "enabled",
+    claudeDetected: true,
+    message:
+      `Enabled Claude Code agent teams in ${settingsPath} (${merged.changes.join(", ")}` +
+      `${backup ? `; backup: ${backup}` : ""}). Disable: tmux-ide integration agent-teams disable`,
+  };
+}
+
+/** Record the user's opt-out so neither the installer nor `enable` turns it back on silently. */
+export function disableClaudeAgentTeams(paths?: AgentTeamsPaths): AgentTeamsResult {
+  const resolved = guarded(paths);
+  const { settingsPath } = resolved;
+  const base = { settingsPath, changes: [], backup: null, claudeDetected: true } as const;
+  let read: ReturnType<typeof readSettings>;
+  try {
+    read = readSettings(settingsPath);
+  } catch (error) {
+    return { ...base, action: "invalid", message: (error as Error).message };
+  }
+  const next = disableAgentTeams(read.settings);
+  if (next.changes.length === 0)
+    return {
+      ...base,
+      action: "unchanged",
+      message: `Claude Code agent teams already disabled in ${settingsPath}.`,
+    };
+  const backup = writeSettings(settingsPath, next.settings, read.exists);
+  return {
+    ...base,
+    changes: next.changes,
+    backup,
+    action: "disabled",
+    message:
+      `Disabled Claude Code agent teams in ${settingsPath} (${next.changes.join(", ")}` +
+      `${backup ? `; backup: ${backup}` : ""}). Re-enable: tmux-ide integration agent-teams enable`,
+  };
+}
+
+export interface AgentTeamsStatus {
+  readonly settingsPath: string;
+  readonly claudeDetected: boolean;
+  readonly setting: AgentTeamsSetting | "invalid-settings";
+  readonly teammateMode: string | null;
+}
+
+export function claudeAgentTeamsStatus(
+  paths: AgentTeamsPaths = agentTeamsPaths(),
+  onPath: () => boolean = () => claudeOnPath(),
+): AgentTeamsStatus {
+  const claudeDetected = detected(paths, onPath);
+  try {
+    const { settings } = readSettings(paths.settingsPath);
+    const mode = settings.teammateMode;
+    return {
+      settingsPath: paths.settingsPath,
+      claudeDetected,
+      setting: agentTeamsSetting(settings),
+      teammateMode: typeof mode === "string" ? mode : null,
+    };
+  } catch {
+    return {
+      settingsPath: paths.settingsPath,
+      claudeDetected,
+      setting: "invalid-settings",
+      teammateMode: null,
+    };
+  }
+}

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);