tmux-ide 2.9.0-beta.21 → 2.9.0-beta.22

package/packages/daemon/dist/lib/tmux-session-mutation-fence.js

@@ -0,0 +1,55 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { WorkspaceCatalogLiveSessionIdSchemaZ } from "@tmux-ide/contracts";
+import { liveSessionIdForNativeIdentity } from "../terminal/protocol/live-session-identity.js";
+import { shellEscape } from "./shell.js";
+/** Session identity travels with the mutation lane, never in global mutable selection. */
+export function createTmuxSessionMutationFence() {
+    const context = new AsyncLocalStorage();
+    return {
+        wrap(run) {
+            return (args) => {
+                const selected = context.getStore();
+                if (!selected)
+                    return run(args);
+                const sentinel = `tmux-session-stale.${randomUUID()}`;
+                const output = run([
+                    "if-shell",
+                    "-t",
+                    `=${selected.name}`,
+                    "-F",
+                    `#{&&:#{==:#{session_id},${selected.id}},#{==:#{session_created},${selected.created}}}`,
+                    args.map((arg) => (arg === ";" ? ";" : shellEscape(arg))).join(" "),
+                    `display-message -p '${sentinel}'`,
+                ]);
+                if (output.trim() === sentinel)
+                    throw new Error("Selected live tmux session changed before mutation");
+                return output;
+            };
+        },
+        async execute(options) {
+            WorkspaceCatalogLiveSessionIdSchemaZ.parse(options.liveSessionId);
+            const raw = await options.run([
+                "list-sessions",
+                "-F",
+                "#{pid}\t#{session_id}\t#{session_created}\t#{session_name}",
+            ]);
+            const rows = raw
+                .trim()
+                .split("\n")
+                .map((line) => line.split("\t"))
+                .filter(([pid, id, created, name]) => pid &&
+                /^\d+$/.test(pid) &&
+                id &&
+                /^\$\d+$/.test(id) &&
+                created &&
+                /^\d+$/.test(created) &&
+                name === options.sessionName &&
+                liveSessionIdForNativeIdentity(pid, id, created) === options.liveSessionId);
+            if (rows.length !== 1)
+                throw new Error("Selected live tmux session is no longer available");
+            const [, id, created] = rows[0];
+            return context.run({ id: id, created: created, name: options.sessionName }, options.mutate);
+        },
+    };
+}

package/packages/daemon/dist/lib/tmux-window-link-guard.js

