tmux-ide 2.9.2 → 2.9.4

package/packages/daemon/dist/terminal/session-runtime/registry.js

@@ -137,6 +137,11 @@ export class SessionRuntimeRegistry {
         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();
@@ -171,6 +176,7 @@ export class SessionRuntimeRegistry {
         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`);
         }
@@ -213,6 +219,7 @@ export class SessionRuntimeRegistry {
                 throw new Error(`SessionRuntime ${session} is attached to a different tmux identity`);
             }
             signal?.throwIfAborted();
+            await abortable(this.#mirror.verifyRegisteredWindows(), signal);
             runtime.qualifyTrustedInventory(runtimeSessionId);
         }
         finally {
@@ -235,24 +242,28 @@ export class SessionRuntimeRegistry {
         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, token) {
         if (this.#disposed)
             return false;
-        const runtime = this.#trustedInventoryTokens.get(token);
-        return (runtime !== undefined &&
-            this.#sessions.get(session) === runtime &&
-            runtime.trustedInventoryQualified());
+        const candidate = this.#trustedInventoryTokens.get(token);
+        return (candidate !== undefined &&
+            this.#sessions.get(session) === candidate.runtime &&
+            candidate.runtime.trustedInventoryEpoch === candidate.epoch &&
+            candidate.runtime.trustedInventoryQualified());
     }
     hasProofQualifiedInventory(session) {
         return ((this.#sessions.get(session)?.trustedInventoryQualified() ?? false) &&
@@ -269,6 +280,14 @@ export class SessionRuntimeRegistry {
             return Promise.reject(new Error("Session runtime disposed"));
         return this.#mirror.executeWindowLinkAction(session, request);
     }
+    /** Resolve pending ownership before an asynchronous owner-authorized mutation. */
+    async verifyWindowOwnership() {
+        await this.#mirror.verifyRegisteredWindows();
+    }
+    /** Install the bounded registered-session membership reader. */
+    setRegisteredWindowReader(reader) {
+        return this.#mirror.setRegisteredWindowReader(reader);
+    }
     /** Retire one no-longer-registered session without disturbing siblings. */
     async retireSession(session) {
         const runtime = this.#sessions.get(session);
@@ -665,6 +684,10 @@ class SessionRuntime {
     #releasedLeases = new Set();
     #disposed = false;
     #trustedInventoryRuntimeSessionId = null;
+    #trustedInventoryEpoch = 0;
+    get trustedInventoryEpoch() {
+        return this.#trustedInventoryEpoch;
+    }
     #activeCausalCellProbes = 0;
     constructor(generation, session, mirror, createControllerToken, scheduler, observability, createTraceCorrelator, nativeGeometryHysteresisMs, submitAuthorized) {
         this.generation = generation;
@@ -725,6 +748,7 @@ class SessionRuntime {
         this.#publishAuthority();
     }
     acquireAuthority(clientId, authority) {
+        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.
@@ -776,6 +800,7 @@ class SessionRuntime {
         });
     }
     acquireController(clientId) {
+        this.assertNoSharedWindow();
         this.#assertConnected(clientId);
         if (this.#controllerClientId === clientId) {
             this.#authority.updatePresence(clientId, "foreground");
@@ -836,6 +861,7 @@ class SessionRuntime {
         this.#authority.release(callerClientId, "geometry");
     }
     assertController(lease, callerClientId) {
+        this.assertNoSharedWindow();
         const parsedLease = this.#validatedLease(lease);
         if (parsedLease.generation !== this.generation ||
             parsedLease.session !== this.session ||
@@ -973,6 +999,7 @@ class SessionRuntime {
             this.#mirror.fitWindowViewport(this.session, semanticWindowId, cols, rows);
     }
     fitViewportWithAuthority(clientId, lease, cols, rows, semanticWindowId) {
+        this.assertNoSharedWindow();
         const parsed = SessionRuntimeAuthorityLeaseSchemaZ.parse(lease);
         let exact;
         try {
@@ -1016,13 +1043,16 @@ class SessionRuntime {
         return await this.#mirror.describeSession(this.session);
     }
     qualifyTrustedInventory(runtimeSessionId) {
+        this.assertNoSharedWindow();
         if (this.#disposed || !this.#retention) {
             throw new Error(`SessionRuntime ${this.session} is not retained`);
         }
         this.#trustedInventoryRuntimeSessionId = runtimeSessionId;
     }
     trustedInventoryQualified() {
-        return !this.#disposed && this.#trustedInventoryRuntimeSessionId !== null;
+        return (!this.#disposed &&
+            this.#trustedInventoryRuntimeSessionId !== null &&
+            !this.#mirror.hasSharedWindowConflict(this.session));
     }
     async describeTrustedInventory() {
         if (!this.trustedInventoryQualified()) {
@@ -1176,8 +1206,26 @@ class SessionRuntime {
         this.#authority.disconnect(consumer.clientId);
         this.#publishAuthority();
     }
+    assertNoSharedWindow() {
+        const message = this.#mirror.windowOwnershipMessage(this.session);
+        if (message) {
+            throw new SessionRuntimeControllerLeaseError("controller-conflict", message);
+        }
+    }
+    invalidateSharedWindowAuthority() {
+        this.#trustedInventoryRuntimeSessionId = null;
+        this.#trustedInventoryEpoch += 1;
+        this.#clearController();
+        for (const clientId of this.#consumersByClientId.keys()) {
+            for (const authority of ["input", "focus", "geometry"])
+                this.#authority.release(clientId, authority);
+        }
+        this.#completedHandoffs.clear();
+        this.#publishAuthority();
+    }
     noteControlExit() {
         this.#trustedInventoryRuntimeSessionId = null;
+        this.#trustedInventoryEpoch += 1;
         const retention = this.#retention;
         this.#retention = null;
         this.#startPromise = null;
@@ -1198,6 +1246,7 @@ class SessionRuntime {
             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/dist/terminal/session-runtime/semantic-mutation-executor.js

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

package/packages/daemon/dist/tui/integrations/claude-agent-teams.js

@@ -0,0 +1,264 @@
+/**
+ * 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.js";
+export const AGENT_TEAMS_ENV = "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS";
+export const DEFAULT_TEAMMATE_MODE = "auto";
+const BACKUP_INFIX = ".tmux-ide-backup-";
+/** PURE — an explicit off value is the user's opt-out. */
+export function isOptOut(value) {
+    if (value === false || value === 0)
+        return true;
+    return typeof value === "string" && /^\s*(0|false|off|no)\s*$/iu.test(value);
+}
+function envOf(settings) {
+    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;
+}
+/** PURE — how the settings currently stand for agent teams. */
+export function agentTeamsSetting(settings) {
+    const value = envOf(settings)?.[AGENT_TEAMS_ENV];
+    if (value === undefined)
+        return "not-configured";
+    return isOptOut(value) ? "disabled-by-user" : "enabled";
+}
+/**
+ * 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, { overrideOptOut = false } = {}) {
+    const setting = agentTeamsSetting(settings);
+    if (setting === "disabled-by-user" && !overrideOptOut)
+        return { settings, changes: [], setting };
+    const changes = [];
+    let next = 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) {
+    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 function agentTeamsPaths() {
+    const namespace = resolveRuntimeNamespace();
+    return { settingsPath: namespace.claudeSettingsPath, claudeDir: namespace.claudeDir };
+}
+/** `claude` on PATH, without spawning anything. */
+export function claudeOnPath(path = process.env.PATH ?? "") {
+    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) {
+    if (!existsSync(path))
+        return { settings: {}, exists: false };
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error("not an object");
+        envOf(parsed);
+        return { settings: parsed, 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) {
+    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, settings, exists) {
+    mkdirSync(dirname(path), { recursive: true });
+    let backup = 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;
+}
+function detected(paths, onPath) {
+    return existsSync(paths.claudeDir) || onPath();
+}
+function guarded(paths) {
+    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, onPath = () => claudeOnPath(), { overrideOptOut = false } = {}) {
+    const resolved = guarded(paths);
+    const { settingsPath } = resolved;
+    const base = { settingsPath, changes: [], backup: null };
+    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;
+    try {
+        read = readSettings(settingsPath);
+    }
+    catch (error) {
+        return { ...base, action: "invalid", claudeDetected: true, message: 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) {
+    const resolved = guarded(paths);
+    const { settingsPath } = resolved;
+    const base = { settingsPath, changes: [], backup: null, claudeDetected: true };
+    let read;
+    try {
+        read = readSettings(settingsPath);
+    }
+    catch (error) {
+        return { ...base, action: "invalid", message: 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 function claudeAgentTeamsStatus(paths = agentTeamsPaths(), onPath = () => claudeOnPath()) {
+    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/dist/tui/mirror/dialog-model.js

@@ -16,6 +16,8 @@
  * Rows span the box interior in x: [left+1, left+width-1).
  */
 import { fuzzyFilter } from "../team/fuzzy.js";
+import { wrapText } from "./terminal-text.js";
+export { wrapText } from "./terminal-text.js";
 // ── Constants ────────────────────────────────────────────────────────────────
 /** Box width — matches the palette so the two overlays read as one family. */
 export const DIALOG_W = 60;
@@ -66,41 +68,6 @@ export function dialogPos(termW, termH, width) {
         top: Math.max(1, Math.floor(termH / 6)),
     };
 }
-/** 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, width) {
-    if (width <= 0)
-        return [text];
-    const out = [];
-    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) {
     return width - 4;

package/packages/daemon/dist/tui/mirror/runtime/application-daemon-authority-owner.js

@@ -4,6 +4,7 @@ import { watch } from "node:fs";
 import { basename, dirname } from "node:path";
 import { getCanonicalDaemonInfoPath, isCanonicalDaemonAlive, readCanonicalDaemonInfo, } from "../../../lib/canonical-daemon.js";
 import { SshConnectionError, openSshDaemonTransport, probeSshDaemonIdentity, } from "../../../lib/ssh-daemon-transport.js";
+import { tuiPerfMark } from "./application-performance-log.js";
 const defaults = {
     readLocal: readCanonicalDaemonInfo,
     isLocalAlive: isCanonicalDaemonAlive,
@@ -97,6 +98,13 @@ export function createApplicationDaemonAuthority(dependencies = defaults) {
     const statusListeners = new Set();
     const updateStatus = (next) => {
         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/dist/tui/mirror/runtime/application-home-fleet.js

@@ -49,6 +49,23 @@ export function projectHomeFleet(catalog, groups, filter) {
     rows.sort((a, b) => a.key.localeCompare(b.key));
     const missing = machines.filter((machine) => machine.state !== "ready" ||
         !groups.find((group) => group.machineId === machine.id)?.available);
+    const activityPending = (machineId) => {
+        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) => [
@@ -65,7 +82,8 @@ export function projectHomeFleet(catalog, groups, filter) {
         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",
@@ -78,7 +96,7 @@ export function projectHomeFleet(catalog, groups, filter) {
         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/dist/tui/mirror/runtime/application-machine-agents.js

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util";
 import { machineResourceKey } from "@tmux-ide/core";
 import { applicationMachineAuthorityManager, } from "./application-machine-authority.js";
 import { createApplicationHomeAgentObserver, } from "./application-home-agent-observer.js";
@@ -29,7 +30,7 @@ export function createApplicationMachineAgents(options) {
     const publish = () => {
         if (disposed)
             return;
-        snapshot = Object.freeze(catalog.groups.map((group) => {
+        const next = Object.freeze(catalog.groups.map((group) => {
             const entry = entries.get(group.id);
             const current = !!entry && entry.binding === bindingFor(entry.handle);
             return Object.freeze({
@@ -47,6 +48,11 @@ 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);