tmux-ide 2.9.5 → 2.9.6

package/packages/daemon/dist/lib/native-tmux-interaction-observer.js

@@ -224,7 +224,9 @@ export class NativeTmuxInteractionObserver {
             this.#state("incompatible");
             return false;
         }
-        if ((this.#capability && this.#capability.serverEpoch !== capability.serverEpoch) ||
+        if ((this.#options.expectedServerEpoch !== undefined &&
+            this.#options.expectedServerEpoch !== capability.serverEpoch) ||
+            (this.#capability && this.#capability.serverEpoch !== capability.serverEpoch) ||
             (this.#cursor && this.#cursor.serverEpoch !== capability.serverEpoch)) {
             this.#state("retired");
             return false;

package/packages/daemon/dist/lib/owner-interaction-observation.js

@@ -14,6 +14,8 @@ export class OwnerInteractionObservation {
     #projector = null;
     #capability = null;
     #start = null;
+    #splitActivation = null;
+    #expectedSplitEpoch;
     #bindings = null;
     #bindingTimer = null;
     #bindingDeadline = null;
@@ -210,8 +212,50 @@ export class OwnerInteractionObservation {
     start() {
         return (this.#start ??= this.#initialize());
     }
+    /** Called only after the canonical split owner's read-only positive preflight.
+     * Ordinary start remains opt-in. A failed lazy reader is never restarted. */
+    activateForSplit(expectedEpoch) {
+        if (this.#disposed || this.#halted || !this.#options.nativeServerIdentity)
+            return Promise.resolve(false);
+        if (this.#selection === "native")
+            return Promise.resolve(this.nativeServerEpoch === expectedEpoch && this.ownedOperationSessionGuard);
+        return (this.#splitActivation ??= this.#activateForSplit(expectedEpoch));
+    }
+    async #activateForSplit(expectedEpoch) {
+        if (this.#selection === "stock") {
+            if (this.#reader)
+                return false;
+            this.#selection = "pending";
+            this.#expectedSplitEpoch = expectedEpoch;
+            this.#start = null; // Default stock start completed without creating a reader.
+        }
+        let timer;
+        try {
+            const completed = await Promise.race([
+                this.start().then(() => true),
+                new Promise((resolve) => {
+                    timer = setTimeout(() => resolve(false), 6_000);
+                }),
+            ]);
+            if (!completed) {
+                this.#halted = true;
+                this.#retireBindings(false);
+                this.#unavailable();
+                void this.#reader?.dispose().catch(() => undefined);
+            }
+            return (completed &&
+                !this.#disposed &&
+                !this.#halted &&
+                this.nativeServerEpoch === expectedEpoch &&
+                this.ownedOperationSessionGuard &&
+                this.ownedOperationPaneGuard);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
     async #initialize() {
-        if (this.#disposed || this.#selection === "stock")
+        if (this.#disposed || this.#halted || this.#selection === "stock")
             return;
         const factory = this.#options.readerFactory ?? ((options) => new NativeTmuxInteractionObserver(options));
         try {
@@ -219,6 +263,7 @@ export class OwnerInteractionObservation {
                 tmuxAuthority: this.#options.tmuxAuthority,
                 nativeServerIdentity: this.#options.nativeServerIdentity,
                 enable: true,
+                expectedServerEpoch: this.#expectedSplitEpoch,
                 onEvent: (event) => this.#event(event),
             });
             await this.#reader.start();
@@ -227,7 +272,7 @@ export class OwnerInteractionObservation {
             if (this.#selection === "native")
                 this.#unavailable();
         }
-        if (this.#disposed)
+        if (this.#disposed || this.#halted)
             return;
         if (this.#selection === "pending") {
             this.#selection = "stock";

package/packages/daemon/dist/lib/pane-widget.js

@@ -35,7 +35,7 @@ export function imageMediaTypeFor(fileName) {
  * which overflows the 2,000-row mirror seed window and would silently break
  * re-detection after every reconnect. The full derivation, including the
  * ~50-column floor below which even a legal marker can be truncated, is the
- * table in apps/desktop-renderer/src/terminal/widgets/WIDGETS.md.
+ * table in docs/guides/pane-widget-protocol.md.
  *
  * Serving image bytes over a daemon route instead — which lifts this entirely —
  * is the documented follow-up.

package/packages/daemon/dist/lib/tmux-pane-editor-context.js

@@ -0,0 +1,99 @@
+import { isAbsolute, resolve } from "node:path";
+import { z } from "zod";
+import { PaneEditorContextTargetSchemaZ, WorkspacePaneCwdSchemaZ, } from "@tmux-ide/contracts";
+import { materializePaneCwd, normalizePaneCwd } from "./workspace-state.js";
+/** Constructed only by the direct, generation-fenced local tmux server owner. */
+export function createPaneEditorContextResolver(options) {
+    const generation = z.uuid().parse(options.generation);
+    return async (input, cancellation) => {
+        const target = PaneEditorContextTargetSchemaZ.parse(input);
+        // A supplied signal selects a fresh inventory read, not an existing flight.
+        const signal = cancellation
+            ? AbortSignal.any([cancellation, AbortSignal.timeout(5_000)])
+            : AbortSignal.timeout(5_000);
+        const unavailable = () => {
+            throw new Error("Selected pane editor context is unavailable");
+        };
+        const assertOwner = () => {
+            options.assertOpen();
+            signal.throwIfAborted();
+            if (target.generation !== generation)
+                unavailable();
+        };
+        assertOwner();
+        const workspace = options.registry.get(target.workspaceName);
+        if (!workspace)
+            return unavailable();
+        const { sessionName, projectDir } = workspace;
+        if (!isAbsolute(projectDir))
+            return unavailable();
+        const assertScope = () => {
+            assertOwner();
+            const current = options.registry.get(target.workspaceName);
+            if (current !== workspace ||
+                current.sessionName !== sessionName ||
+                current.projectDir !== projectDir)
+                unavailable();
+        };
+        const checkCatalog = async () => {
+            assertScope();
+            const sessions = await options.catalog();
+            assertScope();
+            const matches = sessions.filter((session) => session.liveSessionId === target.liveSessionId);
+            if (matches.length !== 1 || matches[0].sessionName !== sessionName)
+                unavailable();
+        };
+        const readPane = async () => {
+            assertScope();
+            const snapshot = await options.inventory.discoverTerminalInventory(signal);
+            assertScope();
+            const analysis = snapshot.catalog;
+            if (analysis.invalidRuntimeProof ||
+                analysis.duplicateSemanticStamp ||
+                analysis.duplicateRuntimePaneBinding)
+                unavailable();
+            const matches = snapshot.panes.filter((pane) => pane.workspaceName === target.workspaceName &&
+                pane.semanticPaneId === target.semanticPaneId);
+            if (matches.length !== 1)
+                return unavailable();
+            const pane = matches[0];
+            if (pane.sessionName !== sessionName || !pane.dir || !isAbsolute(pane.dir))
+                unavailable();
+            // Detach observations from mutable discovery/test adapters before another await.
+            return { ...pane };
+        };
+        await checkCatalog();
+        assertScope();
+        const before = await readPane();
+        assertScope();
+        await checkCatalog();
+        assertScope();
+        // Discovery already fences topology internally. This second read additionally
+        // refuses a cwd/binding change during resolution; it never retries a selection.
+        const after = await readPane();
+        assertScope();
+        for (const key of [
+            "sessionId",
+            "windowId",
+            "runtimePaneId",
+            "windowStamp",
+            "nativePaneBirthId",
+            "dir",
+        ])
+            if ((before[key] ?? null) !== (after[key] ?? null))
+                unavailable();
+        // No saved layout fallback: projectDir only expresses the live cwd as a
+        // typed project-relative value when the existing containment policy permits it.
+        const absolute = WorkspacePaneCwdSchemaZ.parse({ kind: "absolute", path: resolve(after.dir) });
+        const relative = WorkspacePaneCwdSchemaZ.safeParse(normalizePaneCwd(after.dir, projectDir));
+        const cwd = relative.success && materializePaneCwd(relative.data, projectDir) === absolute.path
+            ? relative.data
+            : absolute;
+        const directory = materializePaneCwd(cwd, projectDir);
+        // Portable project-relative paths accept both separator styles. A literal
+        // backslash on POSIX must not silently name a different local directory.
+        if (!directory || directory !== absolute.path)
+            return unavailable();
+        return Object.freeze({ ...target, cwd: Object.freeze(cwd), directory });
+    };
+}

package/packages/daemon/dist/lib/tmux-server-agent-admission.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { TerminalAttachmentSemanticPaneIdSchemaZ } from "@tmux-ide/contracts";
+import { agentIdForPaneStamp, fallbackPaneId, } from "../command-center/resources/application-shell.js";
+export const observedAgentSchema = z
+    .object({
+    observedPaneId: z.string().min(1).max(512),
+    observedAgentId: z.string().min(1).max(512),
+})
+    .strict();
+/** Fresh daemon facts only. No label/index fallback and no client-supplied native IDs. */
+export async function captureAgentAdmission(run, session, observed) {
+    const scan = async () => {
+        const raw = await run([
+            "list-panes",
+            "-s",
+            "-t",
+            session.id,
+            "-F",
+            "#{session_id}\t#{window_id}\t#{pane_id}\t#{pane_birth_id}\t#{@tmux_ide_pane_id}",
+        ]);
+        if (Buffer.byteLength(raw) > 1024 * 1024)
+            throw new Error("Agent inventory exceeds admission bounds");
+        const rows = raw
+            .replace(/\n+$/u, "")
+            .split("\n")
+            .map((line) => {
+            const fields = line.split("\t");
+            const [id, window, pane, birth, stamp] = fields;
+            if (fields.length !== 5 ||
+                id !== session.id ||
+                !/^@\d+$/.test(window) ||
+                !/^%\d+$/.test(pane) ||
+                !/^[1-9]\d*$/.test(birth))
+                throw new Error("Agent native identity is unavailable");
+            return { window: window, pane: pane, birth: birth, stamp: stamp };
+        });
+        if (rows.length > 512)
+            throw new Error("Agent inventory exceeds admission bounds");
+        return rows;
+    };
+    const initial = await scan();
+    const candidates = initial.filter((row) => {
+        const id = row.stamp === ""
+            ? fallbackPaneId({ name: session.name, runtimeSessionId: session.id }, { runtimePaneId: row.pane })
+            : row.stamp;
+        return id === observed.observedPaneId && agentIdForPaneStamp(id) === observed.observedAgentId;
+    });
+    if (candidates.length !== 1)
+        throw new Error("Observed agent is no longer unique");
+    const captured = candidates[0];
+    if (captured.stamp &&
+        (!TerminalAttachmentSemanticPaneIdSchemaZ.safeParse(captured.stamp).success ||
+            initial.filter((r) => r.stamp === captured.stamp).length !== 1))
+        throw new Error("Observed agent stamp is ambiguous");
+    return {
+        async verify(promoted) {
+            const rows = await scan();
+            const matching = rows.filter((row) => row.pane === captured.pane);
+            if (matching.length !== 1 ||
+                matching[0].birth !== captured.birth ||
+                matching[0].window !== captured.window)
+                throw new Error("Observed agent lifetime changed");
+            const current = matching[0];
+            if (captured.stamp && current.stamp !== captured.stamp)
+                throw new Error("Observed agent stamp changed");
+            if (!promoted && current.stamp !== captured.stamp)
+                throw new Error("Observed agent stamp changed");
+            if (promoted &&
+                (!TerminalAttachmentSemanticPaneIdSchemaZ.safeParse(current.stamp).success ||
+                    rows.filter((row) => row.stamp === current.stamp).length !== 1))
+                throw new Error("Promoted agent identity is unavailable");
+            return current.stamp;
+        },
+    };
+}

package/packages/daemon/dist/lib/tmux-server-owner.js

@@ -1,3 +1,7 @@
+import { shellEscape } from "./shell.js";
+import { createNativeSplitCapabilityProbe, createNativeSplitReadiness, } from "./native-split-capability.js";
+import { executeCanonicalSplitMutation } from "./canonical-split-mutation.js";
+import { createGuardedNativeSplitResize } from "./guarded-native-split-resize.js";
 import { execFileSync } from "node:child_process";
 import { requireSupportedTmuxVersion } from "./tmux-version.js";
 import { PaneSourceDiscovery } from "./pane-source-discovery.js";
@@ -10,8 +14,11 @@ import { PaneSourceCredentialAuthority, STARTUP_PANE_CREDENTIAL_TIMEOUT_MS, } fr
 import { createNativeTmuxSessionCreator } from "./tmux-server-session-create.js";
 import { createTmuxSessionMutationFence } from "./tmux-session-mutation-fence.js";
 import { createNativeTmuxSessionOpener } from "./tmux-server-session-open.js";
+import { observedAgentSchema } from "./tmux-server-agent-admission.js";
+import { createPaneEditorContextResolver } from "./tmux-pane-editor-context.js";
 import { createHash, randomUUID } from "node:crypto";
-import { WorkspaceIdSchemaZ } from "@tmux-ide/contracts";
+import { WorkspaceIdSchemaZ, WindowLinkTargetSchemaZ, } from "@tmux-ide/contracts";
+import { WindowSplitLayoutUnavailable } from "../terminal/mirror/window-split-authority.js";
 import { mkdirSync } from "node:fs";
 import { z } from "zod";
 import { isVisibleFleetSession } from "../command-center/discovery.js";
@@ -51,14 +58,26 @@ export function createNativeTmuxServerCatalog(workspaceRegistry, run, assertOpen
     return async () => {
         assertOpen();
         const raw = await run([
-            "list-panes",
-            "-a",
+            "-N",
+            "if-shell",
             "-F",
-            "#{pid}\t#{session_id}\t#{session_created}\t#{session_name}\t#{pane_id}\t#{session_path}",
+            "#{==:#{server_sessions},0}",
+            "display-message -p 'tmux-ide-empty-catalog-v1'",
+            [
+                "list-panes",
+                "-a",
+                "-F",
+                "#{pid}\t#{session_id}\t#{session_created}\t#{session_name}\t#{pane_id}\t#{session_path}",
+            ]
+                .map(shellEscape)
+                .join(" "),
         ], AbortSignal.timeout(2_000));
         assertOpen();
         const rows = new Map();
-        for (const line of raw.trim().split("\n")) {
+        // Only the successful server-side zero-session branch proves emptiness.
+        // Command errors, unsupported formats and unwitnessed blank output stay failures.
+        const lines = raw.trim() === "tmux-ide-empty-catalog-v1" ? [] : raw.trim().split("\n");
+        for (const line of lines) {
             const [pid, id, created, name, pane, dir] = line.split("\t");
             if (!pid ||
                 !/^\d+$/.test(pid) ||
@@ -207,8 +226,23 @@ export async function createNativeTmuxServerOwner(options) {
                     throw new Error("Interaction target lifetime is no longer current");
             },
             resolveSession: (name) => workspaceRegistry.get(name)?.sessionName ?? null,
-            execute: (operationId, intent, timing, execution) => {
+            execute: (operationId, intent, timing, execution, authorizeBeforeEffect) => {
                 assertOpen();
+                if (intent.verb === "workspace.window.split.resize")
+                    return executeCanonicalSplitMutation({
+                        generation,
+                        registry: sessionRuntimeRegistry,
+                        resolveSession: (name) => workspaceRegistry.get(name)?.sessionName ?? null,
+                        runNative: createGuardedNativeSplitResize({
+                            observation: () => observationSelector,
+                            runPinnedTmux: generationRun,
+                        }),
+                    }, operationId, intent, () => {
+                        assertOpen();
+                        if (!authorizeBeforeEffect)
+                            throw new Error("Missing execution authorization");
+                        authorizeBeforeEffect();
+                    });
                 if (intent.verb === "workspace.pane.read")
                     return multiplexer.readPane(operationId, intent, execution);
                 if (intent.verb === "workspace.window.link.select" ||
@@ -229,6 +263,15 @@ export async function createNativeTmuxServerOwner(options) {
             traceAuthority: { generation, incarnation: null },
         },
         mirror: {
+            splitLayoutEpoch: () => observationSelector.nativeServerEpoch,
+            splitLayoutPrepare: createNativeSplitReadiness({
+                observation: () => observationSelector ?? null,
+                runPinnedTmux: generationRun,
+            }),
+            splitLayoutCapability: createNativeSplitCapabilityProbe({
+                observation: () => observationSelector ?? null,
+                runPinnedTmux: generationRun,
+            }),
             createOwnedViewerAdapter: createOwnedViewerAdapterFactory({
                 environmentId: options.environmentId,
                 serverScope: { serverId: options.serverId, generation },
@@ -359,6 +402,13 @@ export async function createNativeTmuxServerOwner(options) {
         terminalInventoryRuntime.invalidate();
         return result;
     };
+    const resolvePaneEditorContext = createPaneEditorContextResolver({
+        generation,
+        assertOpen,
+        registry: workspaceRegistry,
+        catalog,
+        inventory: terminalInventoryRuntime,
+    });
     const multiplexerBackend = {
         mutate: async (...args) => {
             assertOpen();
@@ -435,8 +485,32 @@ export async function createNativeTmuxServerOwner(options) {
     return {
         serverId: options.serverId,
         generation,
+        resolvePaneEditorContext,
         catalog,
+        readWindowSplitLayout: async (workspaceName, input) => {
+            assertOpen();
+            const target = WindowLinkTargetSchemaZ.parse(input);
+            const sessions = await catalog();
+            assertOpen();
+            const sessionName = workspaceRegistry.get(workspaceName)?.sessionName;
+            if (!sessionName ||
+                !sessions.some((row) => row.sessionName === sessionName && row.liveSessionId === target.liveSessionId))
+                throw new WindowSplitLayoutUnavailable();
+            const resource = await sessionRuntimeRegistry.readWindowSplitLayout(sessionName, target);
+            assertOpen();
+            return resource;
+        },
         openSession,
+        openAgent: async (liveSessionId, observed) => {
+            const target = observedAgentSchema.parse(observed);
+            await catalog();
+            try {
+                return await sessionOpener.openAgent(liveSessionId, target);
+            }
+            finally {
+                terminalInventoryRuntime.invalidate();
+            }
+        },
         createSession: sessionCreator.createSession,
         createSessionPane: async (liveSessionId, request) => {
             assertOpen();

package/packages/daemon/dist/lib/tmux-server-session-open.js

@@ -1,3 +1,4 @@
+import { captureAgentAdmission, observedAgentSchema, } from "./tmux-server-agent-admission.js";
 import { randomUUID } from "node:crypto";
 import { WorkspaceCatalogLiveSessionIdSchemaZ } from "@tmux-ide/contracts";
 import { liveSessionIdForNativeIdentity } from "../terminal/protocol/live-session-identity.js";
@@ -15,15 +16,16 @@ export function createNativeTmuxSessionOpener(options) {
         if (disposed)
             throw new Error("Session admission is retired");
     };
-    const open = async (liveSessionId) => {
+    const open = async (liveSessionId, observed) => {
         assertOpen();
         const records = await options.run([
             "list-sessions",
             "-F",
             "#{pid}\t#{session_id}\t#{session_created}\t#{session_name}",
         ]);
+        // The final field is an exact session identity; spaces are valid name bytes.
         const matches = records
-            .trim()
+            .replace(/\n+$/u, "")
             .split("\n")
             .map((line) => line.split("\t"))
             .filter(([pid, id, created, name]) => pid &&
@@ -59,6 +61,10 @@ export function createNativeTmuxSessionOpener(options) {
                 throw new Error("Selected live tmux session changed during admission");
             return output;
         };
+        const agent = observed
+            ? await captureAgentAdmission(run, { id: nativeSessionId, name: name }, observed)
+            : null;
+        await agent?.verify(false);
         const promotion = new WorkspacePromotionAuthority({
             daemonInstanceId: options.generation,
             registry: options.registry,
@@ -71,7 +77,12 @@ export function createNativeTmuxSessionOpener(options) {
                 intent: { sessionId: fleetSessionIdForName(name) },
             });
             await run(["display-message", "-p", "-t", nativeSessionId, "#{session_id}"]);
-            return { workspaceName: result.resource.workspaceName, liveSessionId };
+            const semanticPaneId = await agent?.verify(true);
+            return {
+                workspaceName: result.resource.workspaceName,
+                liveSessionId,
+                ...(semanticPaneId ? { semanticPaneId } : {}),
+            };
         }
         finally {
             await promotion.dispose();
@@ -93,6 +104,25 @@ export function createNativeTmuxSessionOpener(options) {
             tail = operation.catch(() => { });
             return operation;
         },
+        openAgent(liveSessionId, input) {
+            WorkspaceCatalogLiveSessionIdSchemaZ.parse(liveSessionId);
+            const observed = observedAgentSchema.parse(input);
+            assertOpen();
+            if (pending.size >= 16)
+                throw new Error("Session admission capacity reached");
+            const key = randomUUID();
+            const operation = tail
+                .then(async () => {
+                const result = await open(liveSessionId, observed);
+                if (!result.semanticPaneId)
+                    throw new Error("Agent admission returned no target");
+                return { ...result, semanticPaneId: result.semanticPaneId };
+            })
+                .finally(() => pending.delete(key));
+            pending.set(key, operation);
+            tail = operation.catch(() => { });
+            return operation;
+        },
         async dispose() {
             disposed = true;
             await tail;

package/packages/daemon/dist/lib/tui-binary.js

@@ -30,7 +30,6 @@ export const TUI_DOWNLOAD_TIMEOUT_MS = 30_000;
 const MAX_CHECKSUM_MANIFEST_BYTES = 4 * 1024;
 const SUPPORTED = {
     "darwin-arm64": "darwin-arm64",
-    "darwin-x64": "darwin-x64",
     "linux-x64": "linux-x64",
     "linux-arm64": "linux-arm64",
 };

package/packages/daemon/dist/lib/workspace-multiplexer-verbs.js

@@ -628,6 +628,8 @@ export class WorkspaceMultiplexerAuthority {
             workspaceName: intent.workspaceName,
         };
         switch (intent.verb) {
+            case "workspace.window.split.resize":
+                throw new WorkspaceMultiplexerError("workspace_unavailable");
             case "workspace.window.link.select":
             case "workspace.window.link.unlink":
                 throw new WorkspaceMultiplexerError("workspace_unavailable", {

package/packages/daemon/dist/lib/workspace-state.js

@@ -622,7 +622,7 @@ function requireProjectRoot(projectRoot) {
         throw new Error("workspace project root must be absolute");
     return resolve(root);
 }
-function normalizePaneCwd(cwd, projectRoot) {
+export function normalizePaneCwd(cwd, projectRoot) {
     if (cwd === null)
         return null;
     const absolutePath = resolve(projectRoot, cwd);
@@ -633,7 +633,7 @@ function normalizePaneCwd(cwd, projectRoot) {
         ? { kind: "project-relative", path: portablePath || "." }
         : { kind: "absolute", path: absolutePath };
 }
-function materializePaneCwd(cwd, projectRoot) {
+export function materializePaneCwd(cwd, projectRoot) {
     if (!cwd)
         return null;
     if (cwd.kind === "absolute")

package/packages/daemon/dist/native/TmuxIdeNotifier.app/Contents/Info.plist

@@ -21,9 +21,9 @@
   <key>CFBundlePackageType</key>
   <string>APPL</string>
   <key>CFBundleShortVersionString</key>
-  <string>2.9.5</string>
+  <string>2.9.6</string>
   <key>CFBundleVersion</key>
-  <string>2.9.5</string>
+  <string>2.9.6</string>
   <key>LSMinimumSystemVersion</key>
   <string>11.0</string>
   <key>LSUIElement</key>

package/packages/daemon/dist/native/TmuxIdeNotifier.app/Contents/_CodeSignature/CodeResources

@@ -10,7 +10,7 @@
 		</data>
 		<key>Resources/Assets.car</key>
 		<data>
-		LkIDt8zENP1qaa4Np7MKFvpCNtw=
+		EvwqetqXdPImCl5x7nS2kIPD49Y=
 		</data>
 	</dict>
 	<key>files2</key>
@@ -26,7 +26,7 @@
 		<dict>
 			<key>hash2</key>
 			<data>
-			x/5GhMc3oN6TS2XQV90W/AIHsGC3fBG0KZ/AD8bX6yQ=
+			SkyYNOjv6tCr/MP0BYaswjWbcppNxwnvXBYKtGTpF4w=
 			</data>
 		</dict>
 	</dict>

package/packages/daemon/dist/native/tmux/darwin-arm64/manifest.json

@@ -18,6 +18,10 @@
     {
       "patch": "control-output-barriers.patch",
       "patchSha256": "00ce678017ce94fd8ca1374b956d8db5cc4f6cdbe1309eddceed8fddb1adf6a8"
+    },
+    {
+      "patch": "split-resize.patch",
+      "patchSha256": "4d010271fb4eb52cf36fd29b66e7b3c52c44f6ba90296b944014d74bf3d4222a"
     }
   ],
   "experimentalExtensions": [
@@ -36,7 +40,7 @@
   "platform": "darwin",
   "arch": "arm64",
   "files": {
-    "tmux": "40e3ffe22314bad57e3cbacfb1f7490d6fee33e09e2f4a58f3b3b437e41a3819",
+    "tmux": "83024593f485cd4ed363aff6f898823f4401fc7e34c9a46e5732ae6fb8588666",
     "lib/libutf8proc.3.2.3.dylib": "9d044f05ab5e8b19ae954485cfd8b7dd06e0cb66f0e02fe80be99533b21168ae",
     "lib/libncursesw.6.dylib": "c9b3c77b5874b0c694590774f7b7b1568b2bb13e82707bdf29cb7296446fe596",
     "lib/libevent_core-2.1.7.dylib": "5d8dc45957013ce78a17dbacd6f5ed80cec148983d8c7eeeb4408d2f7f74743e",

package/packages/daemon/dist/native/tmux/linux-arm64/manifest.json

@@ -18,6 +18,10 @@
     {
       "patch": "control-output-barriers.patch",
       "patchSha256": "00ce678017ce94fd8ca1374b956d8db5cc4f6cdbe1309eddceed8fddb1adf6a8"
+    },
+    {
+      "patch": "split-resize.patch",
+      "patchSha256": "4d010271fb4eb52cf36fd29b66e7b3c52c44f6ba90296b944014d74bf3d4222a"
     }
   ],
   "experimentalExtensions": [
@@ -64,7 +68,7 @@
   "platform": "linux",
   "arch": "arm64",
   "files": {
-    "tmux": "760291d888aef01da2100ebf68d1c07089f5f91c05dc7a5200a862af94f2c29a",
+    "tmux": "eb7c528ae08224bde1142be8b904d62cbf9e8dcba303fcc782c32acabb860938",
     "lib/libutf8proc.so.3": "83cd7bce65037a46494b154b0f7bfd2479bc1659f56321b9ec896f4b64fb490c",
     "lib/libtinfo.so.6": "22952a4f434fd0f356fad23b92de42084e6666d8a594eadd11511b059cc5bb66",
     "lib/libevent_core-2.1.so.7": "80ad9f14cdea14f65c7a778fef4d831d51d23edc55efd263d7f265587eab73d4",

package/packages/daemon/dist/native/tmux/linux-x64/manifest.json

@@ -18,6 +18,10 @@
     {
       "patch": "control-output-barriers.patch",
       "patchSha256": "00ce678017ce94fd8ca1374b956d8db5cc4f6cdbe1309eddceed8fddb1adf6a8"
+    },
+    {
+      "patch": "split-resize.patch",
+      "patchSha256": "4d010271fb4eb52cf36fd29b66e7b3c52c44f6ba90296b944014d74bf3d4222a"
     }
   ],
   "experimentalExtensions": [
@@ -64,7 +68,7 @@
   "platform": "linux",
   "arch": "x64",
   "files": {
-    "tmux": "f82952f0deea5f882b57a1e0409bb01f2ef193374518005257b6675e6566ddb1",
+    "tmux": "4fc64502841e5944e6f26a0afed510203d0dfeb3ea63844366c4ee036da8583e",
     "lib/libutf8proc.so.3": "a5aa10c99ac2e9a30c4e01fa4baa85a03dadf71eb73119c76fb3f9f54798962d",
     "lib/libtinfo.so.6": "170db4dd0c324ee73d8d5440a38708726066e1288aba942d57191c6f002240d9",
     "lib/libevent_core-2.1.so.7": "adf343350b739d3dba2b8a6cccbe0729cd9e9ee32b38ba69c08bd14f24a8431e",