@@ -0,0 +1,88 @@
+export const WINDOW_LINK_GUARD_APPLIED = "link-guard.ok";
+export const WINDOW_LINK_GUARD_STALE = "link-guard.stale";
+/** if-shell -F and its first branch command do not yield in tmux's command queue.
+ * Keep the mutation first and synchronous. Do not insert run-shell/wait-for/UI.
+ * This checks a current tuple, not an immutable historical winlink (tmux has none).
+ * Use buildNativeWindowLinkPaneSelectGuard for guarded compound pane selection.
+ */
+export function buildNativeWindowLinkGuard(address, action) {
+    const { sessionId, windowIndex, expectedWindowId } = address;
+    if (!/^\$(?:0|[1-9]\d{0,15})$/u.test(sessionId) ||
+        !/^@(?:0|[1-9]\d{0,15})$/u.test(expectedWindowId) ||
+        !Number.isSafeInteger(Number(sessionId.slice(1))) ||
+        !Number.isSafeInteger(Number(expectedWindowId.slice(1))) ||
+        !Number.isSafeInteger(windowIndex) ||
+        windowIndex < 0 ||
+        (address.expectedServerPid !== undefined &&
+            !/^[1-9][0-9]{0,15}$/u.test(address.expectedServerPid)) ||
+        (address.expectedSessionCreated !== undefined &&
+            !/^(?:0|[1-9][0-9]{0,15})$/u.test(address.expectedSessionCreated)) ||
+        (action !== "select" && action !== "unlink")) {
+        throw new Error("Invalid native window link guard address or action");
+    }
+    const target = `${sessionId}:${windowIndex}`;
+    // CANFAIL target lookup makes all three comparisons necessary for missing targets.
+    let condition = `#{&&:#{==:#{session_id},${sessionId}},#{&&:#{==:#{window_index},${windowIndex}},#{==:#{window_id},${expectedWindowId}}}}`;
+    if (address.expectedServerPid !== undefined)
+        condition = `#{&&:#{==:#{pid},${address.expectedServerPid}},${condition}}`;
+    if (address.expectedSessionCreated !== undefined)
+        condition = `#{&&:#{==:#{session_created},${address.expectedSessionCreated}},${condition}}`;
+    const verb = action === "select" ? "select-window" : "unlink-window";
+    // Validated native IDs/index contain no quote, separator, or format syntax.
+    return [
+        "if-shell",
+        "-F",
+        "-t",
+        target,
+        condition,
+        `${verb} -t '${target}' ; display-message -p '${WINDOW_LINK_GUARD_APPLIED}'`,
+        `display-message -p '${WINDOW_LINK_GUARD_STALE}'`,
+    ];
+}
+/** Select an exact link and pane while preserving native user hooks. The window
+ * selection hook may yield or move topology, so revalidate after it. A failed
+ * second check is indeterminate: the window selection may already have happened.
+ */
+export function buildNativeWindowLinkPaneSelectGuard(address, paneId) {
+    const windowGuard = buildNativeWindowLinkGuard(address, "select");
+    if (!/^%(?:0|[1-9]\d{0,15})$/u.test(paneId) || !Number.isSafeInteger(Number(paneId.slice(1)))) {
+        throw new Error("Invalid native pane guard address");
+    }
+    const target = `${address.sessionId}:${address.windowIndex}`;
+    const paneCondition = `#{&&:#{==:#{pane_id},${paneId}},#{==:#{window_id},${address.expectedWindowId}}}`;
+    const stale = `display-message -p '${WINDOW_LINK_GUARD_STALE}'`;
+    const interrupted = "display-message -p 'link-guard.interrupted'";
+    // All interpolated IDs are canonical numeric native identities. Braces are
+    // tmux command groups, not a host shell or a caller-provided command language.
+    const linkCheck = (yes, no) => `if-shell -F -t '${target}' '${windowGuard[4]}' { ${yes} } { ${no} }`;
+    const paneCheck = (yes, no) => `if-shell -F -t '${paneId}' '${paneCondition}' { ${yes} } { ${no} }`;
+    const selectPane = `select-pane -t '${paneId}' ; display-message -p '${WINDOW_LINK_GUARD_APPLIED}'`;
+    const afterHook = paneCheck(linkCheck(selectPane, interrupted), interrupted);
+    return [
+        "if-shell",
+        "-F",
+        "-t",
+        paneId,
+        paneCondition,
+        linkCheck(`select-window -t '${target}' ; ${afterHook}`, stale),
+        stale,
+    ];
+}
+/** Consume only output associated with this request's own native command boundary.
+ * Nonzero completion reports native failure, including last-link unlink refusal.
+ * For compound selection this can follow partial mutation; it is not rollback proof.
+ * Missing/extra output or interrupted completion is indeterminate, never success;
+ * it must not trigger an automatic retry of a potentially completed mutation.
+ */
+export function classifyNativeWindowLinkGuardResult(status, stdout) {
+    if (status === null)
+        return "indeterminate";
+    if (status !== 0)
+        return "native-refused";
+    const output = stdout.trim();
+    if (output === WINDOW_LINK_GUARD_APPLIED)
+        return "applied";
+    if (output === WINDOW_LINK_GUARD_STALE)
+        return "stale";
+    return "indeterminate";
+}

package/packages/daemon/dist/lib/workspace-config-loader.js

