oh-my-codex 0.20.2 → 0.20.5

package/dist/hud/tmux.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { execFileSync } from 'child_process';
 import { existsSync } from 'fs';
 import { HUD_RESIZE_RECONCILE_DELAY_SECONDS, HUD_TMUX_HEIGHT_LINES } from './constants.js';
@@ -9,6 +10,70 @@ export const TMUX_PANE_FIELD_SEPARATOR = '\x1f';
 export const TMUX_PANE_FIELD_SEPARATOR_OCTAL_ESCAPE = '\\037';
 /** Upper bound for tmux hook indices (signed 32-bit max). */
 const TMUX_HOOK_INDEX_MAX = 2147483647;
+const PSMUX_PANE_ID_MAX = 0xffffffffn;
+const PSMUX_PANE_ID_MAX_DIGITS = PSMUX_PANE_ID_MAX.toString().length;
+export function parseCanonicalTmuxPaneId(value) {
+    if (typeof value !== 'string')
+        return null;
+    const match = /^%(0|[1-9]\d*)$/.exec(value);
+    if (!match || match[1].length > PSMUX_PANE_ID_MAX_DIGITS)
+        return null;
+    try {
+        return BigInt(match[1]) <= PSMUX_PANE_ID_MAX ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parses tmux output used as authority. Authority frames are deliberately
+ * transport-strict: a nonempty body followed by exactly one LF or CRLF.
+ */
+export function parseExactTmuxAuthorityLines(output) {
+    if (typeof output !== 'string' || output.length < 2)
+        return null;
+    const terminator = output.endsWith('\r\n') ? '\r\n' : output.endsWith('\n') ? '\n' : null;
+    if (!terminator)
+        return null;
+    const body = output.slice(0, -terminator.length);
+    if (body === '' || body.endsWith('\n') || body.includes('\r'))
+        return null;
+    return body.split('\n');
+}
+/** Parses one exact, nonempty tmux authority scalar. */
+export function parseExactTmuxAuthorityScalar(output) {
+    const lines = parseExactTmuxAuthorityLines(output);
+    return lines?.length === 1 && lines[0] !== '' ? lines[0] : null;
+}
+/**
+ * Tolerant pane parsing is for display metadata only. Callers using its output
+ * as authority MUST first validate framing with parseExactTmuxAuthorityLines.
+ */
+function canonicalizePaneSnapshotBatch(panes) {
+    const paneIds = new Set();
+    const canonicalPanes = [];
+    for (const pane of panes) {
+        const paneId = parseCanonicalTmuxPaneId(pane.paneId);
+        if (!paneId || paneIds.has(paneId))
+            return null;
+        paneIds.add(paneId);
+        canonicalPanes.push({ ...pane, paneId });
+    }
+    return canonicalPanes;
+}
+function parseCanonicalPaneIdSnapshot(output) {
+    const lines = parseExactTmuxAuthorityLines(output);
+    if (!lines)
+        return null;
+    const paneIds = new Set();
+    for (const line of lines) {
+        const paneId = parseCanonicalTmuxPaneId(line);
+        if (!paneId || paneIds.has(paneId))
+            return null;
+        paneIds.add(paneId);
+    }
+    return paneIds;
+}
 function defaultExecTmuxSync(args) {
     try {
         return execFileSync(resolveTmuxBinaryForPlatform() || 'tmux', args, {
@@ -25,28 +90,36 @@ function defaultExecTmuxSync(args) {
     }
 }
 function parseNonNegativeInteger(value) {
-    if (typeof value !== 'string' || value.trim() === '')
+    if (typeof value !== 'string' || !/^(?:0|[1-9][0-9]*)$/.test(value))
         return null;
-    const parsed = Number.parseInt(value.trim(), 10);
-    return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed <= 4_294_967_295 ? parsed : null;
 }
 function parsePositiveInteger(value) {
     const parsed = parseNonNegativeInteger(value);
     return parsed !== null && parsed > 0 ? parsed : null;
 }
-export function parseTmuxPaneSnapshot(output) {
-    return output
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .map((line) => {
+export function parseTmuxPaneSnapshot(output, authoritativePaneIds) {
+    const lines = output.split('\n');
+    if (lines.at(-1) === '')
+        lines.pop();
+    if (lines.length === 0)
+        return [];
+    const panes = [];
+    for (const line of lines) {
+        if (line === '')
+            return [];
         const fieldSeparator = line.includes(TMUX_PANE_FIELD_SEPARATOR)
             ? TMUX_PANE_FIELD_SEPARATOR
             : line.includes(TMUX_PANE_FIELD_SEPARATOR_OCTAL_ESCAPE)
                 ? TMUX_PANE_FIELD_SEPARATOR_OCTAL_ESCAPE
                 : '\t';
         const parts = line.split(fieldSeparator);
-        const [paneId = '', currentCommand = ''] = parts;
+        const [rawPaneId = '', currentCommand = ''] = parts;
+        const paneId = parseCanonicalTmuxPaneId(rawPaneId);
+        if (!paneId)
+            return [];
+        const hasGeometryFields = parts.length >= 9;
         const paneLeft = parseNonNegativeInteger(parts[2]);
         const paneTop = parseNonNegativeInteger(parts[3]);
         const paneWidth = parsePositiveInteger(parts[4]);
@@ -61,16 +134,25 @@ export function parseTmuxPaneSnapshot(output) {
             && paneBottom !== null
             && windowWidth !== null
             && windowHeight !== null);
+        if (hasGeometryFields && !hasGeometry)
+            return [];
         const payloadParts = hasGeometry ? parts.slice(9) : parts.slice(2);
-        const hasCurrentPathColumn = payloadParts.length >= 2;
-        const currentPath = hasCurrentPathColumn ? (payloadParts.at(-1) ?? '') : '';
-        const startCommandParts = hasCurrentPathColumn ? payloadParts.slice(0, -1) : payloadParts;
+        const hasIncarnationFields = hasGeometry
+            && payloadParts.length >= 4
+            && /^(?:0|1)$/.test(payloadParts.at(-2) ?? '')
+            && parsePositiveInteger(payloadParts.at(-1)) !== null;
+        const incarnationParts = hasIncarnationFields ? payloadParts.slice(-2) : [];
+        const commandParts = hasIncarnationFields ? payloadParts.slice(0, -2) : payloadParts;
+        const hasCurrentPathColumn = commandParts.length >= 2;
+        const currentPath = hasCurrentPathColumn ? (commandParts.at(-1) ?? '') : '';
+        const startCommandParts = hasCurrentPathColumn ? commandParts.slice(0, -1) : commandParts;
         const trimmedCurrentPath = currentPath.trim();
-        return {
-            paneId: paneId.trim(),
+        panes.push({
+            paneId,
             currentCommand: currentCommand.trim(),
             startCommand: startCommandParts.join('\t').trim(),
             ...(trimmedCurrentPath ? { currentPath: trimmedCurrentPath } : {}),
+            ...(hasIncarnationFields ? { paneDead: incarnationParts[0] === '1', panePid: incarnationParts[1] } : {}),
             ...(hasGeometry
                 ? {
                     paneLeft,
@@ -82,9 +164,16 @@ export function parseTmuxPaneSnapshot(output) {
                     windowHeight,
                 }
                 : {}),
-        };
-    })
-        .filter((pane) => pane.paneId.startsWith('%'));
+        });
+    }
+    const canonicalPanes = canonicalizePaneSnapshotBatch(panes);
+    if (!canonicalPanes)
+        return [];
+    if (authoritativePaneIds
+        && (canonicalPanes.length !== authoritativePaneIds.size
+            || canonicalPanes.some((pane) => !authoritativePaneIds.has(pane.paneId))))
+        return [];
+    return canonicalPanes;
 }
 export function isHudWatchPane(pane) {
     const command = `${pane.startCommand} ${pane.currentCommand}`.toLowerCase();
@@ -92,53 +181,302 @@ export function isHudWatchPane(pane) {
         && /--watch\b/.test(command)
         && (/\bomx(?:\.js)?\b/.test(command) || /\bnode\b/.test(command)));
 }
+const HUD_OWNER_ENV_KEYS = [
+    OMX_TMUX_HUD_OWNER_ENV,
+    'OMX_SESSION_ID',
+    OMX_TMUX_HUD_LEADER_PANE_ENV,
+];
+function isHudOwnerEnvKey(key) {
+    return HUD_OWNER_ENV_KEYS.some((ownerKey) => ownerKey === key);
+}
+function isPowerShellHudOwnerEnvKey(key) {
+    return HUD_OWNER_ENV_KEYS.some((ownerKey) => ownerKey === key.toUpperCase());
+}
+function lexPosixWords(command) {
+    const words = [];
+    let index = 0;
+    while (index < command.length) {
+        while (/\s/.test(command[index] ?? ''))
+            index += 1;
+        if (index >= command.length)
+            break;
+        if (command[index] === '#')
+            break;
+        let word = '';
+        let quoted = false;
+        while (index < command.length && !/\s/.test(command[index] ?? '')) {
+            const char = command[index];
+            if (';|&()<>`'.includes(char) || char === '\n' || char === '\r')
+                return null;
+            if (char === '\\') {
+                index += 1;
+                if (index >= command.length)
+                    return null;
+                word += command[index];
+                index += 1;
+                continue;
+            }
+            if (char === "'") {
+                quoted = true;
+                index += 1;
+                while (index < command.length && command[index] !== "'") {
+                    word += command[index];
+                    index += 1;
+                }
+                if (index >= command.length)
+                    return null;
+                index += 1;
+                continue;
+            }
+            if (char === '"') {
+                quoted = true;
+                index += 1;
+                while (index < command.length && command[index] !== '"') {
+                    if (command[index] === '\\') {
+                        index += 1;
+                        if (index >= command.length)
+                            return null;
+                    }
+                    word += command[index];
+                    index += 1;
+                }
+                if (index >= command.length)
+                    return null;
+                index += 1;
+                continue;
+            }
+            word += char;
+            index += 1;
+        }
+        if (!word && !quoted)
+            return null;
+        words.push(word);
+    }
+    return words;
+}
+function parsePosixHudEnvAssignments(command) {
+    const values = new Map();
+    const attempted = HUD_OWNER_ENV_KEYS.some((key) => command.includes(key));
+    const words = lexPosixWords(command);
+    if (!words)
+        return { attempted, valid: false, values };
+    const inspect = (tokens) => {
+        let commandStarted = false;
+        let acceptsEnvAssignments = false;
+        for (let index = 0; index < tokens.length; index += 1) {
+            const token = tokens[index];
+            const assignment = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(token);
+            if (assignment && isHudOwnerEnvKey(assignment[1]) && (!commandStarted || acceptsEnvAssignments)) {
+                const key = assignment[1];
+                const existing = values.get(key) ?? [];
+                existing.push(assignment[2]);
+                values.set(key, existing);
+                continue;
+            }
+            if (token === '-c' && index + 1 < tokens.length) {
+                const nested = lexPosixWords(tokens[index + 1]);
+                if (!nested || !inspect(nested))
+                    return false;
+                commandStarted = true;
+                continue;
+            }
+            if (token === 'exec' && !commandStarted)
+                continue;
+            if (!commandStarted && token === 'env') {
+                commandStarted = true;
+                acceptsEnvAssignments = true;
+                continue;
+            }
+            commandStarted = true;
+            acceptsEnvAssignments = false;
+        }
+        return true;
+    };
+    return { attempted, valid: inspect(words), values };
+}
+function parseShellEnvAssignments(command, key) {
+    const parsed = parsePosixHudEnvAssignments(command);
+    return parsed.valid ? (parsed.values.get(key) ?? []) : [];
+}
 function parseShellEnvAssignment(command, key) {
-    const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const match = command.match(new RegExp(`(?:^|\\s)(?:'${escapedKey}=([^']*)'|${escapedKey}=(?:'((?:'\\\\''|[^'])*)'|([^\\s]+)))`));
-    const fallbackMatch = match
-        ? null
-        : command.match(new RegExp(`(?:^|[\\s'])${escapedKey}=([^'\\s]+)`));
-    const raw = match?.[1] ?? match?.[2] ?? match?.[3] ?? fallbackMatch?.[1];
-    if (typeof raw !== 'string')
-        return undefined;
-    const value = raw.replace(/'\\''/g, "'").trim();
-    return value === '' ? undefined : value;
+    const values = parseShellEnvAssignments(command, key);
+    return values.length === 1 && values[0] !== '' ? values[0] : undefined;
+}
+function containsPowerShellHudOwnerReferenceOutsideQuotes(command) {
+    let quote = null;
+    let blockComment = false;
+    let lineComment = false;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index];
+        const next = command[index + 1];
+        if (blockComment) {
+            if (char === '#' && next === '>') {
+                blockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (lineComment) {
+            if (char === '\n' || char === '\r')
+                lineComment = false;
+            continue;
+        }
+        if (quote === 'single') {
+            if (char === "'" && next === "'")
+                index += 1;
+            else if (char === "'")
+                quote = null;
+            continue;
+        }
+        if (quote === 'double') {
+            if (char === '`')
+                index += 1;
+            else if (char === '"')
+                quote = null;
+            continue;
+        }
+        if (char === '<' && next === '#') {
+            blockComment = true;
+            index += 1;
+            continue;
+        }
+        if (char === '#') {
+            lineComment = true;
+            continue;
+        }
+        if (char === "'") {
+            quote = 'single';
+            continue;
+        }
+        if (char === '"') {
+            quote = 'double';
+            continue;
+        }
+        if (char === '`') {
+            index += 1;
+            continue;
+        }
+        if (command.slice(index, index + 5).toLowerCase() === '$env:') {
+            const match = /^\$env:([A-Za-z_][A-Za-z0-9_]*)/i.exec(command.slice(index));
+            if (match && isPowerShellHudOwnerEnvKey(match[1]))
+                return true;
+        }
+    }
+    return false;
+}
+function unwrapKnownPowerShellCommand(command) {
+    const match = /^\s*powershell(?:\.exe)?\s+-NoLogo\s+-NoExit\s+-Command\s+'((?:''|[^'])*)'(.*)$/i.exec(command);
+    if (!match)
+        return null;
+    return { command: match[1].replace(/''/g, "'"), remainder: match[2] };
+}
+function parsePowerShellHudEnvPrefix(command) {
+    const unwrapped = unwrapKnownPowerShellCommand(command);
+    const source = unwrapped?.command ?? command;
+    const present = containsPowerShellHudOwnerReferenceOutsideQuotes(source);
+    const values = new Map();
+    if (!present)
+        return { present: false, valid: false, values, remainder: command };
+    const prefixMatch = /^\s*((?:\$env:[A-Za-z_][A-Za-z0-9_]*\s*=\s*'(?:''|[^'])*'\s*;\s*)+)&(?:\s|$)/i.exec(source);
+    if (!prefixMatch)
+        return { present: true, valid: false, values, remainder: command };
+    const assignmentPattern = /\$env:([A-Za-z_][A-Za-z0-9_]*)\s*=\s*'((?:''|[^'])*)'\s*;/gi;
+    for (const match of prefixMatch[1].matchAll(assignmentPattern)) {
+        const key = match[1].toUpperCase();
+        const existing = values.get(key) ?? [];
+        existing.push(match[2].replace(/''/g, "'"));
+        values.set(key, existing);
+    }
+    const remainder = `${source.slice(prefixMatch[0].length)}${unwrapped?.remainder ?? ''}`;
+    return { present: true, valid: true, values, remainder };
+}
+function hasHudOwnerMetadataAttempt(command) {
+    return parsePowerShellHudEnvPrefix(command).present || parsePosixHudEnvAssignments(command).attempted;
+}
+function isInvalidHudOwnerValue(key, value) {
+    return value === '' || (key === OMX_TMUX_HUD_OWNER_ENV && value !== '1');
+}
+function parseHudEnvAssignment(command, key) {
+    const posix = parsePosixHudEnvAssignments(command);
+    const powerShellPrefix = parsePowerShellHudEnvPrefix(command);
+    if (powerShellPrefix.present)
+        return powerShellPrefix.valid ? (powerShellPrefix.values.get(key.toUpperCase())?.length === 1 ? powerShellPrefix.values.get(key.toUpperCase())[0] : undefined) : undefined;
+    return posix.valid ? parseShellEnvAssignment(command, key) : undefined;
+}
+function hasAmbiguousHudOwnerMetadata(command) {
+    const posix = parsePosixHudEnvAssignments(command);
+    const powerShellPrefix = parsePowerShellHudEnvPrefix(command);
+    if (powerShellPrefix.present) {
+        if (!powerShellPrefix.valid
+            || posix.values.size > 0
+            || containsPowerShellHudOwnerReferenceOutsideQuotes(powerShellPrefix.remainder)
+            || parsePosixHudEnvAssignments(powerShellPrefix.remainder).attempted)
+            return true;
+        return HUD_OWNER_ENV_KEYS.some((key) => {
+            const values = powerShellPrefix.values.get(key) ?? [];
+            return values.length > 1 || (values.length === 1 && isInvalidHudOwnerValue(key, values[0]));
+        });
+    }
+    if (posix.attempted && (!posix.valid || posix.values.size === 0))
+        return true;
+    return HUD_OWNER_ENV_KEYS.some((key) => {
+        const values = posix.values.get(key) ?? [];
+        return values.length > 1 || (values.length === 1 && isInvalidHudOwnerValue(key, values[0]));
+    });
 }
 export function readHudPaneOwner(pane) {
     const command = `${pane.startCommand} ${pane.currentCommand}`;
+    const rawLeaderPaneId = parseHudEnvAssignment(command, OMX_TMUX_HUD_LEADER_PANE_ENV);
+    if (hasAmbiguousHudOwnerMetadata(command)
+        || (rawLeaderPaneId !== undefined && !parseCanonicalTmuxPaneId(rawLeaderPaneId))) {
+        return { sessionId: undefined, leaderPaneId: undefined };
+    }
     return {
-        sessionId: parseShellEnvAssignment(command, 'OMX_SESSION_ID'),
-        leaderPaneId: parseShellEnvAssignment(command, OMX_TMUX_HUD_LEADER_PANE_ENV),
+        sessionId: parseHudEnvAssignment(command, 'OMX_SESSION_ID'),
+        leaderPaneId: rawLeaderPaneId ? parseCanonicalTmuxPaneId(rawLeaderPaneId) ?? undefined : undefined,
     };
 }
 function hasHudPaneOwnerMetadata(pane) {
     const command = `${pane.startCommand} ${pane.currentCommand}`;
-    const owner = readHudPaneOwner(pane);
-    return parseShellEnvAssignment(command, OMX_TMUX_HUD_OWNER_ENV) === '1'
-        || Boolean(owner.sessionId || owner.leaderPaneId);
+    return hasHudOwnerMetadataAttempt(command) && !hasAmbiguousHudOwnerMetadata(command);
+}
+export function hasValidHudOwnerMarker(pane) {
+    const command = `${pane.startCommand} ${pane.currentCommand}`;
+    if (hasAmbiguousHudOwnerMetadata(command))
+        return false;
+    return parseHudEnvAssignment(command, OMX_TMUX_HUD_OWNER_ENV) === '1';
 }
 function hasOmxCliToken(command) {
     return /(?:^|[\s'"])(?:[^\s'"]*\/)?omx(?:\.js)?(?=$|[\s'"])/.test(command);
 }
+function hasPowerShellEnvironmentAssignmentPrefix(command) {
+    return /^\s*(?:\$env:[A-Za-z_][A-Za-z0-9_]*\s*=\s*(?:'(?:''|[^'])*'|"(?:`.|[^"])*")\s*;\s*)+&(?:\s|$)/i.test(command);
+}
 function isLegacyFocusedHudWatchPane(pane) {
     // Migration-only heuristic for prompt-submit auto-HUD reconciliation: older
     // focused auto-HUD panes lacked owner metadata, so keep this deliberately
     // narrower than general HUD ownership/reaping.
-    if (!isHudWatchPane(pane) || hasHudPaneOwnerMetadata(pane))
-        return false;
     const command = `${pane.startCommand} ${pane.currentCommand}`;
+    if (!isHudWatchPane(pane)
+        || hasHudOwnerMetadataAttempt(command)
+        || hasPowerShellEnvironmentAssignmentPrefix(command))
+        return false;
     return hasOmxCliToken(command)
         && !/(?:^|[\s'"])--tmux(?:[\s'"]|$)/.test(command)
         && /(?:^|[\s'"])--preset=focused(?:[\s'"]|$)/.test(command);
 }
 export function findLegacyFocusedHudWatchPaneIds(panes, currentPaneId) {
-    return panes
-        .filter((pane) => pane.paneId !== currentPaneId)
+    const canonicalPanes = canonicalizePaneSnapshotBatch(panes);
+    const canonicalCurrentPaneId = currentPaneId ? parseCanonicalTmuxPaneId(currentPaneId) : null;
+    if (!canonicalPanes || (currentPaneId && !canonicalCurrentPaneId))
+        return [];
+    return canonicalPanes
+        .filter((pane) => pane.paneId !== canonicalCurrentPaneId)
         .filter((pane) => isLegacyFocusedHudWatchPane(pane))
         .map((pane) => pane.paneId);
 }
 export function hudPaneMatchesOwner(pane, owner = {}) {
-    if (!isHudWatchPane(pane))
+    if (!parseCanonicalTmuxPaneId(pane.paneId) || !isHudWatchPane(pane))
         return false;
     const wantedSessionIds = [
         typeof owner.sessionId === 'string' ? owner.sessionId.trim() : '',
@@ -146,11 +484,16 @@ export function hudPaneMatchesOwner(pane, owner = {}) {
     ]
         .map((sessionId) => sessionId.trim())
         .filter((sessionId, index, sessionIds) => sessionId !== '' && sessionIds.indexOf(sessionId) === index);
-    const wantedLeaderPaneId = typeof owner.leaderPaneId === 'string' ? owner.leaderPaneId.trim() : '';
+    const rawWantedLeaderPaneId = typeof owner.leaderPaneId === 'string' ? owner.leaderPaneId : '';
+    const wantedLeaderPaneId = rawWantedLeaderPaneId ? parseCanonicalTmuxPaneId(rawWantedLeaderPaneId) : null;
+    if (rawWantedLeaderPaneId && !wantedLeaderPaneId)
+        return false;
     const wantsSession = wantedSessionIds.length > 0;
-    const wantsLeaderPane = wantedLeaderPaneId !== '';
+    const wantsLeaderPane = wantedLeaderPaneId !== null;
     if (!wantsSession && !wantsLeaderPane)
         return true;
+    if (hasAmbiguousHudOwnerMetadata(`${pane.startCommand} ${pane.currentCommand}`))
+        return false;
     const paneOwner = readHudPaneOwner(pane);
     const sessionMatches = wantsSession && wantedSessionIds.includes(paneOwner.sessionId ?? '');
     const leaderPaneMatches = wantsLeaderPane && paneOwner.leaderPaneId === wantedLeaderPaneId;
@@ -165,8 +508,12 @@ export function hudPaneMatchesOwner(pane, owner = {}) {
     return leaderPaneMatches;
 }
 export function findHudWatchPaneIds(panes, currentPaneId, owner = {}) {
-    return panes
-        .filter((pane) => pane.paneId !== currentPaneId)
+    const canonicalPanes = canonicalizePaneSnapshotBatch(panes);
+    const canonicalCurrentPaneId = currentPaneId ? parseCanonicalTmuxPaneId(currentPaneId) : null;
+    if (!canonicalPanes || (currentPaneId && !canonicalCurrentPaneId))
+        return [];
+    return canonicalPanes
+        .filter((pane) => pane.paneId !== canonicalCurrentPaneId)
         .filter((pane) => hudPaneMatchesOwner(pane, owner))
         .map((pane) => pane.paneId);
 }
@@ -184,8 +531,13 @@ function isDoctorSmokeSessionId(sessionId) {
 function shouldReapDeletedCwdHudPane(pane, isLivePane) {
     // A deleted tmux launch cwd is not enough to prove a HUD is dead: watch mode can
     // keep serving from a resolved live cwd. Reap only explicit doctor smoke panes or
-    // owner-tagged panes whose leader is gone.
-    if (!hasHudPaneOwnerMetadata(pane) || !hasDeletedTmuxPaneMarker(pane.currentPath))
+    // owner-tagged panes whose canonical leader is gone.
+    const command = `${pane.startCommand} ${pane.currentCommand}`;
+    const rawLeaderPaneId = parseHudEnvAssignment(command, OMX_TMUX_HUD_LEADER_PANE_ENV);
+    if (!hasHudPaneOwnerMetadata(pane)
+        || !hasDeletedTmuxPaneMarker(pane.currentPath)
+        || hasAmbiguousHudOwnerMetadata(command)
+        || (rawLeaderPaneId !== undefined && !parseCanonicalTmuxPaneId(rawLeaderPaneId)))
         return false;
     const owner = readHudPaneOwner(pane);
     if (isDoctorSmokeSessionId(owner.sessionId))
@@ -195,18 +547,27 @@ function shouldReapDeletedCwdHudPane(pane, isLivePane) {
     return !owner.leaderPaneId || !isLivePane(owner.leaderPaneId);
 }
 export function reapDeadHudPanes(panes, opts = {}) {
-    const livePaneIds = new Set(panes.map((pane) => pane.paneId));
+    const canonicalPanes = canonicalizePaneSnapshotBatch(panes);
+    if (!canonicalPanes)
+        return { reaped: [], preserved: panes.map((pane) => pane.paneId) };
+    const livePaneIds = new Set(canonicalPanes.map((pane) => pane.paneId));
     const isLivePane = opts.isLivePane ?? ((paneId) => livePaneIds.has(paneId));
     const killPane = opts.killPane ?? ((paneId) => killTmuxPane(paneId));
     const reaped = [];
     const preserved = [];
-    for (const pane of panes) {
+    for (const pane of canonicalPanes) {
         if (!isHudWatchPane(pane))
             continue;
         if (shouldReapDeletedCwdHudPane(pane, isLivePane) && killPane(pane.paneId)) {
             reaped.push(pane.paneId);
             continue;
         }
+        // Never let HUD-looking command text authorize a destructive pane mutation.
+        // Only metadata accepted by the strict owner parsers may do so.
+        if (!hasHudPaneOwnerMetadata(pane)) {
+            preserved.push(pane.paneId);
+            continue;
+        }
         const leaderPaneId = readHudPaneOwner(pane).leaderPaneId;
         if (!leaderPaneId) {
             preserved.push(pane.paneId);
@@ -226,8 +587,10 @@ export function reapDeadHudPanes(panes, opts = {}) {
     return { reaped, preserved };
 }
 export function parsePaneIdFromTmuxOutput(rawOutput) {
-    const paneId = rawOutput.split('\n')[0]?.trim() || '';
-    return paneId.startsWith('%') ? paneId : null;
+    const lines = rawOutput.split('\n');
+    if (lines.at(-1) === '')
+        lines.pop();
+    return lines.length === 1 ? parseCanonicalTmuxPaneId(lines[0]) : null;
 }
 export function shellEscapeSingle(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -242,9 +605,6 @@ function isTmuxSessionId(value) {
 function isTmuxWindowId(value) {
     return /^@\d+$/.test(value);
 }
-function isTmuxPaneId(value) {
-    return /^%\d+$/.test(value);
-}
 export function buildHudResizeHookName(sessionId, windowId, leaderPaneId) {
     return [
         'omx_hud_resize',
@@ -253,13 +613,6 @@ export function buildHudResizeHookName(sessionId, windowId, leaderPaneId) {
         normalizeTmuxHookToken(leaderPaneId),
     ].join('_');
 }
-function buildLegacyHudResizeHookName(sessionId, windowId) {
-    return [
-        'omx_hud_resize',
-        normalizeTmuxHookToken(sessionId),
-        normalizeTmuxHookToken(windowId),
-    ].join('_');
-}
 export function buildHudResizeHookSlot(hookName) {
     let hash = 0;
     for (let i = 0; i < hookName.length; i++) {
@@ -274,35 +627,101 @@ export function buildHudLayoutHookSlot(hookName) {
     }
     return `window-layout-changed[${Math.abs(hash) % TMUX_HOOK_INDEX_MAX}]`;
 }
-export function parseHudResizeHookContext(output, leaderPaneId) {
-    const [sessionId = '', windowId = ''] = output
-        .split('\n')[0]
-        ?.split('\t')
-        .map((part) => part.trim()) ?? [];
-    const normalizedLeaderPaneId = leaderPaneId.trim();
-    if (!isTmuxSessionId(sessionId) || !isTmuxWindowId(windowId) || !isTmuxPaneId(normalizedLeaderPaneId))
+function hudHookIdentityOption(hookSlot) {
+    const match = /^(client-resized|window-layout-changed)\[([0-9]+)\]$/.exec(hookSlot);
+    if (!match)
+        throw new Error('invalid_tmux_hook_slot');
+    return `@omx_hook_identity_${match[1].replaceAll('-', '_')}_${match[2]}`;
+}
+function hudHookIdentityToken(hookName, hookSlot) {
+    let hash = 2166136261;
+    for (const char of `${hookName}:${hookSlot}`)
+        hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
+    return `omx-${(hash >>> 0).toString(16)}`;
+}
+function buildHudHookRegistrationSuffix(context, hookSlot) {
+    return [
+        '\\;', 'set-option', '-t', context.sessionId,
+        hudHookIdentityOption(hookSlot), hudHookIdentityToken(context.hookName, hookSlot),
+    ];
+}
+function buildGuardedHudHookUnregisterArgs(context, hookSlot) {
+    const identityOption = hudHookIdentityOption(hookSlot);
+    return [
+        'if-shell', '-F', '-t', context.sessionId,
+        `#{==:${identityOption},${hudHookIdentityToken(context.hookName, hookSlot)}}`,
+        `set-hook -u -t ${context.sessionId} ${hookSlot} \\; set-option -u -t ${context.sessionId} ${identityOption}`,
+        '',
+    ];
+}
+function readHudResizeHookPaneIncarnations(hudPaneId, leaderPaneId, execTmuxSync) {
+    try {
+        const lines = parseExactTmuxAuthorityLines(execTmuxSync(['list-panes', '-a', '-F', '#{pane_id} #{pane_dead} #{pane_pid}']));
+        if (!lines)
+            return null;
+        const seen = new Set();
+        let leaderPanePid = null;
+        let hudPanePid = null;
+        for (const line of lines) {
+            const match = /^(%\S+) ([01]) ([1-9][0-9]*)$/.exec(line);
+            const paneId = match ? parseCanonicalTmuxPaneId(match[1]) : null;
+            if (!match || !paneId || paneId !== match[1] || seen.has(paneId))
+                return null;
+            seen.add(paneId);
+            if (match[2] === '1')
+                continue;
+            if (paneId === leaderPaneId)
+                leaderPanePid = match[3];
+            if (paneId === hudPaneId)
+                hudPanePid = match[3];
+        }
+        return leaderPanePid && hudPanePid ? { leaderPanePid, hudPanePid } : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function parseHudResizeHookContext(output, leaderPaneId, hudPaneId = leaderPaneId, incarnations = { leaderPanePid: '1', hudPanePid: '1' }) {
+    const line = parseExactTmuxAuthorityScalar(output);
+    if (line === null)
+        return null;
+    const parts = line.split('\t');
+    if (parts.length !== 2 || parts.some((part) => part.trim() !== part || part === ''))
+        return null;
+    const [sessionId = '', windowId = ''] = parts;
+    const normalizedLeaderPaneId = parseCanonicalTmuxPaneId(leaderPaneId);
+    const normalizedHudPaneId = parseCanonicalTmuxPaneId(hudPaneId);
+    if (!isTmuxSessionId(sessionId) || !isTmuxWindowId(windowId) || !normalizedLeaderPaneId || !normalizedHudPaneId)
         return null;
     const hookName = buildHudResizeHookName(sessionId, windowId, normalizedLeaderPaneId);
     return {
         sessionId,
         windowId,
         leaderPaneId: normalizedLeaderPaneId,
+        leaderPanePid: incarnations.leaderPanePid,
+        hudPaneId: normalizedHudPaneId,
+        hudPanePid: incarnations.hudPanePid,
         hookName,
         hookSlot: buildHudResizeHookSlot(hookName),
         layoutHookSlot: buildHudLayoutHookSlot(hookName),
     };
 }
-export function readHudResizeHookContext(leaderPaneId, execTmuxSync = defaultExecTmuxSync) {
-    if (!leaderPaneId || !isTmuxPaneId(leaderPaneId))
+export function readHudResizeHookContext(hudPaneId, leaderPaneId, execTmuxSync = defaultExecTmuxSync) {
+    const canonicalLeaderPaneId = parseCanonicalTmuxPaneId(leaderPaneId);
+    const canonicalHudPaneId = parseCanonicalTmuxPaneId(hudPaneId);
+    if (!canonicalLeaderPaneId || !canonicalHudPaneId)
+        return null;
+    const incarnations = readHudResizeHookPaneIncarnations(canonicalHudPaneId, canonicalLeaderPaneId, execTmuxSync);
+    if (!incarnations)
         return null;
     try {
         return parseHudResizeHookContext(execTmuxSync([
             'display-message',
             '-p',
             '-t',
-            leaderPaneId,
+            canonicalLeaderPaneId,
             '#{session_id}\t#{window_id}',
-        ]), leaderPaneId);
+        ]), canonicalLeaderPaneId, canonicalHudPaneId, incarnations);
     }
     catch {
         return null;
@@ -312,22 +731,54 @@ function buildNestedTmuxCommand(tmuxBin, args, tmuxEnv) {
     const command = [tmuxBin, ...args].map((part) => shellEscapeSingle(part)).join(' ');
     return `${buildEnvPrefix({ TMUX: tmuxEnv })}${command}`;
 }
-function buildHudResizeHookCommand(tmuxBin, hudPaneId, height, context, tmuxEnv) {
-    const resize = buildNestedTmuxCommand(tmuxBin, ['resize-pane', '-t', hudPaneId, '-y', height], tmuxEnv);
-    const unregister = buildHudHookUnregisterCommand(tmuxBin, context, tmuxEnv);
-    const resizeOrUnregister = `${resize} >/dev/null 2>&1 || (${unregister})`;
-    return `${resizeOrUnregister}; sleep ${HUD_RESIZE_RECONCILE_DELAY_SECONDS}; ${resizeOrUnregister}`;
+function quoteHudHookShellArgument(value) {
+    return process.platform === 'win32'
+        ? `'${value.replace(/'/g, "''")}'`
+        : shellEscapeSingle(value);
+}
+function buildHudHookIncarnationCondition(paneId, panePid) {
+    return `#{&&:#{==:#{pane_id},${paneId}},#{&&:#{==:#{pane_dead},0},#{==:#{pane_pid},${panePid}}}}`;
+}
+function buildHudHookSelfUnregister(context) {
+    const identityOption = hudHookIdentityOption(context.hookSlot);
+    return `if-shell -F -t ${context.sessionId} ${quoteHudHookShellArgument(`#{==:${identityOption},${hudHookIdentityToken(context.hookName, context.hookSlot)}}`)} ${quoteHudHookShellArgument(`set-hook -u -t ${context.sessionId} ${context.hookSlot} \\; set-option -u -t ${context.sessionId} ${identityOption}`)} ''`;
 }
-function buildHudHookUnregisterCommand(tmuxBin, context, tmuxEnv) {
-    const unregisterResize = buildNestedTmuxCommand(tmuxBin, ['set-hook', '-u', '-t', context.sessionId, context.hookSlot], tmuxEnv);
-    const unregisterLayout = buildNestedTmuxCommand(tmuxBin, ['set-hook', '-u', '-t', context.sessionId, context.layoutHookSlot], tmuxEnv);
-    return `${unregisterResize} >/dev/null 2>&1 || true; ${unregisterLayout} >/dev/null 2>&1 || true`;
+function buildAtomicHudHookCommand(tmuxBin, context, success, tmuxEnv) {
+    const unregister = buildHudHookSelfUnregister(context);
+    const hudConditional = [
+        'if-shell', '-F', '-t', context.hudPaneId,
+        quoteHudHookShellArgument(buildHudHookIncarnationCondition(context.hudPaneId, context.hudPanePid)),
+        quoteHudHookShellArgument(success),
+        quoteHudHookShellArgument(unregister),
+    ].join(' ');
+    const args = [
+        'if-shell', '-F', '-t', context.leaderPaneId,
+        buildHudHookIncarnationCondition(context.leaderPaneId, context.leaderPanePid),
+        hudConditional,
+        unregister,
+    ];
+    if (process.platform === 'win32') {
+        const quotePowerShell = (value) => `'${value.replace(/'/g, "''")}'`;
+        const invoke = `& ${quotePowerShell(tmuxBin)} ${args.map(quotePowerShell).join(' ')}`;
+        return tmuxEnv
+            ? `& { $env:TMUX = ${quotePowerShell(tmuxEnv)}; ${invoke} } | Out-Null`
+            : `${invoke} | Out-Null`;
+    }
+    const command = buildNestedTmuxCommand(tmuxBin, args, tmuxEnv);
+    return `${command} >/dev/null 2>&1 || true`;
+}
+function buildAtomicHudResizeCommand(tmuxBin, hudPaneId, height, context, tmuxEnv) {
+    return buildAtomicHudHookCommand(tmuxBin, context, `resize-pane -t ${hudPaneId} -y ${height}`, tmuxEnv);
+}
+function buildHudResizeHookCommand(tmuxBin, hudPaneId, height, context, tmuxEnv) {
+    const atomicResize = buildAtomicHudResizeCommand(tmuxBin, hudPaneId, height, context, tmuxEnv);
+    return process.platform === 'win32'
+        ? `${atomicResize}; Start-Sleep -Seconds ${HUD_RESIZE_RECONCILE_DELAY_SECONDS}; ${atomicResize}`
+        : `${atomicResize}; sleep ${HUD_RESIZE_RECONCILE_DELAY_SECONDS}; ${atomicResize}`;
 }
 function buildHudLayoutReconcileHookCommand(tmuxBin, omxBin, leaderPaneId, context, options = {}) {
     const env = options.env ?? process.env;
     const cwd = options.cwd?.trim() || process.cwd();
-    const leaderAlive = buildNestedTmuxCommand(tmuxBin, ['display-message', '-p', '-t', leaderPaneId, '#{pane_id}'], env.TMUX);
-    const unregister = buildHudHookUnregisterCommand(tmuxBin, context, env.TMUX);
     const reconcileEnv = buildEnvPrefix({
         TMUX: env.TMUX,
         TMUX_PANE: leaderPaneId,
@@ -346,19 +797,20 @@ function buildHudLayoutReconcileHookCommand(tmuxBin, omxBin, leaderPaneId, conte
         'hud',
         '--reconcile-tmux',
     ].join(' ');
-    return `${leaderAlive} >/dev/null 2>&1 && (${unregister}; ${reconcile} >/dev/null 2>&1; status=$?; exit $status) || (${unregister})`;
+    const layoutContext = { ...context, hookSlot: context.layoutHookSlot };
+    if (process.platform === 'win32') {
+        const nativeReconcile = `Set-Location -LiteralPath '${cwd.replace(/'/g, "''")}'; & '${process.execPath.replace(/'/g, "''")}' '${omxBin.replace(/'/g, "''")}' hud --reconcile-tmux | Out-Null`;
+        const success = `${buildHudHookSelfUnregister(layoutContext)} \\; run-shell -b ${quoteHudHookShellArgument(nativeReconcile)}`;
+        return buildAtomicHudHookCommand(tmuxBin, layoutContext, success, env.TMUX);
+    }
+    const success = `${buildHudHookSelfUnregister(layoutContext)} \\; run-shell -b ${quoteHudHookShellArgument(`${reconcile} >/dev/null 2>&1`)}`;
+    return buildAtomicHudHookCommand(tmuxBin, layoutContext, success, env.TMUX);
 }
 function unregisterLegacyHudResizeHook(context, execTmuxSync) {
-    const legacyHookSlot = buildHudResizeHookSlot(buildLegacyHudResizeHookName(context.sessionId, context.windowId));
-    if (legacyHookSlot === context.hookSlot)
-        return;
-    try {
-        execTmuxSync(['set-hook', '-u', '-t', context.sessionId, legacyHookSlot]);
-    }
-    catch {
-        // Best-effort migration cleanup: failure should not prevent the new
-        // leader-scoped hook from being registered or unregistered.
-    }
+    // Legacy registrations predate identity metadata. Leaving them untouched is
+    // safer than clearing a slot that may now belong to another registration.
+    void context;
+    void execTmuxSync;
 }
 function buildEnvPrefix(env) {
     const assignments = Object.entries(env)
@@ -367,9 +819,34 @@ function buildEnvPrefix(env) {
         .map(([key, value]) => `${key}=${shellEscapeSingle(value)}`);
     return assignments.length > 0 ? `env ${assignments.join(' ')} ` : '';
 }
+/** The sole platform-aware serializer for tmux HUD watch commands. */
+export function writeHudWatchCommand(options) {
+    const safePreset = options.preset === 'minimal' || options.preset === 'focused' || options.preset === 'full'
+        ? `--preset=${options.preset}`
+        : undefined;
+    const platform = options.platform ?? process.platform;
+    const presetArgument = safePreset ? ` ${shellEscapeSingle(safePreset)}` : '';
+    if (platform === 'win32') {
+        const quotePowerShell = (value) => `'${value.replace(/'/g, "''")}'`;
+        const assignments = Object.entries(options.runtimeEnv)
+            .map(([key, value]) => `$env:${key} = ${quotePowerShell(value)}`)
+            .join('; ');
+        const invocation = ['&', quotePowerShell(options.nodeCommand), quotePowerShell(options.omxEntry), 'hud', '--watch', ...(safePreset ? [safePreset] : [])].join(' ');
+        const script = `${assignments}; ${invocation}`;
+        return options.powerShellEnvelope
+            ? `powershell.exe -NoLogo -NoExit -Command ${quotePowerShell(script)}`
+            : script;
+    }
+    const assignments = Object.entries(options.runtimeEnv)
+        .map(([key, value]) => `${key}=${key === OMX_TMUX_HUD_OWNER_ENV && !options.quoteOwnerValue ? value : shellEscapeSingle(value)}`)
+        .join(' ');
+    const nodeCommand = options.nodeCommand === 'node' ? 'node' : shellEscapeSingle(options.nodeCommand);
+    return `exec ${assignments ? `env ${assignments} ` : ''}${nodeCommand} ${shellEscapeSingle(options.omxEntry)} hud --watch${presetArgument}`;
+}
 export function buildHudRuntimeEnv(input = {}) {
     const sessionId = typeof input.sessionId === 'string' ? input.sessionId.trim() : '';
-    const leaderPaneId = typeof input.leaderPaneId === 'string' ? input.leaderPaneId.trim() : '';
+    const rawLeaderPaneId = typeof input.leaderPaneId === 'string' ? input.leaderPaneId : '';
+    const leaderPaneId = rawLeaderPaneId ? parseCanonicalTmuxPaneId(rawLeaderPaneId) : null;
     const env = {};
     if (sessionId)
         env.OMX_SESSION_ID = sessionId;
@@ -393,23 +870,40 @@ export function buildHudRuntimeEnv(input = {}) {
         },
     };
 }
-export function buildHudWatchCommand(omxBin, preset, sessionId, omxRoot, leaderPaneId, rootEnv) {
-    const safePreset = preset === 'minimal' || preset === 'focused' || preset === 'full'
-        ? ` --preset=${preset}`
-        : '';
-    const envPrefix = buildEnvPrefix(buildHudRuntimeEnv({
+export function buildHudWatchCommand(omxBin, preset, sessionId, omxRoot, leaderPaneId, rootEnv, platform = process.platform) {
+    const runtimeEnv = buildHudRuntimeEnv({
         sessionId,
         leaderPaneId,
         omxRoot,
         ...(rootEnv ?? { rootSource: 'omx-root-env' }),
-    }).env);
-    return `exec ${envPrefix}${shellEscapeSingle(process.execPath)} ${shellEscapeSingle(omxBin)} hud --watch${safePreset}`;
+    }).env;
+    return writeHudWatchCommand({
+        omxEntry: omxBin,
+        runtimeEnv,
+        nodeCommand: process.execPath,
+        preset,
+        platform,
+        powerShellEnvelope: platform === 'win32',
+        quoteOwnerValue: true,
+    });
 }
 export function listCurrentWindowPanes(execTmuxSync = defaultExecTmuxSync, currentPaneId) {
+    const canonicalCurrentPaneId = currentPaneId ? parseCanonicalTmuxPaneId(currentPaneId) : null;
+    if (currentPaneId && !canonicalCurrentPaneId)
+        return [];
+    const targetArgs = canonicalCurrentPaneId ? ['-t', canonicalCurrentPaneId] : [];
     try {
-        return parseTmuxPaneSnapshot(execTmuxSync([
+        const paneIds = parseCanonicalPaneIdSnapshot(execTmuxSync([
+            'list-panes',
+            ...targetArgs,
+            '-F',
+            '#{pane_id}',
+        ]));
+        if (!paneIds)
+            return [];
+        const paneSnapshotOutput = execTmuxSync([
             'list-panes',
-            ...(currentPaneId ? ['-t', currentPaneId] : []),
+            ...targetArgs,
             '-F',
             [
                 '#{pane_id}',
@@ -423,8 +917,13 @@ export function listCurrentWindowPanes(execTmuxSync = defaultExecTmuxSync, curre
                 '#{window_height}',
                 '#{pane_start_command}',
                 '#{pane_current_path}',
+                '#{pane_dead}',
+                '#{pane_pid}',
             ].join(TMUX_PANE_FIELD_SEPARATOR),
-        ]));
+        ]);
+        if (!parseExactTmuxAuthorityLines(paneSnapshotOutput))
+            return [];
+        return parseTmuxPaneSnapshot(paneSnapshotOutput, paneIds);
     }
     catch {
         return [];
@@ -432,7 +931,8 @@ export function listCurrentWindowPanes(execTmuxSync = defaultExecTmuxSync, curre
 }
 export function readActiveTmuxPaneId(execTmuxSync = defaultExecTmuxSync) {
     try {
-        return parsePaneIdFromTmuxOutput(execTmuxSync(['display-message', '-p', '#{pane_id}']));
+        const paneId = parseExactTmuxAuthorityScalar(execTmuxSync(['display-message', '-p', '#{pane_id}']));
+        return parseCanonicalTmuxPaneId(paneId);
     }
     catch {
         return null;
@@ -442,56 +942,421 @@ export function listCurrentWindowHudPaneIds(currentPaneId, execTmuxSync = defaul
     return findHudWatchPaneIds(listCurrentWindowPanes(execTmuxSync, currentPaneId), currentPaneId, owner);
 }
 export function readCurrentWindowSize(execTmuxSync = defaultExecTmuxSync, currentPaneId) {
+    const canonicalCurrentPaneId = currentPaneId ? parseCanonicalTmuxPaneId(currentPaneId) : null;
+    if (currentPaneId && !canonicalCurrentPaneId)
+        return { width: null, height: null };
     try {
         const raw = execTmuxSync([
             'display-message',
             '-p',
-            ...(currentPaneId ? ['-t', currentPaneId] : []),
+            ...(canonicalCurrentPaneId ? ['-t', canonicalCurrentPaneId] : []),
             '#{window_width}\t#{window_height}',
         ]);
-        const [widthRaw = '', heightRaw = ''] = raw.split('\t');
-        const width = Number.parseInt(widthRaw.trim(), 10);
-        const height = Number.parseInt(heightRaw.trim(), 10);
-        return {
-            width: Number.isFinite(width) && width > 0 ? width : null,
-            height: Number.isFinite(height) && height > 0 ? height : null,
-        };
+        const framed = parseExactTmuxAuthorityScalar(raw);
+        if (framed === null)
+            return { width: null, height: null };
+        const fields = framed.split('\t');
+        if (fields.length !== 2)
+            return { width: null, height: null };
+        const width = parsePositiveInteger(fields[0]);
+        const height = parsePositiveInteger(fields[1]);
+        return { width, height };
     }
     catch {
         return { width: null, height: null };
     }
 }
+function readHudSplitSourceAuthority(targetPaneId, execTmuxSync) {
+    try {
+        const source = parseExactTmuxAuthorityScalar(execTmuxSync([
+            'display-message',
+            '-p',
+            ...(targetPaneId ? ['-t', targetPaneId] : []),
+            '#{pane_id}\t#{pane_dead}\t#{pane_pid}\t#{session_id}\t#{window_id}',
+        ]));
+        if (!source)
+            return null;
+        const fields = source.split('\t');
+        if (fields.length !== 5)
+            return null;
+        const paneId = parseCanonicalTmuxPaneId(fields[0]);
+        const paneDead = fields[1];
+        const panePid = fields[2];
+        const sessionId = fields[3];
+        const windowId = fields[4];
+        if (!paneId
+            || (targetPaneId && paneId !== targetPaneId)
+            || paneDead !== '0'
+            || !/^[1-9][0-9]*$/.test(panePid ?? '')
+            || !isTmuxSessionId(sessionId ?? '')
+            || !isTmuxWindowId(windowId ?? ''))
+            return null;
+        return { paneId, panePid: panePid, sessionId: sessionId, windowId: windowId };
+    }
+    catch {
+        return null;
+    }
+}
+function buildHudSplitSourceCondition(source) {
+    return `#{&&:#{==:#{pane_id},${source.paneId}},#{&&:#{==:#{pane_dead},0},#{&&:#{==:#{pane_pid},${source.panePid}},#{&&:#{==:#{session_id},${source.sessionId}},#{==:#{window_id},${source.windowId}}}}}}`;
+}
+const hudSplitAuthorities = new Map();
+function readCanonicalPaneIdSnapshot(execTmuxSync, targetPaneId, global = false) {
+    try {
+        return parseCanonicalPaneIdSnapshot(execTmuxSync([
+            'list-panes',
+            ...(global ? ['-a'] : targetPaneId ? ['-t', targetPaneId] : []),
+            '-F',
+            '#{pane_id}',
+        ]));
+    }
+    catch {
+        return null;
+    }
+}
+function deriveSingleNewPane(before, after) {
+    if (after.size !== before.size + 1 || ![...before].every((paneId) => after.has(paneId)))
+        return null;
+    const created = [...after].filter((paneId) => !before.has(paneId));
+    return created.length === 1 ? created[0] ?? null : null;
+}
+const OMX_TMUX_SPLIT_OPERATION_MARKER_ENV = 'OMX_TMUX_SPLIT_OPERATION_MARKER';
+function writeHudSplitOperationMarkedCommand(command, marker) {
+    if (process.platform === 'win32')
+        return `$env:${OMX_TMUX_SPLIT_OPERATION_MARKER_ENV} = '${marker}'; ${command}`;
+    return `${OMX_TMUX_SPLIT_OPERATION_MARKER_ENV}='${marker}'; export ${OMX_TMUX_SPLIT_OPERATION_MARKER_ENV}; ${command}`;
+}
+function hasHudSplitOperationMarker(startCommand, marker) {
+    const posixMarker = `${OMX_TMUX_SPLIT_OPERATION_MARKER_ENV}='${marker}'`;
+    const powerShellMarker = `$env:${OMX_TMUX_SPLIT_OPERATION_MARKER_ENV} = '${marker}'`;
+    return startCommand === posixMarker
+        || startCommand.startsWith(`${posixMarker};`)
+        || startCommand === powerShellMarker
+        || startCommand.startsWith(`${powerShellMarker};`);
+}
+function findHudSplitOperationMarkerPaneId(marker, execTmuxSync) {
+    try {
+        const lines = parseExactTmuxAuthorityLines(execTmuxSync(['list-panes', '-a', '-F', '#{pane_id}\t#{pane_start_command}']));
+        if (!lines)
+            return null;
+        let candidate = null;
+        const seen = new Set();
+        for (const rawLine of lines) {
+            const fields = rawLine.split('\t');
+            if (fields.length !== 2)
+                return null;
+            const paneId = parseCanonicalTmuxPaneId(fields[0]);
+            if (!paneId || paneId !== fields[0] || seen.has(paneId))
+                return null;
+            seen.add(paneId);
+            const command = fields[1] ?? '';
+            if (!hasHudSplitOperationMarker(command, marker))
+                continue;
+            if (candidate)
+                return null;
+            candidate = paneId;
+        }
+        return candidate;
+    }
+    catch {
+        return null;
+    }
+}
+function recoverHudSplitPaneId(globalBefore, targetBefore, targetPaneId, marker, execTmuxSync) {
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        const globalAfter = readCanonicalPaneIdSnapshot(execTmuxSync, undefined, true);
+        const targetAfter = targetPaneId ? readCanonicalPaneIdSnapshot(execTmuxSync, targetPaneId) : null;
+        const globalCandidate = globalAfter ? deriveSingleNewPane(globalBefore, globalAfter) : null;
+        const targetCandidate = targetPaneId ? (targetAfter ? deriveSingleNewPane(targetBefore, targetAfter) : null) : globalCandidate;
+        const markerCandidate = findHudSplitOperationMarkerPaneId(marker, execTmuxSync);
+        if (globalCandidate && globalCandidate === targetCandidate && markerCandidate === globalCandidate)
+            return globalCandidate;
+        if (markerCandidate && !globalBefore.has(markerCandidate))
+            return markerCandidate;
+        if (attempt < 2)
+            sleepSync(50);
+    }
+    return null;
+}
+function sleepSync(milliseconds) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+function readTmuxOptionExactly(execTmuxSync, option) {
+    try {
+        return parseExactTmuxAuthorityScalar(execTmuxSync(['show-options', '-g', '-v', option]));
+    }
+    catch {
+        return null;
+    }
+}
+function hasHudSplitAuthority(paneId, execTmuxSync = defaultExecTmuxSync) {
+    const authority = hudSplitAuthorities.get(paneId);
+    if (!authority)
+        return false;
+    const globalPanes = readCanonicalPaneIdSnapshot(execTmuxSync, undefined, true);
+    if (!globalPanes?.has(paneId))
+        return false;
+    if (authority.targetPaneId) {
+        const targetPanes = readCanonicalPaneIdSnapshot(execTmuxSync, authority.targetPaneId);
+        if (!targetPanes?.has(paneId))
+            return false;
+    }
+    const location = readHudPaneSessionAndWindow(paneId, execTmuxSync);
+    return (findHudSplitOperationMarkerPaneId(authority.operationMarker, execTmuxSync) === paneId
+        && readHudPaneIncarnation(paneId, execTmuxSync)?.panePid === authority.panePid
+        && location?.sessionId === authority.sessionId
+        && location?.windowId === authority.windowId
+        && readTmuxOptionExactly(execTmuxSync, authority.proofOption) === authority.proofValue);
+}
+function readHudPaneIncarnation(paneId, execTmuxSync) {
+    try {
+        const lines = parseExactTmuxAuthorityLines(execTmuxSync(['list-panes', '-a', '-F', '#{pane_id} #{pane_dead} #{pane_pid}']));
+        if (!lines)
+            return null;
+        const seenPaneIds = new Set();
+        let incarnation = null;
+        for (const line of lines) {
+            const match = /^(%\S+) ([01]) ([0-9]+)$/.exec(line);
+            const observedPaneId = match ? parseCanonicalTmuxPaneId(match[1]) : null;
+            if (!match || !observedPaneId || observedPaneId !== match[1] || seenPaneIds.has(observedPaneId))
+                return null;
+            seenPaneIds.add(observedPaneId);
+            if (match[2] === '1')
+                continue;
+            if (!/^[1-9][0-9]*$/.test(match[3]))
+                return null;
+            if (observedPaneId === paneId)
+                incarnation = { paneDead: false, panePid: match[3] };
+        }
+        return incarnation;
+    }
+    catch {
+        return null;
+    }
+}
+function isPaneLiveInStrictGlobalProbe(paneId, expectedPid, execTmuxSync) {
+    const incarnation = readHudPaneIncarnation(paneId, execTmuxSync);
+    return Boolean(incarnation && !incarnation.paneDead && (!expectedPid || incarnation.panePid === expectedPid));
+}
+/** Freshly validates retained split proof and sustained global liveness before a HUD mutation sink. */
+export function verifyHudWatchPaneAuthority(paneId, execTmuxSync = defaultExecTmuxSync) {
+    const canonicalPaneId = parseCanonicalTmuxPaneId(paneId);
+    if (!canonicalPaneId || !hasHudSplitAuthority(canonicalPaneId, execTmuxSync))
+        return false;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        if (attempt > 0)
+            sleepSync(100);
+        if (!hasHudSplitAuthority(canonicalPaneId, execTmuxSync)
+            || !isPaneLiveInStrictGlobalProbe(canonicalPaneId, hudSplitAuthorities.get(canonicalPaneId)?.panePid, execTmuxSync))
+            return false;
+    }
+    return true;
+}
+/** Kills only a pane still bound to this process's exact split proof. */
+export function rollbackHudWatchPaneAuthority(paneId, execTmuxSync = defaultExecTmuxSync) {
+    const canonicalPaneId = parseCanonicalTmuxPaneId(paneId);
+    const authority = canonicalPaneId ? hudSplitAuthorities.get(canonicalPaneId) : undefined;
+    if (!canonicalPaneId || !authority)
+        return false;
+    const killed = mutateHudWatchPaneIfCurrent(canonicalPaneId, authority.panePid, `kill-pane -t ${canonicalPaneId}`, execTmuxSync);
+    if (killed)
+        hudSplitAuthorities.delete(canonicalPaneId);
+    return killed;
+}
+function rollbackRecoveredHudSplitPane(paneId, proofOption, proofValue, operationMarker, panePid, sessionId, windowId, execTmuxSync = defaultExecTmuxSync) {
+    const canonicalPaneId = parseCanonicalTmuxPaneId(paneId);
+    if (!canonicalPaneId || canonicalPaneId !== paneId)
+        return false;
+    const pidCondition = panePid && /^[1-9][0-9]*$/.test(panePid) ? `#{&&:#{==:#{pane_pid},${panePid}},` : '';
+    const sessionCondition = sessionId && /^\$[0-9]+$/.test(sessionId) ? `#{&&:#{==:#{session_id},${sessionId}},` : '';
+    const windowCondition = windowId && /^@[0-9]+$/.test(windowId) ? `#{&&:#{==:#{window_id},${windowId}},` : '';
+    const closes = `${pidCondition ? '}' : ''}${sessionCondition ? '}' : ''}${windowCondition ? '}' : ''}`;
+    const receipt = `__omx_hud_rollback_${randomUUID()}`;
+    const condition = `#{&&:#{==:#{pane_id},${paneId}},#{&&:#{==:#{pane_dead},0},${pidCondition}${sessionCondition}${windowCondition}#{&&:#{==:#{${proofOption}},${proofValue}},#{m:*${operationMarker}*,#{pane_start_command}}}${closes}}`;
+    try {
+        return parseExactTmuxAuthorityScalar(execTmuxSync([
+            'if-shell', '-F', '-t', paneId,
+            condition,
+            `kill-pane -t ${paneId} \\; display-message -p ${receipt}`,
+            `display-message -p __omx_hud_rollback_rejected_${receipt}`,
+        ])) === receipt;
+    }
+    catch {
+        return false;
+    }
+}
 export function createHudWatchPane(cwd, hudCmd, options = {}, execTmuxSync = defaultExecTmuxSync) {
+    const canonicalTargetPaneId = options.targetPaneId ? parseCanonicalTmuxPaneId(options.targetPaneId) : null;
+    if (options.targetPaneId && !canonicalTargetPaneId)
+        return null;
+    const sourceAuthority = readHudSplitSourceAuthority(canonicalTargetPaneId, execTmuxSync);
+    if (!sourceAuthority)
+        return null;
+    const sourcePaneId = sourceAuthority.paneId;
+    const globalBefore = readCanonicalPaneIdSnapshot(execTmuxSync, undefined, true);
+    const targetBefore = readCanonicalPaneIdSnapshot(execTmuxSync, sourcePaneId);
+    if (!globalBefore || !targetBefore)
+        return null;
+    const operationMarker = randomUUID();
     const heightLines = Number.isFinite(options.heightLines) && (options.heightLines ?? 0) > 0
         ? Math.floor(options.heightLines ?? HUD_TMUX_HEIGHT_LINES)
         : HUD_TMUX_HEIGHT_LINES;
     const args = [
-        'split-window',
-        '-v',
-        ...(options.fullWidth ? ['-f'] : []),
-        '-l',
-        String(heightLines),
-        '-d',
-        ...(options.targetPaneId ? ['-t', options.targetPaneId] : []),
-        '-c',
-        cwd,
-        '-P',
-        '-F',
-        '#{pane_id}',
-        hudCmd,
+        'split-window', '-v', ...(options.fullWidth ? ['-f'] : []), '-l', String(heightLines), '-d',
+        '-t', sourcePaneId, '-c', shellEscapeSingle(cwd), writeHudSplitOperationMarkedCommand(hudCmd, operationMarker),
     ];
+    let paneId = null;
+    const nonce = randomUUID();
+    const proofOption = `@omx_hud_split_owner_nonce_${nonce}`;
+    const provisionalProof = `pending:${nonce}`;
+    const receipt = `__omx_hud_split_${randomUUID()}`;
+    const splitCommand = args.join(' ');
+    try {
+        execTmuxSync(['set-option', '-g', proofOption, provisionalProof]);
+        if (readTmuxOptionExactly(execTmuxSync, proofOption) !== provisionalProof)
+            return null;
+        const splitOutput = execTmuxSync([
+            'if-shell', '-F', '-t', sourcePaneId, buildHudSplitSourceCondition(sourceAuthority),
+            `${splitCommand} \\; display-message -p ${receipt}`,
+            `display-message -p __omx_hud_split_rejected_${receipt}`,
+        ]);
+        if (parseExactTmuxAuthorityScalar(splitOutput) !== receipt)
+            return null;
+        paneId = recoverHudSplitPaneId(globalBefore, targetBefore, sourcePaneId, operationMarker, execTmuxSync);
+        const incarnation = paneId ? readHudPaneIncarnation(paneId, execTmuxSync) : null;
+        const location = paneId ? readHudPaneSessionAndWindow(paneId, execTmuxSync) : null;
+        if (!paneId
+            || !incarnation
+            || !location
+            || location.sessionId !== sourceAuthority.sessionId
+            || location.windowId !== sourceAuthority.windowId) {
+            if (paneId) {
+                rollbackRecoveredHudSplitPane(paneId, proofOption, provisionalProof, operationMarker, incarnation?.panePid, location?.sessionId ?? sourceAuthority.sessionId, location?.windowId ?? sourceAuthority.windowId, execTmuxSync);
+            }
+            return null;
+        }
+        hudSplitAuthorities.set(paneId, {
+            proofOption,
+            proofValue: provisionalProof,
+            operationMarker,
+            panePid: incarnation.panePid,
+            sessionId: location.sessionId,
+            windowId: location.windowId,
+            targetPaneId: sourcePaneId,
+        });
+        if (!hasHudSplitAuthority(paneId, execTmuxSync)) {
+            rollbackHudWatchPaneAuthority(paneId, execTmuxSync);
+            return null;
+        }
+        const proofValue = `${paneId}:split:${nonce}`;
+        execTmuxSync(['set-option', '-g', proofOption, proofValue]);
+        hudSplitAuthorities.set(paneId, { proofOption, proofValue, operationMarker, panePid: incarnation.panePid, sessionId: location.sessionId, windowId: location.windowId, targetPaneId: sourcePaneId });
+        if (readTmuxOptionExactly(execTmuxSync, proofOption) !== proofValue) {
+            rollbackHudWatchPaneAuthority(paneId, execTmuxSync);
+            return null;
+        }
+        if (!verifyHudWatchPaneAuthority(paneId, execTmuxSync)) {
+            rollbackHudWatchPaneAuthority(paneId, execTmuxSync);
+            return null;
+        }
+        return paneId;
+    }
+    catch {
+        if (paneId) {
+            rollbackHudWatchPaneAuthority(paneId, execTmuxSync);
+        }
+        else {
+            const recoveredPaneId = recoverHudSplitPaneId(globalBefore, targetBefore, sourcePaneId, operationMarker, execTmuxSync);
+            if (recoveredPaneId) {
+                rollbackRecoveredHudSplitPane(recoveredPaneId, proofOption, provisionalProof, operationMarker, undefined, sourceAuthority.sessionId, sourceAuthority.windowId, execTmuxSync);
+            }
+        }
+        return null;
+    }
+}
+function readHudPaneSessionAndWindow(paneId, execTmuxSync) {
     try {
-        return parsePaneIdFromTmuxOutput(execTmuxSync(args));
+        const value = parseExactTmuxAuthorityScalar(execTmuxSync([
+            'display-message', '-p', '-t', paneId, '#{session_id}\t#{window_id}',
+        ]));
+        if (!value)
+            return null;
+        const [sessionId, windowId, ...extra] = value.split('\t');
+        return !extra.length && isTmuxSessionId(sessionId ?? '') && isTmuxWindowId(windowId ?? '')
+            ? { sessionId: sessionId, windowId: windowId }
+            : null;
     }
     catch {
         return null;
     }
 }
+/** Executes a split-owned pane mutation only while its immutable owner proof and exact incarnation remain current. */
+export function mutateHudWatchPaneIfCurrent(paneId, expectedPanePid, mutation, execTmuxSync = defaultExecTmuxSync) {
+    const canonicalPaneId = parseCanonicalTmuxPaneId(paneId);
+    const authority = canonicalPaneId ? hudSplitAuthorities.get(canonicalPaneId) : undefined;
+    if (!canonicalPaneId
+        || !authority
+        || authority.panePid !== expectedPanePid
+        || !/^[1-9][0-9]*$/.test(expectedPanePid)
+        || !/^(?:kill-pane|resize-pane) -t %(?:0|[1-9][0-9]*)(?: -y [1-9][0-9]*)?$/.test(mutation))
+        return false;
+    const marker = `__omx_hud_mutation_${randomUUID()}`;
+    const condition = `#{&&:#{==:#{pane_id},${canonicalPaneId}},#{&&:#{==:#{pane_dead},0},#{&&:#{==:#{pane_pid},${expectedPanePid}},#{&&:#{==:#{session_id},${authority.sessionId}},#{&&:#{==:#{window_id},${authority.windowId}},#{&&:#{==:#{${authority.proofOption}},${authority.proofValue}},#{m:*${authority.operationMarker}*,#{pane_start_command}}}}}}}`;
+    try {
+        const output = execTmuxSync([
+            'if-shell', '-F', '-t', canonicalPaneId,
+            condition,
+            `${mutation} \\; display-message -p ${marker}`,
+            `display-message -p __omx_hud_mutation_failed_${marker}`,
+        ]);
+        return parseExactTmuxAuthorityScalar(output) === marker;
+    }
+    catch {
+        return false;
+    }
+}
+/** Executes a retained pane mutation only while the exact target incarnation remains live. */
+function mutateTmuxPaneIfCurrent(paneId, expectedPanePid, mutation, execTmuxSync = defaultExecTmuxSync) {
+    const canonicalPaneId = parseCanonicalTmuxPaneId(paneId);
+    if (!canonicalPaneId || !/^[1-9][0-9]*$/.test(expectedPanePid))
+        return false;
+    const marker = `__omx_hud_mutation_${randomUUID()}`;
+    try {
+        const output = execTmuxSync([
+            'if-shell', '-F', '-t', canonicalPaneId,
+            buildHudHookIncarnationCondition(canonicalPaneId, expectedPanePid),
+            `${mutation} \\; display-message -p ${marker}`,
+            `display-message -p __omx_hud_mutation_failed_${marker}`,
+        ]);
+        return parseExactTmuxAuthorityScalar(output) === marker;
+    }
+    catch {
+        return false;
+    }
+}
+/** Kills a pane only while its exact live incarnation remains the target. */
+export function killTmuxPaneIfCurrent(paneId, expectedPanePid, execTmuxSync = defaultExecTmuxSync) {
+    const canonicalPaneId = parseCanonicalTmuxPaneId(paneId);
+    return canonicalPaneId
+        ? mutateTmuxPaneIfCurrent(canonicalPaneId, expectedPanePid, `kill-pane -t ${canonicalPaneId}`, execTmuxSync)
+        : false;
+}
+/** Resizes a pane only while its exact live incarnation remains the target. */
+export function resizeTmuxPaneIfCurrent(paneId, expectedPanePid, heightLines, execTmuxSync = defaultExecTmuxSync) {
+    const canonicalPaneId = parseCanonicalTmuxPaneId(paneId);
+    if (!canonicalPaneId)
+        return false;
+    const height = Number.isFinite(heightLines) && heightLines > 0
+        ? Math.floor(heightLines)
+        : HUD_TMUX_HEIGHT_LINES;
+    return mutateTmuxPaneIfCurrent(canonicalPaneId, expectedPanePid, `resize-pane -t ${canonicalPaneId} -y ${height}`, execTmuxSync);
+}
 export function killTmuxPane(paneId, execTmuxSync = defaultExecTmuxSync) {
-    if (!paneId.startsWith('%'))
+    const canonicalPaneId = parseCanonicalTmuxPaneId(paneId);
+    if (!canonicalPaneId)
         return false;
     try {
-        execTmuxSync(['kill-pane', '-t', paneId]);
+        execTmuxSync(['kill-pane', '-t', canonicalPaneId]);
         return true;
     }
     catch {
@@ -499,13 +1364,14 @@ export function killTmuxPane(paneId, execTmuxSync = defaultExecTmuxSync) {
     }
 }
 export function resizeTmuxPane(paneId, heightLines, execTmuxSync = defaultExecTmuxSync) {
-    if (!paneId.startsWith('%'))
+    const canonicalPaneId = parseCanonicalTmuxPaneId(paneId);
+    if (!canonicalPaneId)
         return false;
     const height = Number.isFinite(heightLines) && heightLines > 0
         ? Math.floor(heightLines)
         : HUD_TMUX_HEIGHT_LINES;
     try {
-        execTmuxSync(['resize-pane', '-t', paneId, '-y', String(height)]);
+        execTmuxSync(['resize-pane', '-t', canonicalPaneId, '-y', String(height)]);
         return true;
     }
     catch {
@@ -517,26 +1383,28 @@ export function registerHudResizeHook(hudPaneId, leaderPaneId, heightLines, opti
     const execTmuxSync = typeof optionsOrExecTmuxSync === 'function'
         ? optionsOrExecTmuxSync
         : (maybeExecTmuxSync ?? defaultExecTmuxSync);
-    if (!hudPaneId.startsWith('%'))
+    const canonicalHudPaneId = parseCanonicalTmuxPaneId(hudPaneId);
+    const canonicalLeaderPaneId = parseCanonicalTmuxPaneId(leaderPaneId);
+    if (!canonicalHudPaneId || !canonicalLeaderPaneId)
         return false;
-    const context = readHudResizeHookContext(leaderPaneId, execTmuxSync);
+    const context = readHudResizeHookContext(canonicalHudPaneId, canonicalLeaderPaneId, execTmuxSync);
     if (!context)
         return false;
     const tmuxBin = resolveTmuxBinaryForPlatform() || 'tmux';
     const height = String(Math.max(1, Math.floor(heightLines)));
-    const resizeCmd = shellEscapeSingle(buildHudResizeHookCommand(tmuxBin, hudPaneId, height, context, options.env?.TMUX));
+    const resizeCmd = shellEscapeSingle(buildHudResizeHookCommand(tmuxBin, canonicalHudPaneId, height, context, options.env?.TMUX));
     const omxBin = resolveOmxCliEntryPath({ cwd: options.cwd, env: options.env });
     try {
-        execTmuxSync(['set-hook', '-t', context.sessionId, context.hookSlot, `run-shell -b ${resizeCmd}`]);
+        execTmuxSync(['set-hook', '-t', context.sessionId, context.hookSlot, `run-shell -b ${resizeCmd}`, ...buildHudHookRegistrationSuffix(context, context.hookSlot)]);
         unregisterLegacyHudResizeHook(context, execTmuxSync);
     }
     catch {
         return false;
     }
-    if (omxBin && leaderPaneId?.startsWith('%')) {
+    if (omxBin) {
         try {
-            const reconcileCmd = shellEscapeSingle(buildHudLayoutReconcileHookCommand(tmuxBin, omxBin, leaderPaneId, context, options));
-            execTmuxSync(['set-hook', '-t', context.sessionId, context.layoutHookSlot, `run-shell -b ${reconcileCmd}`]);
+            const reconcileCmd = shellEscapeSingle(buildHudLayoutReconcileHookCommand(tmuxBin, omxBin, canonicalLeaderPaneId, context, options));
+            execTmuxSync(['set-hook', '-t', context.sessionId, context.layoutHookSlot, `run-shell -b ${reconcileCmd}`, ...buildHudHookRegistrationSuffix(context, context.layoutHookSlot)]);
         }
         catch {
             // Keep the resize hook installed so older tmux builds still recover on
@@ -547,19 +1415,29 @@ export function registerHudResizeHook(hudPaneId, leaderPaneId, heightLines, opti
     return true;
 }
 export function unregisterHudResizeHook(leaderPaneId, execTmuxSync = defaultExecTmuxSync) {
-    const context = readHudResizeHookContext(leaderPaneId, execTmuxSync);
+    const canonicalLeaderPaneId = parseCanonicalTmuxPaneId(leaderPaneId);
+    if (!canonicalLeaderPaneId)
+        return false;
+    let contextOutput;
+    try {
+        contextOutput = execTmuxSync(['display-message', '-p', '-t', canonicalLeaderPaneId, '#{session_id}\t#{window_id}']);
+    }
+    catch {
+        return false;
+    }
+    const context = parseHudResizeHookContext(contextOutput, canonicalLeaderPaneId, canonicalLeaderPaneId, { leaderPanePid: '1', hudPanePid: '1' });
     if (!context)
         return false;
     let ok = true;
     try {
         unregisterLegacyHudResizeHook(context, execTmuxSync);
-        execTmuxSync(['set-hook', '-u', '-t', context.sessionId, context.hookSlot]);
+        execTmuxSync(buildGuardedHudHookUnregisterArgs(context, context.hookSlot));
     }
     catch {
         ok = false;
     }
     try {
-        execTmuxSync(['set-hook', '-u', '-t', context.sessionId, context.layoutHookSlot]);
+        execTmuxSync(buildGuardedHudHookUnregisterArgs(context, context.layoutHookSlot));
     }
     catch {
         ok = false;