@@ -1,3 +1,6 @@
+// Consumers outside the daemon tsconfig need the bundled declaration as well.
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="../js-yaml.d.ts" />
 /**
  * Side-effect-free loader for repository-scoped WorkspaceConfigV1 files.
  *

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

@@ -26,6 +26,7 @@ import { getDefaultWorkspaceRegistry } from "./workspace-registry.js";
 import { internalInteractionOperationMarker } from "./tmux-external-interaction-observer.js";
 import { INTERNAL_READ_OPERATION_OPTION, INTERNAL_SEND_OPERATION_OPTION, } from "./tmux-interaction-options.js";
 import { memorablePaneName } from "../terminal/protocol/pane-display-name.js";
+import { WindowLinkResolutionError } from "../terminal/mirror/window-link-authority.js";
 const CREATION_OPTION = "@tmux_ide_creation_id";
 const SEMANTIC_PANE_OPTION = "@tmux_ide_pane_id";
 const SEMANTIC_WINDOW_OPTION = "@tmux_ide_window_id";
@@ -47,6 +48,10 @@ const ERROR_MESSAGES = {
     workspace_unavailable: "The requested workspace is not available for multiplexer verbs.",
     pane_not_found: "No pane in this workspace carries the requested semantic identity.",
     window_not_found: "No window in this workspace carries the requested identity.",
+    window_link_stale: "The window link observation is no longer current.",
+    window_link_ambiguous: "Select an explicit window link for this pane.",
+    window_link_session_mismatch: "The window link belongs to another session generation.",
+    window_link_backing_mismatch: "The window link no longer names the expected window.",
     ambiguous_target: "The requested identity names more than one live tmux object.",
     last_window_refused: "This is the session's last window. Close the session instead if that is what you mean.",
     last_pane_refused: "This is the session's last pane. Close the session instead if that is what you mean.",
@@ -121,7 +126,19 @@ export function parseMultiplexerPaneRows(output) {
             creationId: creationId === "" ? null : creationId,
         });
     }
-    return rows;
+    // list-panes -s repeats each backing for its session links. Identical native
+    // rows are one pane; conflicting observations fail closed.
+    const unique = new Map();
+    for (const row of rows) {
+        const previous = unique.get(row.paneId);
+        if (previous && JSON.stringify(previous) !== JSON.stringify(row)) {
+            throw new WorkspaceMultiplexerError("workspace_unavailable", {
+                reason: "conflicting_linked_pane_observation",
+            });
+        }
+        unique.set(row.paneId, row);
+    }
+    return [...unique.values()];
 }
 /** Distinct windows in a pane listing, in first-seen order. */
 export function windowIdsOf(rows) {
@@ -205,6 +222,61 @@ export class WorkspaceMultiplexerAuthority {
     mutate(raw, timing) {
         return this.#mutate(raw, timing);
     }
+    /** Runs only inside the existing semantic mutation lane; never rediscovers a stale link. */
+    async mutateWindowLink(raw, execute) {
+        if (this.#disposed)
+            throw new WorkspaceMultiplexerError("workspace_unavailable");
+        const request = WorkspaceMultiplexerMutationRequestSchemaZ.parse(raw);
+        if (request.expectedDaemonInstanceId !== this.#daemonInstanceId)
+            throw new WorkspaceMultiplexerError("daemon_instance_mismatch");
+        const intent = request.intent;
+        if (intent.verb !== "workspace.window.link.select" &&
+            intent.verb !== "workspace.window.link.unlink" &&
+            intent.verb !== "workspace.pane.select")
+            throw new TypeError("Expected a window-link selection or unlink intent");
+        const workspace = this.#registry.get(intent.workspaceName);
+        if (!workspace)
+            throw new WorkspaceMultiplexerError("workspace_not_found");
+        const envelope = {
+            operationId: request.operationId,
+            daemonInstanceId: this.#daemonInstanceId,
+            workspaceName: intent.workspaceName,
+        };
+        try {
+            const result = await execute(workspace.sessionName, intent.verb === "workspace.pane.select"
+                ? {
+                    action: "select",
+                    ...(intent.windowLink ? { target: intent.windowLink } : {}),
+                    paneId: intent.semanticPaneId,
+                }
+                : {
+                    action: intent.verb === "workspace.window.link.unlink" ? "unlink" : "select",
+                    target: intent.target,
+                });
+            if (result.outcome !== "applied") {
+                throw new WorkspaceMultiplexerError(result.outcome === "stale"
+                    ? "window_link_stale"
+                    : result.outcome === "native-refused"
+                        ? "mutation_failed"
+                        : "mutation_unverified", { reason: result.outcome });
+            }
+            return WorkspaceMultiplexerMutationResultSchemaZ.parse(intent.verb === "workspace.pane.select"
+                ? {
+                    ...envelope,
+                    verb: intent.verb,
+                    outcome: "applied",
+                    semanticPaneId: intent.semanticPaneId,
+                }
+                : { ...envelope, verb: intent.verb, outcome: "applied", target: intent.target });
+        }
+        catch (error) {
+            if (error instanceof WorkspaceMultiplexerError)
+                throw error;
+            if (error instanceof WindowLinkResolutionError)
+                throw new WorkspaceMultiplexerError(error.reason, { operationId: request.operationId }, error);
+            throw new WorkspaceMultiplexerError("mutation_unverified", { operationId: request.operationId }, error);
+        }
+    }
     /**
      * Capture a semantically addressed pane for an authored read. The tmux
      * after-capture hook is the completion authority; this method only performs
@@ -436,6 +508,11 @@ export class WorkspaceMultiplexerAuthority {
             workspaceName: intent.workspaceName,
         };
         switch (intent.verb) {
+            case "workspace.window.link.select":
+            case "workspace.window.link.unlink":
+                throw new WorkspaceMultiplexerError("workspace_unavailable", {
+                    reason: "window_link_authority_required",
+                });
             case "workspace.window.split":
                 return this.#split(request, workspace, envelope);
             case "workspace.window.kill":
@@ -826,6 +903,10 @@ export class WorkspaceMultiplexerAuthority {
         };
     }
     #select(intent, sessionName, envelope, timing) {
+        if (intent.windowLink)
+            throw new WorkspaceMultiplexerError("workspace_unavailable", {
+                reason: "window_link_authority_required",
+            });
         const timed = (operation, run) => {
             if (!timing)
                 return run();

package/packages/daemon/dist/lib/workspace-pane-creation.js

@@ -1,10 +1,10 @@
 import { boundedTmuxRead } from "./bounded-tmux-read.js";
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
-import { delimiter, isAbsolute, join, relative, sep } from "node:path";
+import { isAbsolute, relative, sep } from "node:path";
 import { WorkspacePaneCreateMutationRequestSchemaZ, WorkspacePaneCreateMutationResultSchemaZ, } from "@tmux-ide/contracts";
 import { runTmuxBinary, TmuxError } from "@tmux-ide/tmux-bridge";
 import { createNamedSocketFence } from "./tmux-named-socket-fence.js";
-import { resolveBundledTmux } from "./bundled-tmux.js";
+import { resolveTmuxExecutable as resolvePinnedTmuxExecutable, tmuxClientEnvironment, } from "./tmux-client-execution.js";
 import { probeProjectReadiness } from "./project-readiness-probe.js";
 import { agentHintForCommand } from "./agent-kind.js";
 import { loadWorkspaceConfig, WorkspaceConfigLoadError, } from "./workspace-config-loader.js";
@@ -12,7 +12,7 @@ import { getDefaultWorkspaceRegistry } from "./workspace-registry.js";
 import { memorablePaneName } from "../terminal/protocol/pane-display-name.js";
 import { shellEscape } from "./shell.js";
 import { MissionRepository } from "./mission-repository.js";
-import { resolveRuntimeNamespace } from "./runtime-namespace.js";
+import { resolveRuntimeNamespace, resolveTmuxServerIntent } from "./runtime-namespace.js";
 import { prepareTmuxTruecolorEnvironment } from "./tmux-terminal-color.js";
 import { captureUnixSocketIdentity, revalidateUnixSocketIdentity, } from "./unix-socket-authority.js";
 const MAX_LIVE_OR_UNSAFE_OPERATIONS = 128;
@@ -102,61 +102,17 @@ function assertEffectiveConfigProvenance(workspace, canonicalRoot, source) {
     }
 }
 function resolveTmuxExecutable() {
+    // Preserve development artifact qualification errors instead of masking them.
     if (resolveRuntimeNamespace().development)
-        return resolveBundledTmux();
-    const configured = process.env.TMUX_IDE_TMUX_BIN;
-    if (!configured) {
-        const bundled = resolveBundledTmux();
-        if (bundled)
-            return bundled;
-    }
-    const candidates = configured
-        ? [configured]
-        : (process.env.PATH ?? "")
-            .split(delimiter)
-            // Empty and relative PATH entries mean the daemon/project cwd. They
-            // are never executable authority for a privileged tmux mutation.
-            .filter((entry) => entry.length > 0 && isAbsolute(entry))
-            .map((entry) => join(entry, "tmux"));
-    for (const candidate of candidates) {
-        try {
-            if (!isAbsolute(candidate))
-                continue;
-            accessSync(candidate, constants.X_OK);
-            const canonical = realpathSync(candidate);
-            if (statSync(canonical).isFile())
-                return canonical;
-        }
-        catch {
-            // Continue to the next daemon-start candidate.
-        }
+        return resolvePinnedTmuxExecutable();
+    try {
+        return resolvePinnedTmuxExecutable();
     }
-    throw new WorkspacePaneCreationError("workspace_unavailable", {
-        reason: "tmux_executable_unavailable",
-    });
-}
-const SAFE_TERMINAL_VALUE = /^(?:xterm|screen|tmux|rxvt|vt100|ansi)[A-Za-z0-9+._-]{0,58}$/u;
-const SAFE_LOCALE_VALUE = /^[A-Za-z0-9][A-Za-z0-9_.@-]{0,127}$/u;
-/**
- * The pinned tmux client receives only presentation metadata. Everything else
- * is denied by omission: PATH/HOME/SHELL, TMUX/TMUX_PANE/TMUX_TMPDIR, shell
- * startup hooks, dynamic-loader variables, Node options, and project secrets
- * cannot redirect authority or inject code into this daemon-owned execution.
- */
-function tmuxClientEnvironment(source) {
-    const environment = {
-        TERM: SAFE_TERMINAL_VALUE.test(source.TERM ?? "") ? source.TERM : "xterm-256color",
-        // A pinned runner may be the first tmux client and therefore create the
-        // server. Never let a headless parent (`TERM=dumb`, `NO_COLOR=1`) become
-        // the global environment inherited by every later interactive child.
-        COLORTERM: "truecolor",
-    };
-    for (const name of ["LANG", "LC_ALL", "LC_CTYPE"]) {
-        const value = source[name];
-        if (value && SAFE_LOCALE_VALUE.test(value))
-            environment[name] = value;
+    catch {
+        throw new WorkspacePaneCreationError("workspace_unavailable", {
+            reason: "tmux_executable_unavailable",
+        });
     }
-    return environment;
 }
 function tmuxSocketFromEnvironment() {
     const match = /^(.*),[0-9]+,[0-9]+$/u.exec(process.env.TMUX ?? "");
@@ -165,7 +121,7 @@ function tmuxSocketFromEnvironment() {
 export function resolveWorkspacePaneTmuxAuthority() {
     const namespace = resolveRuntimeNamespace();
     const executablePath = resolveTmuxExecutable();
-    if (namespace.development)
+    if (resolveTmuxServerIntent()?.source === "explicit")
         return Object.freeze({ executablePath, socketSelector: namespace.tmuxSocket });
     const environmentSocket = tmuxSocketFromEnvironment();
     if (environmentSocket) {
@@ -186,7 +142,7 @@ export function resolveWorkspacePaneTmuxAuthority() {
     // A sessionless daemon may start before the default tmux server exists. Pin
     // the daemon's default socket *name* and captured environment rather than
     // consulting a later request's TMUX/PATH.
-    return Object.freeze({ executablePath, socketSelector: resolveRuntimeNamespace().tmuxSocket });
+    return Object.freeze({ executablePath, socketSelector: namespace.tmuxSocket });
 }
 /** Execute mutations only through the daemon-generation-pinned tmux authority. */
 export function createPinnedWorkspaceTmuxRunner(authority, options = {}) {

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

@@ -67,6 +67,7 @@ const PANE_VERIFY_FORMAT = [
     "#{pane_id}",
     `#{${SEMANTIC_PANE_OPTION}}`,
     `#{${SEMANTIC_WINDOW_OPTION}}`,
+    "#{window_index}",
     SENTINEL,
 ].join(FIELD);
 const ERROR_MESSAGES = {
@@ -223,8 +224,10 @@ function parseVerifyPanes(output) {
         const fields = line.split(FIELD);
         const windowPaneCount = positiveInteger(fields[3] ?? "");
         const sessionWindowCount = positiveInteger(fields[4] ?? "");
-        if (fields.length !== 9 ||
-            fields[8] !== SENTINEL ||
+        if (fields.length !== 10 ||
+            fields[9] !== SENTINEL ||
+            !/^(0|[1-9][0-9]*)$/u.test(fields[8]) ||
+            !Number.isSafeInteger(Number(fields[8])) ||
             !/^\$[0-9]+$/u.test(fields[0]) ||
             !/^@[0-9]+$/u.test(fields[1]) ||
             !/^%[0-9]+$/u.test(fields[5]) ||
@@ -243,6 +246,7 @@ function parseVerifyPanes(output) {
             paneId: fields[5],
             semanticPaneId: fields[6],
             semanticWindowId: fields[7],
+            windowIndex: Number(fields[8]),
         });
     }
     return panes;
@@ -368,9 +372,7 @@ export class WorkspacePromotionAuthority {
             // promotion is the app's only repair verb — so reconcile the stamps here
             // before resolving to a `replayed` outcome. Stamping is additive and never
             // overwrites a valid stamp, so a healthy session is untouched.
-            const alreadyRegistered = this.#registry
-                .list()
-                .find((workspace) => workspace.sessionName === session.sessionName);
+            const alreadyRegistered = this.#registeredSession(session.sessionName);
             if (alreadyRegistered) {
                 const registeredIdentity = {
                     workspaceName: alreadyRegistered.name,
@@ -390,6 +392,39 @@ export class WorkspacePromotionAuthority {
             this.#assertActive(request.operationId);
             await this.#verifyPromotedInventory(session.sessionId, identity);
             await this.#publishFleetEnrollment(request, session, identity);
+            // Catalog discovery can admit this session while the native stamping
+            // and verification awaits run. Reuse that exact registry identity instead
+            // of publishing a second name for the same session at the commit point.
+            const discovered = this.#registeredSession(session.sessionName);
+            if (discovered) {
+                if (discovered.name !== identity.workspaceName) {
+                    try {
+                        await this.#io.runTmux([
+                            "set-option",
+                            "-t",
+                            session.sessionId,
+                            SESSION_WORKSPACE_OPTION,
+                            discovered.name,
+                        ]);
+                    }
+                    catch (error) {
+                        throw new WorkspacePromotionError("stamp_failed", {
+                            operationId: request.operationId,
+                            workspaceName: discovered.name,
+                        }, error);
+                    }
+                }
+                this.#assertActive(request.operationId);
+                if (this.#registeredSession(session.sessionName)?.name !== discovered.name) {
+                    throw new WorkspacePromotionError("workspace_conflict", {
+                        operationId: request.operationId,
+                        workspaceName: discovered.name,
+                    });
+                }
+                return this.#succeed(request, fingerprint, discovered.name, session.sessionName, {
+                    replayed: true,
+                });
+            }
             let registered;
             try {
                 registered = this.#registry.add({
@@ -449,6 +484,15 @@ export class WorkspacePromotionAuthority {
             throw error;
         }
     }
+    #registeredSession(sessionName) {
+        const candidates = this.#registry
+            .list()
+            .filter((workspace) => workspace.sessionName === sessionName);
+        if (candidates.length > 1) {
+            throw new WorkspacePromotionError("workspace_conflict", { sessionName });
+        }
+        return candidates[0];
+    }
     #assertConflictFreeIdentity(identity) {
         for (const workspace of this.#registry.list()) {
             if (workspace.name === identity.workspaceName &&
@@ -531,6 +575,19 @@ export class WorkspacePromotionAuthority {
                 reason: "empty_or_foreign_pane_inventory",
             });
         }
+        // list-panes -s repeats each backing pane once per window link. Stamp the
+        // backing only once, and reject contradictory observations before writes.
+        const uniqueScan = new Map();
+        for (const pane of scanned) {
+            const previous = uniqueScan.get(pane.paneId);
+            if (previous && JSON.stringify(previous) !== JSON.stringify(pane)) {
+                throw new WorkspacePromotionError("promotion_verification_failed", {
+                    reason: "inconsistent_tmux_topology",
+                });
+            }
+            uniqueScan.set(pane.paneId, pane);
+        }
+        scanned = [...uniqueScan.values()];
         const nowSec = Math.floor(this.#io.now() / 1000);
         const reconciledWindows = new Set();
         try {
@@ -699,7 +756,29 @@ export class WorkspacePromotionAuthority {
                 reason: "missing_window_stamp",
             });
         }
-        const catalog = analyzeTrustedSemanticPaneCatalog(panes.map((pane) => ({
+        // Validate links independently from their shared backing. Repeated native
+        // panes are legal only across distinct links with identical backing facts.
+        const links = new Map();
+        const backingPanes = new Map();
+        const semanticWindows = new Map();
+        for (const pane of panes) {
+            const { windowIndex, ...backing } = pane;
+            const previous = backingPanes.get(pane.paneId);
+            const semanticOwner = semanticWindows.get(pane.semanticWindowId);
+            const rows = links.get(windowIndex) ?? [];
+            if ((previous && JSON.stringify(previous) !== JSON.stringify(backing)) ||
+                (semanticOwner && semanticOwner !== pane.windowId) ||
+                rows.some((row) => row.paneId === pane.paneId || row.windowId !== pane.windowId)) {
+                throw new WorkspacePromotionError("promotion_verification_failed", {
+                    reason: "inconsistent_tmux_topology",
+                });
+            }
+            backingPanes.set(pane.paneId, backing);
+            semanticWindows.set(pane.semanticWindowId, pane.windowId);
+            rows.push(pane);
+            links.set(windowIndex, rows);
+        }
+        const catalog = analyzeTrustedSemanticPaneCatalog([...backingPanes.values()].map((pane) => ({
             workspaceName: identity.workspaceName,
             semanticPaneId: pane.semanticPaneId === "" ? null : pane.semanticPaneId,
             sessionId: pane.sessionId,
@@ -716,16 +795,16 @@ export class WorkspacePromotionAuthority {
                 reason: "semantic_pane_catalog_rejected_inventory",
             });
         }
-        const windows = new Map();
-        for (const pane of panes) {
-            const rows = windows.get(pane.windowId) ?? [];
+        const backings = new Map();
+        for (const pane of backingPanes.values()) {
+            const rows = backings.get(pane.windowId) ?? [];
             rows.push(pane);
-            windows.set(pane.windowId, rows);
+            backings.set(pane.windowId, rows);
         }
         const sessionWindowCount = panes[0].sessionWindowCount;
-        if (windows.size !== sessionWindowCount ||
+        if (links.size !== sessionWindowCount ||
             panes.some((pane) => pane.sessionWindowCount !== sessionWindowCount) ||
-            [...windows.values()].some((rows) => rows.length !== rows[0].windowPaneCount ||
+            [...links.values(), ...backings.values()].some((rows) => rows.length !== rows[0].windowPaneCount ||
                 rows.some((row) => row.windowPaneCount !== rows.length ||
                     row.windowName !== rows[0].windowName ||
                     row.semanticWindowId !== rows[0].semanticWindowId))) {

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

@@ -101,6 +101,10 @@ export class WorkspaceRegistry {
     has(name) {
         return this.workspaces.some((w) => w.name === name);
     }
+    /** Whether this entry is discovered live state, never durable user intent. */
+    isVolatile(name) {
+        return this.volatileNames.has(name);
+    }
     add(input) {
         if (this.has(input.name)) {
             throw new WorkspaceAlreadyExistsError(input.name);

package/packages/daemon/dist/server/pane-stream-upgrade.js

@@ -20,9 +20,11 @@ function rejectUpgrade(socket, status) {
         ? "Forbidden"
         : status === 404
             ? "Not Found"
-            : status === 426
-                ? "Upgrade Required"
-                : "Service Unavailable";
+            : status === 410
+                ? "Gone"
+                : status === 426
+                    ? "Upgrade Required"
+                    : "Service Unavailable";
     try {
         socket.end(`HTTP/1.1 ${status} ${phrase}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`);
     }
@@ -36,7 +38,7 @@ function rejectUpgrade(socket, status) {
  * Origin, and pre-auth capacity decisions happen before `handleUpgrade`, so
  * rejected requests never become WebSockets.
  */
-export function attachPaneStreamWebSocket(server, coordinator) {
+export function attachPaneStreamWebSocket(server, coordinator, redemptionPath = PANE_STREAM_REDEEM_PATH, isCurrent = () => true) {
     const wss = new WebSocketServer({
         noServer: true,
         clientTracking: false,
@@ -52,9 +54,17 @@ export function attachPaneStreamWebSocket(server, coordinator) {
     const upgrade = (request, socket, head) => {
         const rawPath = request.url ?? "";
         const pathname = rawPath.split("?", 1)[0] ?? "";
-        if (!pathname.startsWith("/v1/terminal/pane-streams/"))
+        if (redemptionPath === PANE_STREAM_REDEEM_PATH &&
+            pathname.startsWith("/v1/terminal/pane-streams/")) {
+            rejectUpgrade(socket, 426);
+            return;
+        }
+        if (redemptionPath !== PANE_STREAM_REDEEM_PATH && pathname !== redemptionPath)
             return;
-        if (pathname !== PANE_STREAM_REDEEM_PATH) {
+        if (redemptionPath === PANE_STREAM_REDEEM_PATH &&
+            !pathname.startsWith("/v2/terminal/pane-streams/"))
+            return;
+        if (pathname !== redemptionPath) {
             rejectUpgrade(socket, 404);
             return;
         }
@@ -78,6 +88,10 @@ export function attachPaneStreamWebSocket(server, coordinator) {
             rejectUpgrade(socket, 403);
             return;
         }
+        if (!isCurrent()) {
+            rejectUpgrade(socket, 410);
+            return;
+        }
         const decision = coordinator.reserveUpgrade({
             path: rawPath,
             protocols: protocols(protocolHeaders[0]),