oh-my-codex 0.20.2 → 0.20.5

package/dist/team/tmux-session.js

@@ -1,8 +1,9 @@
 import { spawnSync, execFile } from 'child_process';
 import { promisify } from 'util';
-import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
+import { closeSync, chmodSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
-import { dirname, isAbsolute, join, resolve } from 'path';
+import { randomBytes } from 'crypto';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'path';
 import { CODEX_BYPASS_FLAG, CLAUDE_SKIP_PERMISSIONS_FLAG, MADMAX_FLAG, CONFIG_FLAG, LONG_CONFIG_FLAG, MODEL_FLAG, } from '../cli/constants.js';
 import { getAgent } from '../agents/definitions.js';
 import { buildCapturePaneArgv as sharedBuildCapturePaneArgv, buildVisibleCapturePaneArgv as sharedBuildVisibleCapturePaneArgv, normalizeTmuxCapture as sharedNormalizeTmuxCapture, paneHasActiveTask as sharedPaneHasActiveTask, paneIsBootstrapping as sharedPaneIsBootstrapping, paneShowsCodexViewport as sharedPaneShowsCodexViewport, paneLooksReady as sharedPaneLooksReady, } from '../scripts/tmux-hook-engine.js';
@@ -11,6 +12,8 @@ import { classifyTeamWorkerLaunchPolicy, extractModelProviderOverrideValue, norm
 import { sleep, sleepSync } from '../utils/sleep.js';
 import { buildPlatformCommandSpec, classifySpawnError, resolveCommandPathForPlatform, spawnPlatformCommandSync, } from '../utils/platform-command.js';
 import { resolveOmxCliEntryPath } from '../utils/paths.js';
+import { readExactPaneProof, readExactPaneProofsSync, readExactPaneProofSync } from './exact-pane.js';
+import { resolveCanonicalTeamStateRoot } from './state-root.js';
 const execFileAsync = promisify(execFile);
 import { HUD_RESIZE_RECONCILE_DELAY_SECONDS, HUD_TMUX_TEAM_HEIGHT_LINES } from '../hud/constants.js';
 import { OMX_TMUX_HUD_OWNER_ENV } from '../hud/reconcile.js';
@@ -18,6 +21,51 @@ import { findHudWatchPaneIds, hudPaneMatchesOwner, OMX_TMUX_HUD_LEADER_PANE_ENV
 const OMX_INSTANCE_OPTION = '@omx_instance_id';
 const OMX_PANE_INSTANCE_OPTION = '@omx_pane_instance_id';
 const OMX_TEAM_PANE_OWNER_OPTION = '@omx_team_pane_owner_id';
+/** `kill(pid, 0)` establishes absence only on ESRCH. */
+function probeProcessLiveness(pid) {
+    try {
+        process.kill(pid, 0);
+        return 'alive';
+    }
+    catch (error) {
+        return error.code === 'ESRCH' ? 'gone' : 'unknown';
+    }
+}
+/** Carries live tmux resources when creation cannot safely roll them back. */
+export class CreateTeamSessionPartialError extends Error {
+    partialSession;
+    proofUnavailable;
+    originalError;
+    cleanupErrors;
+    constructor(partialSession, proofUnavailable, originalError, 
+    /** Cleanup commands that failed after resources were created and must be retried. */
+    cleanupErrors = []) {
+        super('create_team_session_cleanup_incomplete');
+        this.partialSession = partialSession;
+        this.proofUnavailable = proofUnavailable;
+        this.originalError = originalError;
+        this.cleanupErrors = cleanupErrors;
+        this.name = 'CreateTeamSessionPartialError';
+    }
+}
+class ExactPaneProofUnavailableError extends Error {
+    proof;
+    constructor(proof) {
+        super(`exact_pane_proof_unavailable:${proof.paneId}:${proof.reason}`);
+        this.proof = proof;
+        this.name = 'ExactPaneProofUnavailableError';
+    }
+}
+class AmbiguousSplitWindowOutputError extends Error {
+    newlyObservedPaneIds;
+    reconciliationError;
+    constructor(newlyObservedPaneIds, reconciliationError = null) {
+        super('tmux_split_window_output_ambiguous');
+        this.newlyObservedPaneIds = newlyObservedPaneIds;
+        this.reconciliationError = reconciliationError;
+        this.name = 'AmbiguousSplitWindowOutputError';
+    }
+}
 const INJECTION_MARKER = '[OMX_TMUX_INJECT]';
 const MODEL_INSTRUCTIONS_FILE_KEY = 'model_instructions_file';
 const OMX_BYPASS_DEFAULT_SYSTEM_PROMPT_ENV = 'OMX_BYPASS_DEFAULT_SYSTEM_PROMPT';
@@ -64,7 +112,7 @@ const TMUX_PANE_STABILITY_POLL_MS = 60;
 const TMUX_PANE_STABILITY_POLLS_REQUIRED = 2;
 const TMUX_PANE_STABILITY_TIMEOUT_MS = 750;
 const OMX_TEAM_STATE_ROOT_ENV = 'OMX_TEAM_STATE_ROOT';
-function runTmux(args) {
+function runTmux(args, preserveStdout = false) {
     const { result } = spawnPlatformCommandSync('tmux', args, { encoding: 'utf-8' });
     if (result.error) {
         return { ok: false, stderr: result.error.message };
@@ -72,7 +120,325 @@ function runTmux(args) {
     if (result.status !== 0) {
         return { ok: false, stderr: (result.stderr || '').trim() || `tmux exited ${result.status}` };
     }
-    return { ok: true, stdout: (result.stdout || '').trim() };
+    const stdout = result.stdout || '';
+    return { ok: true, stdout: preserveStdout ? stdout : stdout.trim() };
+}
+export function parseSplitWindowPaneId(stdout, expectedReceipt) {
+    const match = expectedReceipt === undefined
+        ? /^(%\d+)(?:\r?\n)?$/.exec(stdout)
+        : /^(%\d+)\t([^\r\n\t]+)(?:\r?\n)?$/.exec(stdout);
+    if (!match || (expectedReceipt !== undefined && match[2] !== expectedReceipt))
+        return null;
+    return match[1];
+}
+/** Preserve structured tmux fields, including an empty final field. */
+/** Preserve structured tmux fields, including an empty final field. */
+function runTmuxStructured(args) {
+    const { result } = spawnPlatformCommandSync('tmux', args, { encoding: 'utf-8' });
+    if (result.error)
+        return { ok: false, stderr: result.error.message };
+    if (result.status !== 0) {
+        return { ok: false, stderr: (result.stderr || '').trim() || `tmux exited ${result.status}` };
+    }
+    return { ok: true, stdout: (result.stdout || '').replace(/\r?\n$/, '') };
+}
+function captureSourcePaneAuthority(paneId, expectedTeamPaneOwnerId) {
+    const target = paneId.trim();
+    if (!/^%[0-9]+$/.test(target))
+        throw new Error(`invalid tmux source pane: ${paneId}`);
+    const result = runTmuxStructured([
+        'display-message', '-p', '-t', target,
+        '#{session_name}\t#{session_id}\t#{session_created}\t#{window_index}\t#{window_id}\t#{pane_id}\t#{pane_pid}',
+    ]);
+    if (!result.ok)
+        throw new Error(`failed to capture tmux source authority: ${result.stderr}`);
+    const fields = result.stdout.split('\t');
+    if (fields.length !== 7)
+        throw new Error('malformed tmux source authority');
+    const [sessionName, sessionId, sessionCreated, windowIndex, windowId, capturedPaneId, panePid] = fields;
+    if (!sessionName || !/^\$[0-9]+$/.test(sessionId) || !/^[0-9]+$/.test(sessionCreated)
+        || !/^[0-9]+$/.test(windowIndex) || !/^@[0-9]+$/.test(windowId)
+        || capturedPaneId !== target || !/^[1-9][0-9]*$/.test(panePid)) {
+        throw new Error('malformed tmux source authority');
+    }
+    const parsedPid = Number(panePid);
+    if (!Number.isSafeInteger(parsedPid) || parsedPid <= 0)
+        throw new Error('malformed tmux source authority');
+    const proof = readExactPaneProofSync(target);
+    if (proof.status === 'unavailable')
+        throw new ExactPaneProofUnavailableError(proof);
+    if (proof.status !== 'live' || proof.pid !== parsedPid)
+        throw new Error(`tmux pane identity changed: ${target}`);
+    const ownerResult = runTmuxStructured(['show-option', '-qv', '-p', '-t', target, OMX_TEAM_PANE_OWNER_OPTION]);
+    if (!ownerResult.ok)
+        throw new Error(`failed to capture tmux pane owner: ${ownerResult.stderr}`);
+    const teamPaneOwnerId = ownerResult.stdout.trim() || null;
+    if (teamPaneOwnerId && !/^[A-Za-z0-9._:-]+$/.test(teamPaneOwnerId)) {
+        throw new Error('malformed tmux pane owner');
+    }
+    if (expectedTeamPaneOwnerId !== undefined && teamPaneOwnerId !== expectedTeamPaneOwnerId) {
+        throw new Error(`tmux pane team owner changed: ${target}`);
+    }
+    return {
+        paneId: target,
+        panePid: parsedPid,
+        sessionName,
+        sessionId,
+        sessionCreated,
+        windowId,
+        windowIndex,
+        teamPaneOwnerId,
+    };
+}
+function sourceAuthorityPredicate(source) {
+    return [
+        '#{==:#{pane_dead},0}',
+        `#{==:#{pane_id},${source.paneId}}`,
+        `#{==:#{pane_pid},${source.panePid}}`,
+        `#{==:#{session_id},${source.sessionId}}`,
+        `#{==:#{session_created},${source.sessionCreated}}`,
+        `#{==:#{window_id},${source.windowId}}`,
+        ...(source.teamPaneOwnerId ? [`#{==:#{${OMX_TEAM_PANE_OWNER_OPTION}},${source.teamPaneOwnerId}}`] : []),
+    ].reduce((combined, condition) => `#{&&:${combined},${condition}}`);
+}
+function sourceTransactionReceipt() {
+    return `omx_source_${process.pid}_${Date.now()}_${randomBytes(16).toString('hex')}`;
+}
+function bindSplitReceiptToPaneCommand(command, receipt) {
+    return `${command} # ${receipt}`;
+}
+/** Queue an effect in the source pane's tmux server only when its exact pane/session/window incarnation still matches. */
+export function runSourceAuthorizedTmux(source, effect, receipt = sourceTransactionReceipt()) {
+    const result = runTmux([
+        'if-shell', '-F', '-t', source.paneId, sourceAuthorityPredicate(source),
+        `${effect} ; display-message -p ${shellQuoteSingle(receipt)}`,
+        "display-message -p ''",
+    ]);
+    if (!result.ok)
+        throw new Error(`tmux source authority transaction failed: ${result.stderr}`);
+    if (result.stdout !== receipt)
+        throw new Error('tmux source authority changed before effect');
+    return receipt;
+}
+function runSourceAuthorizedSplit(source, buildEffect) {
+    // Reconcile against the immutable window ID, not the mutable session:index
+    // target: a concurrent renumber between the guarded split and the after-read
+    // must never turn an unrelated window's pane into kill authority.
+    const windowTarget = source.windowId;
+    const beforeTopology = listPanesResult(windowTarget);
+    if (beforeTopology.error) {
+        throw new Error(`failed to read tmux pane topology before split: ${beforeTopology.error}`);
+    }
+    const beforePaneIds = new Set(beforeTopology.panes.map((pane) => pane.paneId));
+    const receipt = sourceTransactionReceipt();
+    const effect = buildEffect(receipt);
+    const result = runTmux([
+        'if-shell', '-F', '-t', source.paneId, sourceAuthorityPredicate(source),
+        effect.replace("-F '#{pane_id}'", `-F '#{pane_id}\\t${receipt}'`),
+        "display-message -p ''",
+    ], true);
+    if (!result.ok)
+        throw new Error(`tmux source authority transaction failed: ${result.stderr}`);
+    const paneId = parseSplitWindowPaneId(result.stdout, receipt);
+    if (!paneId) {
+        const afterTopology = listPanesResult(windowTarget);
+        const newlyObservedPaneIds = afterTopology.error
+            ? []
+            : afterTopology.panes
+                .filter((pane) => !beforePaneIds.has(pane.paneId) && pane.startCommand.includes(receipt))
+                .map((pane) => pane.paneId);
+        throw new AmbiguousSplitWindowOutputError(newlyObservedPaneIds, afterTopology.error);
+    }
+    return paneId;
+}
+function restoredHudCleanupDebtPath(cwd, stateRoot) {
+    const canonicalStateRoot = resolveCanonicalTeamStateRoot(resolve(cwd));
+    if (typeof stateRoot !== 'string' || !stateRoot.trim()) {
+        return join(canonicalStateRoot, '.restored-hud-cleanup-debt.json');
+    }
+    const canonicalTeamsRoot = join(canonicalStateRoot, 'team');
+    const root = resolve(stateRoot);
+    const relativeRoot = relative(canonicalTeamsRoot, root);
+    if (!isAbsolute(stateRoot.trim())
+        || !relativeRoot
+        || relativeRoot === '..'
+        || relativeRoot.startsWith(`..${sep}`)
+        || isAbsolute(relativeRoot)
+        || relativeRoot.split(sep).length !== 1) {
+        throw new Error('restored_hud_cleanup_debt_state_root_invalid');
+    }
+    for (let candidate = root;; candidate = dirname(candidate)) {
+        try {
+            const metadata = lstatSync(candidate);
+            if (metadata.isSymbolicLink() || !metadata.isDirectory()) {
+                throw new Error('restored_hud_cleanup_debt_state_root_invalid');
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        if (candidate === canonicalTeamsRoot)
+            break;
+    }
+    return join(root, '.restored-hud-cleanup-debt.json');
+}
+function syncRestoredHudDebtParentSync(path) {
+    let descriptor;
+    try {
+        descriptor = openSync(dirname(path), 'r');
+        fsyncSync(descriptor);
+    }
+    catch (error) {
+        const code = error.code;
+        if (!(code === 'EPERM' && process.platform === 'win32'))
+            throw error;
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+    }
+}
+function persistRestoredHudCleanupDebtSync(cwd, debt, stateRoot) {
+    const debtPath = restoredHudCleanupDebtPath(cwd, stateRoot);
+    mkdirSync(dirname(debtPath), { recursive: true });
+    // Recheck after mkdir: an untrusted Team root must still be canonical and
+    // non-symlinked immediately before the durable file mutation.
+    restoredHudCleanupDebtPath(cwd, stateRoot);
+    const temporaryPath = `${debtPath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
+    writeFileSync(temporaryPath, `${JSON.stringify(debt)}\n`, { mode: 0o600 });
+    const temporaryDescriptor = openSync(temporaryPath, 'r');
+    try {
+        fsyncSync(temporaryDescriptor);
+    }
+    finally {
+        closeSync(temporaryDescriptor);
+    }
+    renameSync(temporaryPath, debtPath);
+    syncRestoredHudDebtParentSync(debtPath);
+}
+function parseRestoredHudCleanupDebtSync(cwd, stateRoot) {
+    const debtPath = restoredHudCleanupDebtPath(cwd, stateRoot);
+    if (!existsSync(debtPath))
+        return null;
+    let debt;
+    try {
+        debt = JSON.parse(readFileSync(debtPath, 'utf8'));
+    }
+    catch {
+        throw new Error('restored_hud_cleanup_debt_malformed');
+    }
+    if (debt.schema_version !== 1 || debt.operation !== 'restored_hud_cleanup'
+        || !hasExplicitWorkerPaneId(debt.pane_id)
+        || !hasExplicitWorkerPaneId(debt.leader_pane_id)
+        || !Number.isSafeInteger(debt.leader_pane_pid) || debt.leader_pane_pid <= 0
+        || !(typeof debt.leader_pane_owner_id === 'string' || debt.leader_pane_owner_id === null)
+        || debt.hud_owner_leader_pane_id !== debt.leader_pane_id
+        || (debt.pane_pid !== null && (!Number.isSafeInteger(debt.pane_pid) || debt.pane_pid <= 0))) {
+        throw new Error('restored_hud_cleanup_debt_malformed');
+    }
+    return { path: debtPath, debt };
+}
+function removeRestoredHudCleanupDebtSync(path) {
+    unlinkSync(path);
+    syncRestoredHudDebtParentSync(path);
+}
+/**
+ * Replays a prior restored-HUD obligation. A live pane is killable only when
+ * its recorded PID, HUD command identity, and tagged leader identity all
+ * still match; PID-less and ambiguous records remain durable debt.
+ */
+export function reconcileRestoredHudCleanupDebtSync(cwd, stateRoot) {
+    const record = parseRestoredHudCleanupDebtSync(cwd, stateRoot);
+    if (!record)
+        return;
+    const { path, debt } = record;
+    const proof = readExactPaneProofSync(debt.pane_id);
+    if (proof.status === 'gone') {
+        removeRestoredHudCleanupDebtSync(path);
+        return;
+    }
+    if (proof.status !== 'live' || debt.pane_pid === null || proof.pid !== debt.pane_pid || !debt.leader_pane_owner_id) {
+        throw new Error(`restored_hud_cleanup_debt_unresolved:${debt.pane_id}`);
+    }
+    const leader = requireLiveTeamOwnedPaneSync(debt.leader_pane_id, debt.leader_pane_pid, debt.leader_pane_owner_id);
+    const topology = listPanesResult(leader);
+    const hudMatches = !topology.error && topology.panes.filter((pane) => pane.paneId === proof.paneId
+        && hudPaneMatchesOwner(pane, { leaderPaneId: debt.hud_owner_leader_pane_id })).length === 1;
+    if (!hudMatches)
+        throw new Error(`restored_hud_cleanup_debt_unresolved:${debt.pane_id}`);
+    killExactPaneSync(proof.paneId, debt.pane_pid, () => {
+        requireLiveTeamOwnedPaneSync(debt.leader_pane_id, debt.leader_pane_pid, debt.leader_pane_owner_id);
+    });
+    removeRestoredHudCleanupDebtSync(path);
+}
+/** Remove restored-HUD debt only after the canonical config transaction commits the same frozen identity. */
+export function finalizeRestoredHudCleanupDebtSync(cwd, paneId, panePid, stateRoot, _requireFreshHudIdentity) {
+    const record = parseRestoredHudCleanupDebtSync(cwd, stateRoot);
+    if (!record)
+        return;
+    const { debt } = record;
+    if (debt.pane_id !== paneId || debt.pane_pid !== panePid || !debt.leader_pane_owner_id) {
+        throw new Error(`restored_hud_cleanup_debt_unresolved:${debt.pane_id}`);
+    }
+    const leader = requireLiveTeamOwnedPaneSync(debt.leader_pane_id, debt.leader_pane_pid, debt.leader_pane_owner_id);
+    const topology = listPanesResult(leader);
+    const hudMatches = !topology.error && topology.panes.filter((pane) => pane.paneId === debt.pane_id
+        && hudPaneMatchesOwner(pane, { leaderPaneId: debt.hud_owner_leader_pane_id })).length === 1;
+    if (!hudMatches)
+        throw new Error(`restored_hud_cleanup_debt_unresolved:${debt.pane_id}`);
+    const finalProof = readExactPaneProofSync(debt.pane_id);
+    if (finalProof.status !== 'live' || finalProof.pid !== debt.pane_pid) {
+        throw new Error(`restored_hud_cleanup_debt_unresolved:${debt.pane_id}`);
+    }
+    removeRestoredHudCleanupDebtSync(record.path);
+}
+/**
+ * Kill only a pane that a fresh global snapshot proves live. Callers treat
+ * gone/dead rows as already cleaned and unavailable snapshots as fail-closed.
+ */
+function requireLiveExactPaneSync(paneId, expectedPid) {
+    const proof = readExactPaneProofSync(paneId);
+    if (proof.status === 'unavailable')
+        throw new ExactPaneProofUnavailableError(proof);
+    if (proof.status === 'gone')
+        throw new Error(`tmux pane is not proven live: ${paneId}`);
+    if (expectedPid !== undefined && proof.pid !== expectedPid) {
+        throw new Error(`tmux pane identity changed: ${paneId}`);
+    }
+    return proof.paneId;
+}
+function killExactPaneSync(paneId, expectedPid, assertAuthorization) {
+    const proof = readExactPaneProofSync(paneId);
+    if (proof.status === 'unavailable')
+        throw new ExactPaneProofUnavailableError(proof);
+    if (proof.status === 'gone')
+        return;
+    if (expectedPid !== undefined && proof.pid !== expectedPid) {
+        throw new Error(`tmux pane identity changed: ${paneId}`);
+    }
+    assertAuthorization?.();
+    // Authorization can read tmux. Re-prove immediately after it so a recycled
+    // pane ID cannot be targeted by the subsequent kill.
+    const finalProof = readExactPaneProofSync(proof.paneId);
+    if (finalProof.status === 'unavailable')
+        throw new ExactPaneProofUnavailableError(finalProof);
+    if (finalProof.status === 'gone')
+        return;
+    if (finalProof.pid !== proof.pid || (expectedPid !== undefined && finalProof.pid !== expectedPid)) {
+        throw new Error(`tmux pane identity changed: ${paneId}`);
+    }
+    const result = runTmux(['kill-pane', '-t', finalProof.paneId]);
+    if (!result.ok)
+        throw new Error(`failed to kill tmux pane ${finalProof.paneId}: ${result.stderr}`);
+    const afterKill = readExactPaneProofSync(finalProof.paneId);
+    if (afterKill.status === 'unavailable')
+        throw new ExactPaneProofUnavailableError(afterKill);
+    if (afterKill.status !== 'gone') {
+        if (afterKill.pid !== finalProof.pid)
+            throw new Error(`tmux pane identity changed: ${paneId}`);
+        throw new Error(`tmux pane remains live after kill: ${paneId}`);
+    }
 }
 function appendNoUnderlineStyleFlags(style) {
     const normalized = style
@@ -86,7 +452,8 @@ function appendNoUnderlineStyleFlags(style) {
     }
     return combined.join(',');
 }
-function sanitizeTmuxStyleOption(sessionTarget, optionName) {
+function sanitizeTmuxStyleOption(sessionTarget, optionName, beforeEffect) {
+    beforeEffect?.();
     const shown = runTmux(['show-options', '-gv', '-t', sessionTarget, optionName]);
     if (!shown.ok)
         return false;
@@ -96,36 +463,28 @@ function sanitizeTmuxStyleOption(sessionTarget, optionName) {
     const sanitized = appendNoUnderlineStyleFlags(current);
     if (sanitized === current)
         return true;
+    beforeEffect?.();
     const result = runTmux(['set-option', '-t', sessionTarget, optionName, sanitized]);
     return result.ok;
 }
-function tagPaneInstance(paneTarget, instanceId) {
-    const target = paneTarget.trim();
-    const sanitized = instanceId.trim();
-    if (!target || !sanitized)
-        return;
-    const result = runTmux(['set-option', '-p', '-t', target, OMX_PANE_INSTANCE_OPTION, sanitized]);
-    if (!result.ok) {
-        throw new Error(`failed to tag tmux pane ${target}: ${result.stderr}`);
-    }
-}
-export function tagPaneTeamOwner(paneTarget, teamOwnerId) {
+export function tagPaneTeamOwner(paneTarget, teamOwnerId, expectedPanePid) {
     const target = paneTarget.trim();
     const sanitized = teamOwnerId.trim();
     if (!target || !sanitized)
         return;
-    const result = runTmux(['set-option', '-p', '-t', target, OMX_TEAM_PANE_OWNER_OPTION, sanitized]);
+    const provenTarget = requireLiveExactPaneSync(target, expectedPanePid);
+    const result = runTmux(['set-option', '-p', '-t', provenTarget, OMX_TEAM_PANE_OWNER_OPTION, sanitized]);
     if (!result.ok) {
-        throw new Error(`failed to tag tmux pane ${target}: ${result.stderr}`);
+        throw new Error(`failed to tag tmux pane ${provenTarget}: ${result.stderr}`);
     }
 }
-export function mitigateCopyModeUnderlineArtifacts(sessionTarget) {
+export function mitigateCopyModeUnderlineArtifacts(sessionTarget, beforeEffect) {
     const normalizedTarget = sessionTarget.trim();
     if (normalizedTarget === '')
         return false;
     let applied = false;
     for (const optionName of TMUX_COPY_MODE_STYLE_OPTIONS) {
-        if (sanitizeTmuxStyleOption(normalizedTarget, optionName)) {
+        if (sanitizeTmuxStyleOption(normalizedTarget, optionName, beforeEffect)) {
             applied = true;
         }
     }
@@ -181,18 +540,104 @@ function baseSessionName(target) {
     return target.split(':')[0] || target;
 }
 function listPanes(target) {
-    const result = runTmux(['list-panes', '-t', target, '-F', '#{pane_id}\t#{pane_current_command}\t#{pane_start_command}']);
+    return listPanesResult(target).panes;
+}
+function listPanesResult(target) {
+    const result = runTmuxStructured(['list-panes', '-t', target, '-F', '#{pane_id}\t#{pane_current_command}\t#{pane_start_command}']);
     if (!result.ok)
-        return [];
-    return result.stdout
-        .split('\n')
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0)
-        .map((line) => {
-        const [paneId = '', currentCommand = '', startCommand = ''] = line.split('\t');
-        return { paneId, currentCommand, startCommand };
-    })
-        .filter((pane) => pane.paneId.startsWith('%'));
+        return { panes: [], error: result.stderr };
+    const panes = [];
+    for (const rawLine of result.stdout.split('\n')) {
+        const line = rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine;
+        if (line.length === 0)
+            continue;
+        const firstSeparator = line.indexOf('\t');
+        const secondSeparator = firstSeparator >= 0 ? line.indexOf('\t', firstSeparator + 1) : -1;
+        const paneId = firstSeparator >= 0 ? line.slice(0, firstSeparator) : line;
+        if (firstSeparator < 0 || secondSeparator < 0 || !/^%[0-9]+$/.test(paneId)) {
+            return { panes: [], error: 'malformed pane topology' };
+        }
+        if (panes.some((pane) => pane.paneId === paneId)) {
+            return { panes: [], error: 'malformed pane topology' };
+        }
+        panes.push({
+            paneId,
+            currentCommand: line.slice(firstSeparator + 1, secondSeparator),
+            startCommand: line.slice(secondSeparator + 1),
+        });
+    }
+    return { panes, error: null };
+}
+/**
+ * Window-wide layout effects may only touch the exact startup pane set. A
+ * target-scoped topology read rejects foreign/new panes, and targeted global
+ * snapshots pin every surviving pane identity. The final scoped read happens
+ * immediately before the mutation so panes added during owner reads cannot
+ * inherit that authority.
+ */
+/**
+ * Re-prove an explicitly Team-owned pane immediately before an effect. The
+ * double PID proof keeps ownership and process identity continuous across an
+ * untrusted tmux option read.
+ */
+function requireLiveTeamOwnedPaneSync(paneId, expectedPanePid, expectedTeamOwnerId) {
+    const target = requireLiveExactPaneSync(paneId, expectedPanePid);
+    const owner = readPaneTeamOwnerTagResult(target);
+    if (owner.status !== 'value' || owner.value !== expectedTeamOwnerId) {
+        const detail = owner.status === 'error' ? owner.error : 'missing';
+        throw new Error(`tmux pane team owner changed: ${target}: ${detail}`);
+    }
+    return requireLiveExactPaneSync(target, expectedPanePid);
+}
+function frozenWindowTopologyError(teamTarget, expectedPaneIds, actualPaneIds) {
+    const expected = [...expectedPaneIds].sort();
+    const actual = [...actualPaneIds].sort();
+    const unexpected = actual.filter((paneId) => !expectedPaneIds.has(paneId));
+    const missing = expected.filter((paneId) => !actualPaneIds.has(paneId));
+    return new Error(`tmux window topology changed before layout mutation: target=${teamTarget}; expected=[${expected.join(',')}]; actual=[${actual.join(',')}]; unexpected=[${unexpected.join(',')}]; missing=[${missing.join(',')}]. Team requires an isolated tmux window with no host-owned foreign panes`);
+}
+function requireFrozenWindowTopologySync(teamTarget, expectedPanePids, expectedPaneOwners) {
+    const topology = listPanesResult(teamTarget);
+    if (topology.error)
+        throw new Error(`failed to read tmux pane topology: ${topology.error}`);
+    const actualPaneIds = new Set(topology.panes.map((pane) => pane.paneId));
+    if (actualPaneIds.size !== expectedPanePids.size
+        || [...expectedPanePids.keys()].some((paneId) => !actualPaneIds.has(paneId))) {
+        throw frozenWindowTopologyError(teamTarget, new Set(expectedPanePids.keys()), actualPaneIds);
+    }
+    for (const [paneId, expectedPanePid] of expectedPanePids) {
+        const expectedOwner = expectedPaneOwners?.get(paneId);
+        if (expectedOwner)
+            requireLiveTeamOwnedPaneSync(paneId, expectedPanePid, expectedOwner);
+        else {
+            const proof = readExactPaneProofSync(paneId);
+            if (proof.status === 'unavailable')
+                throw new ExactPaneProofUnavailableError(proof);
+            if (proof.status === 'gone')
+                throw new Error(`tmux pane is not proven live: ${proof.paneId}`);
+            if (proof.pid !== expectedPanePid)
+                throw new Error(`tmux pane identity changed: ${proof.paneId}`);
+        }
+    }
+    const finalProofs = readExactPaneProofsSync([...expectedPanePids.keys()]);
+    for (const [index, [paneId, expectedPanePid]] of [...expectedPanePids.entries()].entries()) {
+        const proof = finalProofs[index];
+        if (proof.status === 'unavailable')
+            throw new ExactPaneProofUnavailableError(proof);
+        if (proof.status === 'gone')
+            throw new Error(`tmux pane is not proven live: ${proof.paneId}`);
+        if (proof.paneId !== paneId || proof.pid !== expectedPanePid) {
+            throw new Error(`tmux pane identity changed: ${paneId}`);
+        }
+    }
+    const finalTopology = listPanesResult(teamTarget);
+    if (finalTopology.error)
+        throw new Error(`failed to read tmux pane topology: ${finalTopology.error}`);
+    const finalPaneIds = new Set(finalTopology.panes.map((pane) => pane.paneId));
+    if (finalPaneIds.size !== expectedPanePids.size
+        || [...expectedPanePids.keys()].some((paneId) => !finalPaneIds.has(paneId))) {
+        throw frozenWindowTopologyError(teamTarget, new Set(expectedPanePids.keys()), finalPaneIds);
+    }
 }
 export function listPaneIds(target) {
     return listPanes(target).map((pane) => pane.paneId);
@@ -237,12 +682,6 @@ export function chooseTeamLeaderPaneId(panes, preferredPaneId) {
         return nonHud.paneId;
     return preferredPaneId;
 }
-function findHudPaneIds(target, leaderPaneId) {
-    return findHudWatchPaneIds(listPanes(target), leaderPaneId, { leaderPaneId });
-}
-function findOwnedHudPaneIds(target, leaderPaneId) {
-    return findHudWatchPaneIds(listPanes(target), leaderPaneId, { leaderPaneId });
-}
 function readPaneCurrentPath(paneId) {
     if (!paneId.startsWith('%'))
         return null;
@@ -281,7 +720,8 @@ function shouldAttemptRestoreCwdCandidate(candidate) {
     }
     return pathIsUsableDirectory(candidate.rawPath);
 }
-function resolveStandaloneHudRestoreCwdCandidates(leaderPaneId, fallbackCwd, explicitCwd) {
+function resolveStandaloneHudRestoreCwdCandidates(leaderPaneId, fallbackCwd, explicitCwd, beforeReadLiveLeaderCwd) {
+    beforeReadLiveLeaderCwd?.();
     const liveLeaderCwd = readPaneCurrentPath(leaderPaneId);
     return uniqueRestoreCwdCandidates([
         { source: 'explicit', rawPath: explicitCwd },
@@ -318,105 +758,214 @@ async function runTmuxAsync(args) {
         return { ok: false, stderr: (err.stderr || err.message || '').trim() || 'tmux command failed' };
     }
 }
-async function sendKeyAsync(target, key) {
+function hasExplicitWorkerPaneId(workerPaneId) {
+    return typeof workerPaneId === 'string' && workerPaneId.trim().length > 0;
+}
+function readExactWorkerPaneLivenessProofSync(paneId) {
+    if (!/^%[0-9]+$/.test(paneId))
+        return { status: 'unavailable', paneId, reason: 'invalid_pane_id' };
+    const result = runTmuxStructured([
+        'display-message', '-p', '-t', paneId,
+        `#{pane_id}\t#{pane_dead}\t#{pane_pid}\t#{${OMX_TEAM_PANE_OWNER_OPTION}}`,
+    ]);
+    if (!result.ok) {
+        if (/can't find pane|no such pane|unknown pane/i.test(result.stderr)) {
+            return { status: 'gone', paneId, reason: 'absent' };
+        }
+        return { status: 'unavailable', paneId, reason: `query_failed:${result.stderr || 'unknown'}` };
+    }
+    const lines = result.stdout.replace(/\r\n/g, '\n').split('\n').filter((line) => line.length > 0);
+    if (lines.length !== 1)
+        return { status: 'unavailable', paneId, reason: 'malformed_exact_pane_result' };
+    const fields = lines[0].split('\t');
+    if (fields.length !== 4)
+        return { status: 'unavailable', paneId, reason: 'malformed_exact_pane_result' };
+    const [actualPaneId, paneDead, rawPid, ownerId] = fields;
+    if (actualPaneId !== paneId) {
+        return { status: 'unavailable', paneId, reason: `pane_id_changed:expected=${paneId}:actual=${actualPaneId}` };
+    }
+    if (paneDead !== '0' && paneDead !== '1')
+        return { status: 'unavailable', paneId, reason: 'malformed_exact_pane_result' };
+    if (!/^[0-9]+$/.test(rawPid))
+        return { status: 'unavailable', paneId, reason: 'malformed_exact_pane_result' };
+    const pid = Number(rawPid);
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return { status: 'unavailable', paneId, reason: 'malformed_exact_pane_result' };
+    if (paneDead === '1')
+        return { status: 'gone', paneId, reason: 'dead' };
+    return { status: 'live', paneId, pid, ownerId };
+}
+function requireExactWorkerPaneLivenessIdentity(paneId, expectedPanePid, expectedTeamOwnerId, hudPaneId) {
+    if (hudPaneId?.trim() && paneId === hudPaneId.trim()) {
+        throw new Error(`tmux worker pane is HUD target: ${paneId}`);
+    }
+    const proof = readExactWorkerPaneLivenessProofSync(paneId);
+    if (proof.status === 'unavailable' && proof.reason.startsWith('pane_id_changed:')) {
+        throw new Error(`tmux worker pane identity changed: ${paneId}: ${proof.reason}`);
+    }
+    if (proof.status !== 'live')
+        return proof;
+    if (typeof expectedPanePid === 'number' && proof.pid !== expectedPanePid) {
+        throw new Error(`tmux worker pane PID changed: ${paneId}: expected ${expectedPanePid}, got ${proof.pid}`);
+    }
+    const expectedOwner = typeof expectedTeamOwnerId === 'string' ? expectedTeamOwnerId.trim() : '';
+    if (expectedOwner && proof.ownerId !== expectedOwner) {
+        throw new Error(`tmux worker pane incarnation changed: ${paneId}: expected ${expectedOwner}, got ${proof.ownerId || 'missing'}`);
+    }
+    return proof;
+}
+function resolveWorkerPaneTargetSync(sessionName, workerIndex, workerPaneId) {
+    if (!hasExplicitWorkerPaneId(workerPaneId))
+        return paneTarget(sessionName, workerIndex);
+    const proof = readExactPaneProofSync(workerPaneId);
+    return proof.status === 'live' ? proof.paneId : null;
+}
+async function resolveWorkerPaneTargetAsync(sessionName, workerIndex, workerPaneId) {
+    if (!hasExplicitWorkerPaneId(workerPaneId))
+        return paneTarget(sessionName, workerIndex);
+    const proof = await readExactPaneProof(workerPaneId);
+    return proof.status === 'live' ? proof.paneId : null;
+}
+function createPinnedWorkerPaneTargetResolverSync(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId) {
+    if (!hasExplicitWorkerPaneId(workerPaneId)) {
+        return () => resolveWorkerPaneTargetSync(sessionName, workerIndex, workerPaneId);
+    }
+    const pinnedPid = expectedPanePid;
+    const expectedOwner = typeof expectedTeamOwnerId === 'string' ? expectedTeamOwnerId.trim() : '';
+    const canonicalHudPaneId = typeof hudPaneId === 'string' ? hudPaneId.trim() : '';
+    return () => {
+        if (typeof pinnedPid !== 'number' || !Number.isSafeInteger(pinnedPid) || pinnedPid <= 0)
+            return null;
+        if (!expectedOwner)
+            return null;
+        if (canonicalHudPaneId && workerPaneId === canonicalHudPaneId) {
+            throw new Error(`tmux worker pane is HUD target: ${workerPaneId}`);
+        }
+        const proof = readExactPaneProofSync(workerPaneId);
+        if (proof.status !== 'live')
+            return null;
+        if (proof.pid !== pinnedPid) {
+            throw new Error(`tmux pane identity changed: ${workerPaneId}`);
+        }
+        const owner = readPaneTeamOwnerTagResult(proof.paneId);
+        if (owner.status !== 'value' || owner.value !== expectedOwner)
+            return null;
+        const finalProof = readExactPaneProofSync(workerPaneId);
+        if (finalProof.status !== 'live')
+            return null;
+        if (finalProof.pid !== pinnedPid) {
+            throw new Error(`tmux pane identity changed: ${workerPaneId}`);
+        }
+        return finalProof.paneId;
+    };
+}
+function createPinnedWorkerPaneTargetResolver(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId) {
+    if (!hasExplicitWorkerPaneId(workerPaneId)) {
+        return () => resolveWorkerPaneTargetAsync(sessionName, workerIndex, workerPaneId);
+    }
+    const pinnedPid = expectedPanePid;
+    const expectedOwner = typeof expectedTeamOwnerId === 'string' ? expectedTeamOwnerId.trim() : '';
+    const canonicalHudPaneId = typeof hudPaneId === 'string' ? hudPaneId.trim() : '';
+    let lastResolvedPid;
+    const resolveTarget = async () => {
+        if (typeof pinnedPid !== 'number' || !Number.isSafeInteger(pinnedPid) || pinnedPid <= 0)
+            return null;
+        if (!expectedOwner)
+            return null;
+        if (canonicalHudPaneId && workerPaneId === canonicalHudPaneId) {
+            throw new Error(`tmux worker pane is HUD target: ${workerPaneId}`);
+        }
+        const proof = await readExactPaneProof(workerPaneId);
+        if (proof.status !== 'live')
+            return null;
+        if (proof.pid !== pinnedPid) {
+            throw new Error(`tmux pane identity changed: ${workerPaneId}`);
+        }
+        const owner = readPaneTeamOwnerTagResult(proof.paneId);
+        if (owner.status !== 'value' || owner.value !== expectedOwner) {
+            const detail = owner.status === 'error' ? owner.error : 'missing';
+            throw new Error(`tmux pane team owner changed: ${workerPaneId}: ${detail}`);
+        }
+        // The option read is untrusted and can race pane ID reuse. Its immediately
+        // adjacent PID proof authorizes the following capture/control/input effect.
+        const finalProof = await readExactPaneProof(workerPaneId);
+        if (finalProof.status !== 'live')
+            return null;
+        if (finalProof.pid !== pinnedPid) {
+            throw new Error(`tmux pane identity changed: ${workerPaneId}`);
+        }
+        lastResolvedPid = finalProof.pid;
+        return finalProof.paneId;
+    };
+    resolveTarget.lastResolvedPid = () => lastResolvedPid;
+    return resolveTarget;
+}
+async function requireAsyncPaneTarget(resolveTarget) {
+    const target = await resolveTarget();
+    if (!target)
+        throw new Error('tmux pane is not proven live');
+    return target;
+}
+async function sendKeyAsync(resolveTarget, key) {
+    const target = await requireAsyncPaneTarget(resolveTarget);
     const result = await runTmuxAsync(['send-keys', '-t', target, key]);
     if (!result.ok) {
         throw new Error(`sendKeyAsync: failed to send ${key}: ${result.stderr}`);
     }
 }
-async function capturePaneAsync(target) {
+async function capturePaneAsync(resolveTarget) {
+    const target = await resolveTarget();
+    if (!target)
+        return '';
     const result = await runTmuxAsync(sharedBuildCapturePaneArgv(target, 80));
     if (!result.ok)
         return '';
     return result.stdout;
 }
-async function captureVisiblePaneAsync(target) {
+/** Capture an explicit Team worker pane only after PID-owner-PID authorization. */
+export async function captureWorkerPane(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId) {
+    const resolveTarget = createPinnedWorkerPaneTargetResolver(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId);
+    return capturePaneAsync(resolveTarget);
+}
+async function captureVisiblePaneAsync(resolveTarget) {
+    const target = await resolveTarget();
+    if (!target)
+        return '';
     const result = await runTmuxAsync(sharedBuildVisibleCapturePaneArgv(target));
     if (!result.ok)
         return '';
     return result.stdout;
 }
-async function isWorkerAliveAsync(sessionName, workerIndex, workerPaneId) {
-    if (workerPaneId?.startsWith('%')) {
-        const paneStatus = await readPaneLivenessByIdAsync(workerPaneId);
-        if (paneStatus !== null)
-            return paneStatus;
+async function isWorkerAliveAsync(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId, resolveTarget) {
+    if (hasExplicitWorkerPaneId(workerPaneId)) {
+        const resolver = resolveTarget ?? createPinnedWorkerPaneTargetResolver(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId);
+        const target = await resolver();
+        const pid = resolver.lastResolvedPid?.() ?? expectedPanePid;
+        if (!target || typeof pid !== 'number' || !Number.isSafeInteger(pid) || pid <= 0)
+            return 'unknown';
+        return probeProcessLiveness(pid);
     }
     const result = await runTmuxAsync([
         'list-panes',
-        '-t', paneTarget(sessionName, workerIndex, workerPaneId),
+        '-t', paneTarget(sessionName, workerIndex),
         '-F',
         '#{pane_dead} #{pane_pid}',
     ]);
     if (!result.ok)
-        return false;
+        return 'unknown';
     const line = result.stdout.split('\n')[0]?.trim();
     if (!line)
-        return false;
+        return 'unknown';
     const parts = line.split(/\s+/);
     if (parts.length < 2)
-        return false;
+        return 'unknown';
     const paneDead = parts[0];
     const pid = Number.parseInt(parts[1], 10);
     if (paneDead === '1')
-        return false;
+        return 'gone';
     if (!Number.isFinite(pid))
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function parsePaneLivenessLine(line, allowMissingPid) {
-    const parts = line.trim().split(/\s+/);
-    if (parts.length < 1 || parts[0] === '')
-        return null;
-    const paneDead = parts[0];
-    const pid = Number.parseInt(parts[1] ?? '', 10);
-    if (paneDead === '1')
-        return false;
-    if (!Number.isFinite(pid))
-        return allowMissingPid ? true : false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return allowMissingPid;
-    }
-}
-function readPaneLivenessById(paneId) {
-    const result = runTmux(['list-panes', '-a', '-F', '#{pane_id} #{pane_dead} #{pane_pid}']);
-    if (!result.ok)
-        return null;
-    for (const line of result.stdout.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        const [id = '', ...rest] = trimmed.split(/\s+/);
-        if (id !== paneId)
-            continue;
-        return parsePaneLivenessLine(rest.join(' '), true);
-    }
-    return null;
-}
-async function readPaneLivenessByIdAsync(paneId) {
-    const result = await runTmuxAsync(['list-panes', '-a', '-F', '#{pane_id} #{pane_dead} #{pane_pid}']);
-    if (!result.ok)
-        return null;
-    for (const line of result.stdout.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        const [id = '', ...rest] = trimmed.split(/\s+/);
-        if (id !== paneId)
-            continue;
-        return parsePaneLivenessLine(rest.join(' '), true);
-    }
-    return null;
+        return 'unknown';
+    return probeProcessLiveness(pid);
 }
 function shellQuoteSingle(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -510,6 +1059,20 @@ function buildNestedTmuxShellCommand(command) {
 function buildBestEffortShellCommand(command) {
     return `${command} >/dev/null 2>&1 || true`;
 }
+function buildAuthoritativeHudResizeShellCommand(hudPaneId, heightLines = HUD_TMUX_TEAM_HEIGHT_LINES, expectedPanePid, expectedPaneOwnerId, effectCommand = buildNestedTmuxShellCommand(buildHudResizeCommand(buildHudPaneTarget(hudPaneId), heightLines))) {
+    const target = buildHudPaneTarget(hudPaneId);
+    const snapshot = buildNestedTmuxShellCommand("list-panes -a -F '#{pane_id}\t#{pane_dead}\t#{pane_pid}'");
+    const expectedPid = typeof expectedPanePid === 'number' && Number.isSafeInteger(expectedPanePid) && expectedPanePid > 0
+        ? ` && $3 == "${expectedPanePid}"`
+        : '';
+    const proof = `awk -F '\\t' -v pane='${target}' 'NF != 3 || $1 !~ /^%[0-9]+$/ || ($2 != "0" && $2 != "1") || (seen[$1]++) || ($1 == pane && ($3 !~ /^[1-9][0-9]*$/ || length($3) > 16 || (length($3) == 16 && ("x" $3) > "x9007199254740991"))) || ($1 != pane && $3 != "" && ($3 !~ /^[1-9][0-9]*$/ || length($3) > 16 || (length($3) == 16 && ("x" $3) > "x9007199254740991"))) { bad = 1 } $1 == pane && $2 == "0"${expectedPid} { live = 1 } END { exit bad || !live }'`;
+    const expectedOwner = expectedPaneOwnerId?.trim();
+    if (!expectedOwner) {
+        return `if snapshot=$(${snapshot}); then printf '%s\\n' "$snapshot" | ${proof} && ${effectCommand}; fi`;
+    }
+    const owner = buildNestedTmuxShellCommand(`show-option -qv -p -t ${target} ${OMX_TEAM_PANE_OWNER_OPTION}`);
+    return `if snapshot=$(${snapshot}); then printf '%s\\n' "$snapshot" | ${proof} && owner=$(${owner}) && [ "$owner" = ${shellQuoteSingle(expectedOwner)} ] && final_snapshot=$(${snapshot}) && printf '%s\\n' "$final_snapshot" | ${proof} && ${effectCommand}; fi`;
+}
 /** Upper bound for tmux hook indices (signed 32-bit max). */
 const TMUX_HOOK_INDEX_MAX = 2147483647;
 function buildResizeHookSlot(hookName) {
@@ -526,8 +1089,8 @@ function buildClientAttachedHookSlot(hookName) {
     }
     return `client-attached[${Math.abs(hash) % TMUX_HOOK_INDEX_MAX}]`;
 }
-export function buildRegisterResizeHookArgs(hookTarget, hookName, hudPaneId, heightLines = HUD_TMUX_TEAM_HEIGHT_LINES) {
-    const resizeCommand = buildBestEffortShellCommand(buildNestedTmuxShellCommand(buildHudResizeCommand(hudPaneId, heightLines)));
+export function buildRegisterResizeHookArgs(hookTarget, hookName, hudPaneId, heightLines = HUD_TMUX_TEAM_HEIGHT_LINES, expectedPanePid, expectedPaneOwnerId) {
+    const resizeCommand = buildBestEffortShellCommand(buildAuthoritativeHudResizeShellCommand(hudPaneId, heightLines, expectedPanePid, expectedPaneOwnerId));
     const hookCommand = shellQuoteSingle(`${resizeCommand}; sleep ${HUD_RESIZE_RECONCILE_DELAY_SECONDS}; ${resizeCommand}`);
     return ['set-hook', '-t', hookTarget, buildResizeHookSlot(hookName), `run-shell -b ${hookCommand}`];
 }
@@ -543,9 +1106,11 @@ export function buildClientAttachedReconcileHookName(teamName, sessionName, wind
         normalizeHudPaneToken(hudPaneId),
     ].join('_');
 }
-export function buildRegisterClientAttachedReconcileArgs(hookTarget, hookName, hudPaneId, heightLines = HUD_TMUX_TEAM_HEIGHT_LINES) {
+export function buildRegisterClientAttachedReconcileArgs(hookTarget, hookName, hudPaneId, heightLines = HUD_TMUX_TEAM_HEIGHT_LINES, expectedPanePid, expectedPaneOwnerId) {
     const hookSlot = buildClientAttachedHookSlot(hookName);
-    const oneShotCommand = shellQuoteSingle(`${buildBestEffortShellCommand(buildNestedTmuxShellCommand(buildHudResizeCommand(hudPaneId, heightLines)))}; ${buildNestedTmuxShellCommand(`set-hook -u -t ${hookTarget} ${hookSlot}`)}`);
+    const resizeCommand = buildBestEffortShellCommand(buildAuthoritativeHudResizeShellCommand(hudPaneId, heightLines, expectedPanePid, expectedPaneOwnerId));
+    const unregisterCommand = buildBestEffortShellCommand(buildAuthoritativeHudResizeShellCommand(hudPaneId, heightLines, expectedPanePid, expectedPaneOwnerId, buildNestedTmuxShellCommand(`set-hook -u -t ${hookTarget} ${hookSlot}`)));
+    const oneShotCommand = shellQuoteSingle(`${resizeCommand}; ${unregisterCommand}`);
     return ['set-hook', '-t', hookTarget, hookSlot, `run-shell -b ${oneShotCommand}`];
 }
 export function buildUnregisterClientAttachedReconcileArgs(hookTarget, hookName) {
@@ -555,18 +1120,18 @@ export function unregisterResizeHook(hookTarget, hookName) {
     const result = runTmux(buildUnregisterResizeHookArgs(hookTarget, hookName));
     return result.ok;
 }
-export function buildScheduleDelayedHudResizeArgs(hudPaneId, delaySeconds = HUD_RESIZE_RECONCILE_DELAY_SECONDS, heightLines = HUD_TMUX_TEAM_HEIGHT_LINES) {
+export function buildScheduleDelayedHudResizeArgs(hudPaneId, delaySeconds = HUD_RESIZE_RECONCILE_DELAY_SECONDS, heightLines = HUD_TMUX_TEAM_HEIGHT_LINES, expectedPanePid, expectedPaneOwnerId) {
     const delay = Number.isFinite(delaySeconds) && delaySeconds > 0 ? delaySeconds : HUD_RESIZE_RECONCILE_DELAY_SECONDS;
-    return ['run-shell', '-b', `sleep ${delay}; ${buildBestEffortShellCommand(buildNestedTmuxShellCommand(buildHudResizeCommand(hudPaneId, heightLines)))}`];
+    return ['run-shell', '-b', `sleep ${delay}; ${buildBestEffortShellCommand(buildAuthoritativeHudResizeShellCommand(hudPaneId, heightLines, expectedPanePid, expectedPaneOwnerId))}`];
 }
-export function buildReconcileHudResizeArgs(hudPaneId, heightLines = HUD_TMUX_TEAM_HEIGHT_LINES) {
-    return ['run-shell', buildBestEffortShellCommand(buildNestedTmuxShellCommand(buildHudResizeCommand(hudPaneId, heightLines)))];
+export function buildReconcileHudResizeArgs(hudPaneId, heightLines = HUD_TMUX_TEAM_HEIGHT_LINES, expectedPanePid, expectedPaneOwnerId) {
+    return ['run-shell', buildBestEffortShellCommand(buildAuthoritativeHudResizeShellCommand(hudPaneId, heightLines, expectedPanePid, expectedPaneOwnerId))];
 }
-function redrawLeaderPaneAfterTeamLayout(leaderPaneId) {
-    const target = leaderPaneId.trim();
-    if (!target.startsWith('%'))
-        return;
-    runTmux(['send-keys', '-t', target, 'C-l']);
+function redrawLeaderPaneAfterTeamLayout(source, expectedTeamOwnerId) {
+    const provenTarget = requireLiveTeamOwnedPaneSync(source.paneId, source.panePid, expectedTeamOwnerId);
+    if (provenTarget !== source.paneId)
+        throw new Error(`tmux pane identity changed: ${source.paneId}`);
+    runSourceAuthorizedTmux(source, `send-keys -t ${source.paneId} C-l`);
 }
 const ZSH_CANDIDATE_PATHS = ['/bin/zsh', '/usr/bin/zsh', '/usr/local/bin/zsh', '/opt/local/bin/zsh', '/opt/homebrew/bin/zsh'];
 const BASH_CANDIDATE_PATHS = ['/bin/bash', '/usr/bin/bash'];
@@ -923,6 +1488,23 @@ function appendTeamWorkerMcpDisableOverrides(args, env) {
         args.splice(endOfOptionsIndex < 0 ? args.length : endOfOptionsIndex, 0, CONFIG_FLAG, `${key}=false`);
     }
 }
+const CODEX_BYPASS_MDM_INCOMPATIBLE_REASON = 'codex_bypass_mdm_incompatible';
+const CODEX_BYPASS_MDM_REJECTED_MARKER = 'MDM_POLICY_REJECTED: approval_policy=never forbids --dangerously-bypass-approvals-and-sandbox';
+export function classifyCodexBypassMdmIncompatibility(captured, workerCli, finalArgs) {
+    if (workerCli !== 'codex' || !finalArgs || !parseTeamWorkerLaunchArgs([...finalArgs], 'final tmux worker arguments', { directPolicyMode: 'ignore' }).wantsBypass)
+        return null;
+    const normalizedLines = captured.replace(/\r\n?/g, '\n').split('\n');
+    return normalizedLines.includes(CODEX_BYPASS_MDM_REJECTED_MARKER)
+        ? CODEX_BYPASS_MDM_INCOMPATIBLE_REASON
+        : null;
+}
+function buildAttachedTmuxWorkerStartupPlan(teamName, workerIndex, launchArgs, cwd, extraEnv, workerCliOverride, initialPrompt, workerRole) {
+    const processSpec = buildWorkerStartupProcessLaunchSpec(teamName, workerIndex, launchArgs, cwd, extraEnv, workerCliOverride, initialPrompt, workerRole);
+    const startupArgs = [...processSpec.args];
+    if (processSpec.workerCli === 'codex')
+        appendTeamWorkerMcpDisableOverrides(startupArgs, { ...process.env, ...extraEnv });
+    return Object.freeze({ processSpec, startupArgs: Object.freeze(startupArgs) });
+}
 function insertArgsBeforeEndOfOptions(args, insertedArgs) {
     const endOfOptionsIndex = args.indexOf('--');
     if (endOfOptionsIndex < 0)
@@ -1046,24 +1628,17 @@ function buildWorkerStartupScriptContent(processSpec, startupEnv, startupArgs, c
         '',
     ].filter((line) => line !== '').join('\n');
 }
-export function writeWorkerStartupScriptCommand(teamName, workerIndex, launchArgs = [], cwd = process.cwd(), extraEnv = {}, workerCliOverride, initialPrompt, workerRole) {
+export function writeWorkerStartupScriptCommand(teamName, workerIndex, launchArgs = [], cwd = process.cwd(), extraEnv = {}, workerCliOverride, initialPrompt, workerRole, attachedPlan) {
     if (process.platform === 'win32' && !isMsysOrGitBash())
         return null;
     const stateRoot = extraEnv[OMX_TEAM_STATE_ROOT_ENV]?.trim();
     if (!stateRoot)
         return null;
-    const processSpec = buildWorkerStartupProcessLaunchSpec(teamName, workerIndex, launchArgs, cwd, extraEnv, workerCliOverride, initialPrompt, workerRole);
-    const startupEnv = {
-        ...readTmuxWorkerAmbientEnv(process.env),
-        ...processSpec.env,
-    };
-    const startupArgs = [...processSpec.args];
-    if (processSpec.workerCli === 'codex') {
-        appendTeamWorkerMcpDisableOverrides(startupArgs, { ...process.env, ...extraEnv });
-    }
+    const startupPlan = attachedPlan ?? buildAttachedTmuxWorkerStartupPlan(teamName, workerIndex, launchArgs, cwd, extraEnv, workerCliOverride, initialPrompt, workerRole);
+    const startupEnv = { ...readTmuxWorkerAmbientEnv(process.env), ...startupPlan.processSpec.env };
     const scriptPath = join(stateRoot, 'team', teamName, 'runtime', `worker-${workerIndex}-startup.sh`);
     mkdirSync(dirname(scriptPath), { recursive: true });
-    writeFileSync(scriptPath, buildWorkerStartupScriptContent(processSpec, startupEnv, startupArgs, cwd, extraEnv), 'utf-8');
+    writeFileSync(scriptPath, buildWorkerStartupScriptContent(startupPlan.processSpec, startupEnv, [...startupPlan.startupArgs], cwd, extraEnv), 'utf-8');
     chmodSync(scriptPath, 0o700);
     return `exec /bin/sh ${shellQuoteSingle(translatePathForMsys(scriptPath))}`;
 }
@@ -1217,7 +1792,20 @@ export function createTeamSession(teamName, workerCount, cwd, workerLaunchArgs =
     const safeTeamName = sanitizeTeamName(teamName);
     let registeredResizeHook = null;
     let registeredClientAttachedHook = null;
-    const rollbackPaneIds = [];
+    const rollbackPanes = new Map();
+    // An owner-tag command may have succeeded even if tmux reports an ambiguous
+    // failure; rollback can only kill panes whose owner is re-authorized.
+    const rollbackTaggedPaneOwnerIds = new Map();
+    let partialTeamTarget = null;
+    let partialLeaderPaneId = null;
+    let partialLeaderPanePid;
+    let partialTeamPaneOwnerId = '';
+    const partialWorkerPaneIds = [];
+    const partialWorkerPaneIdsByIndex = Array.from({ length: workerCount }, () => null);
+    const partialWorkerPanePidsByIndex = Array.from({ length: workerCount }, () => null);
+    const partialStartupCleanupPanePids = new Map();
+    let partialHudPaneId = null;
+    let partialHudPanePid = null;
     try {
         const tmuxPaneTarget = process.env.TMUX_PANE;
         const displayArgs = tmuxPaneTarget
@@ -1234,82 +1822,185 @@ export function createTeamSession(teamName, workerCount, cwd, workerLaunchArgs =
             throw new Error(`failed to parse current tmux target: ${context.stdout}`);
         }
         const teamTarget = `${sessionName}:${windowIndex}`;
+        partialTeamTarget = teamTarget;
         const ownerSessionId = (options.ownerSessionId ?? process.env.OMX_SESSION_ID ?? '').trim();
         const teamPaneOwnerId = (options.teamPaneOwnerId ?? `team:${safeTeamName}`).trim();
-        if (ownerSessionId) {
-            const tagResult = runTmux(['set-option', '-t', sessionName, OMX_INSTANCE_OPTION, ownerSessionId]);
-            if (!tagResult.ok) {
-                throw new Error(`failed to tag tmux session ${sessionName}: ${tagResult.stderr}`);
-            }
+        partialTeamPaneOwnerId = teamPaneOwnerId;
+        const paneListResult = listPanesResult(teamTarget);
+        if (paneListResult.error)
+            throw new Error(`failed to read tmux pane topology: ${paneListResult.error}`);
+        const leaderPaneId = chooseTeamLeaderPaneId(paneListResult.panes, detectedLeaderPaneId);
+        const leaderProof = readExactPaneProofSync(leaderPaneId);
+        if (leaderProof.status === 'unavailable')
+            throw new ExactPaneProofUnavailableError(leaderProof);
+        if (leaderProof.status === 'gone')
+            throw new Error(`tmux pane is not proven live: ${leaderPaneId}`);
+        let leaderSource = captureSourcePaneAuthority(leaderPaneId);
+        if (leaderSource.sessionName !== sessionName || leaderSource.windowIndex !== windowIndex || leaderSource.panePid !== leaderProof.pid) {
+            throw new Error('tmux source authority changed during team startup');
         }
-        const panes = listPanes(teamTarget);
-        const leaderPaneId = chooseTeamLeaderPaneId(panes, detectedLeaderPaneId);
-        tagPaneInstance(leaderPaneId, ownerSessionId);
-        tagPaneTeamOwner(leaderPaneId, teamPaneOwnerId);
-        const initialHudPaneIds = findHudPaneIds(teamTarget, leaderPaneId);
+        const leaderPanePid = leaderSource.panePid;
+        partialLeaderPaneId = leaderPaneId;
+        partialLeaderPanePid = leaderPanePid;
+        const initialHudPaneIds = findHudWatchPaneIds(paneListResult.panes, leaderPaneId, { leaderPaneId });
+        const initialWindowPanePids = new Map([[leaderPaneId, leaderPanePid]]);
         const omxEntry = resolveOmxCliEntryPath();
         const canRecreateTeamHud = Boolean(omxEntry && omxEntry.trim() !== '');
+        // Freeze every HUD owned by this leader even when startup cannot recreate
+        // it; the untouched pane remains part of the authorized topology.
+        for (const hudPaneId of initialHudPaneIds) {
+            const proof = readExactPaneProofSync(hudPaneId);
+            if (proof.status === 'unavailable')
+                throw new ExactPaneProofUnavailableError(proof);
+            if (proof.status === 'gone')
+                throw new Error(`tmux pane is not proven live: ${hudPaneId}`);
+            initialWindowPanePids.set(hudPaneId, proof.pid);
+        }
         // Team mode prioritizes leader + worker visibility. Remove HUD panes only
         // when we can recreate the team HUD. Otherwise keep the existing HUD alive
         // instead of making it disappear on team startup failures or broken installs.
+        requireFrozenWindowTopologySync(teamTarget, initialWindowPanePids);
+        if (ownerSessionId) {
+            runSourceAuthorizedTmux(leaderSource, `set-option -t ${leaderSource.sessionId} ${OMX_INSTANCE_OPTION} ${shellQuoteSingle(ownerSessionId)}`);
+        }
+        if (ownerSessionId) {
+            runSourceAuthorizedTmux(leaderSource, `set-option -p -t ${leaderPaneId} ${OMX_PANE_INSTANCE_OPTION} ${shellQuoteSingle(ownerSessionId)}`);
+        }
+        runSourceAuthorizedTmux(leaderSource, `set-option -p -t ${leaderPaneId} ${OMX_TEAM_PANE_OWNER_OPTION} ${shellQuoteSingle(teamPaneOwnerId)}`);
+        // All subsequent Team mutations must bind the frozen leader owner in the
+        // same tmux-server transaction as their effect. The initial tag itself is
+        // deliberately the sole bootstrap mutation before an owner exists.
+        leaderSource = captureSourcePaneAuthority(leaderPaneId, teamPaneOwnerId);
+        const exactProveAndTagReconciledPane = (paneId) => {
+            const proof = readExactPaneProofSync(paneId);
+            if (proof.status === 'unavailable')
+                throw new ExactPaneProofUnavailableError(proof);
+            if (proof.status === 'gone')
+                return null;
+            const paneSource = captureSourcePaneAuthority(paneId);
+            if (paneSource.panePid !== proof.pid)
+                throw new Error(`tmux pane identity changed: ${paneId}`);
+            if (paneSource.teamPaneOwnerId && paneSource.teamPaneOwnerId !== teamPaneOwnerId) {
+                throw new Error(`tmux pane team owner changed: ${paneId}`);
+            }
+            if (ownerSessionId) {
+                runSourceAuthorizedTmux(paneSource, `set-option -p -t ${paneId} ${OMX_PANE_INSTANCE_OPTION} ${shellQuoteSingle(ownerSessionId)}`);
+            }
+            rollbackTaggedPaneOwnerIds.set(paneId, teamPaneOwnerId);
+            runSourceAuthorizedTmux(paneSource, `set-option -p -t ${paneId} ${OMX_TEAM_PANE_OWNER_OPTION} ${shellQuoteSingle(teamPaneOwnerId)}`);
+            rollbackPanes.set(paneId, proof.pid);
+            return proof.pid;
+        };
         if (canRecreateTeamHud) {
-            for (const hudPaneId of initialHudPaneIds) {
-                runTmux(['kill-pane', '-t', hudPaneId]);
+            for (const [hudPaneId, hudPanePid] of initialWindowPanePids) {
+                if (hudPaneId !== leaderPaneId)
+                    killExactPaneSync(hudPaneId, hudPanePid);
             }
         }
         const workerPaneIds = [];
+        const workerStartupArgs = Array.from({ length: workerCount }, () => Object.freeze([]));
+        const workerPanePidsByIndex = Array.from({ length: workerCount }, () => null);
         let rightStackRootPaneId = null;
+        let rightStackRootPanePid = null;
+        const frozenWindowPanePids = new Map([[leaderPaneId, leaderPanePid]]);
+        const frozenWindowPaneOwners = new Map([[leaderPaneId, teamPaneOwnerId]]);
         for (let i = 1; i <= workerCount; i++) {
             const startup = workerStartups[i - 1] || {};
             const workerCwd = startup.cwd || cwd;
             const tmuxWorkerCwd = translatePathForMsys(workerCwd);
             const workerEnv = startup.env || {};
             const launchArgsForWorker = [...(workerLaunchPolicyPlan[i - 1] ?? workerLaunchArgs)];
+            const attachedStartupPlan = buildAttachedTmuxWorkerStartupPlan(safeTeamName, i, launchArgsForWorker, workerCwd, workerEnv, workerCliPlan[i - 1], startup.initialPrompt, startup.workerRole);
+            workerStartupArgs[i - 1] = attachedStartupPlan.startupArgs;
             trustWorkerMiseConfigIfAvailable(workerCwd);
-            const cmd = writeWorkerStartupScriptCommand(safeTeamName, i, launchArgsForWorker, workerCwd, workerEnv, workerCliPlan[i - 1], startup.initialPrompt, startup.workerRole) ?? buildWorkerStartupCommand(safeTeamName, i, launchArgsForWorker, workerCwd, workerEnv, workerCliPlan[i - 1], startup.initialPrompt, startup.workerRole);
+            const cmd = writeWorkerStartupScriptCommand(safeTeamName, i, launchArgsForWorker, workerCwd, workerEnv, workerCliPlan[i - 1], startup.initialPrompt, startup.workerRole, attachedStartupPlan) ?? buildWorkerStartupCommand(safeTeamName, i, launchArgsForWorker, workerCwd, workerEnv, workerCliPlan[i - 1], startup.initialPrompt, startup.workerRole);
             // First split creates the right side from leader. Remaining splits stack on the right.
             const splitDirection = i === 1 ? '-h' : '-v';
-            const splitTarget = i === 1 ? leaderPaneId : (rightStackRootPaneId ?? leaderPaneId);
-            const split = runTmux([
-                'split-window',
-                splitDirection,
-                '-t',
-                splitTarget,
-                '-d',
-                '-P',
-                '-F',
-                '#{pane_id}',
-                '-c',
-                tmuxWorkerCwd,
-                cmd,
-            ]);
-            if (!split.ok) {
-                throw new Error(`failed to create worker pane ${i}: ${split.stderr}`);
+            const splitTarget = requireLiveTeamOwnedPaneSync(i === 1 ? leaderPaneId : (rightStackRootPaneId ?? leaderPaneId), i === 1 ? leaderPanePid : (rightStackRootPanePid ?? leaderPanePid), teamPaneOwnerId);
+            const splitSource = captureSourcePaneAuthority(splitTarget, teamPaneOwnerId);
+            let paneId;
+            try {
+                paneId = runSourceAuthorizedSplit(splitSource, (receipt) => `split-window ${splitDirection} -t ${splitTarget} -d -P -F '#{pane_id}' -c ${shellQuoteSingle(tmuxWorkerCwd)} ${shellQuoteSingle(bindSplitReceiptToPaneCommand(cmd, receipt))}`);
             }
-            const paneId = split.stdout.split('\n')[0]?.trim();
-            if (!paneId || !paneId.startsWith('%')) {
-                throw new Error(`failed to capture worker pane id for worker ${i}`);
+            catch (error) {
+                if (error instanceof AmbiguousSplitWindowOutputError) {
+                    const isUnassignedAmbiguity = error.newlyObservedPaneIds.length > 1;
+                    for (const candidatePaneId of error.newlyObservedPaneIds) {
+                        rollbackPanes.set(candidatePaneId, null);
+                        partialWorkerPaneIds.push(candidatePaneId);
+                        if (isUnassignedAmbiguity)
+                            partialStartupCleanupPanePids.set(candidatePaneId, null);
+                    }
+                    if (error.newlyObservedPaneIds.length === 1) {
+                        partialWorkerPaneIdsByIndex[i - 1] = error.newlyObservedPaneIds[0];
+                    }
+                    for (const candidatePaneId of error.newlyObservedPaneIds) {
+                        const reconciledPid = exactProveAndTagReconciledPane(candidatePaneId);
+                        if (reconciledPid === null) {
+                            rollbackPanes.delete(candidatePaneId);
+                            partialWorkerPaneIds.splice(partialWorkerPaneIds.lastIndexOf(candidatePaneId), 1);
+                            partialStartupCleanupPanePids.delete(candidatePaneId);
+                            if (partialWorkerPaneIdsByIndex[i - 1] === candidatePaneId) {
+                                partialWorkerPaneIdsByIndex[i - 1] = null;
+                            }
+                        }
+                        else if (isUnassignedAmbiguity) {
+                            partialStartupCleanupPanePids.set(candidatePaneId, reconciledPid);
+                        }
+                        else {
+                            partialWorkerPanePidsByIndex[i - 1] = reconciledPid;
+                        }
+                    }
+                }
+                throw error;
             }
-            rollbackPaneIds.push(paneId);
+            // The pane exists once split-window returns its concrete ID. Persist it in
+            // rollback/partial state before its first proof: a malformed or unavailable
+            // topology must retain cleanup debt, but cannot authorize an effect.
+            rollbackPanes.set(paneId, null);
+            partialWorkerPaneIds.push(paneId);
+            partialWorkerPaneIdsByIndex[i - 1] = paneId;
+            const paneProof = readExactPaneProofSync(paneId);
+            if (paneProof.status === 'unavailable')
+                throw new ExactPaneProofUnavailableError(paneProof);
+            if (paneProof.status === 'gone')
+                throw new Error(`tmux pane is not proven live: ${paneId}`);
+            const panePid = paneProof.pid;
+            rollbackPanes.set(paneId, panePid);
+            partialWorkerPanePidsByIndex[i - 1] = panePid;
+            workerPanePidsByIndex[i - 1] = panePid;
+            frozenWindowPanePids.set(paneId, panePid);
             if (isNativeWindows() && !waitForPaneToRemainPresent(teamTarget, paneId)) {
                 throw new Error(`worker pane ${i} did not remain present after tmux split-window returned ${paneId}`);
             }
-            tagPaneInstance(paneId, ownerSessionId);
-            tagPaneTeamOwner(paneId, teamPaneOwnerId);
+            const paneSource = captureSourcePaneAuthority(paneId);
+            if (paneSource.panePid !== panePid)
+                throw new Error(`tmux pane identity changed: ${paneId}`);
+            if (ownerSessionId) {
+                runSourceAuthorizedTmux(paneSource, `set-option -p -t ${paneId} ${OMX_PANE_INSTANCE_OPTION} ${shellQuoteSingle(ownerSessionId)}`);
+            }
+            rollbackTaggedPaneOwnerIds.set(paneId, teamPaneOwnerId);
+            runSourceAuthorizedTmux(paneSource, `set-option -p -t ${paneId} ${OMX_TEAM_PANE_OWNER_OPTION} ${shellQuoteSingle(teamPaneOwnerId)}`);
+            frozenWindowPaneOwners.set(paneId, teamPaneOwnerId);
             workerPaneIds.push(paneId);
-            if (i === 1)
+            if (i === 1) {
                 rightStackRootPaneId = paneId;
+                rightStackRootPanePid = panePid;
+            }
         }
         // Keep leader as full left/main pane; workers stay stacked on the right.
-        runTmux(['select-layout', '-t', teamTarget, 'main-vertical']);
+        requireFrozenWindowTopologySync(teamTarget, frozenWindowPanePids, frozenWindowPaneOwners);
+        runSourceAuthorizedTmux(leaderSource, `select-layout -t ${leaderSource.windowId} main-vertical`);
         // Force leader pane to use half the window width.
         const windowWidthResult = runTmux(['display-message', '-p', '-t', teamTarget, '#{window_width}']);
         if (windowWidthResult.ok) {
             const width = Number.parseInt(windowWidthResult.stdout.split('\n')[0]?.trim() || '', 10);
             if (Number.isFinite(width) && width >= 40) {
                 const half = String(Math.floor(width / 2));
-                runTmux(['set-window-option', '-t', teamTarget, 'main-pane-width', half]);
-                runTmux(['select-layout', '-t', teamTarget, 'main-vertical']);
+                requireFrozenWindowTopologySync(teamTarget, frozenWindowPanePids, frozenWindowPaneOwners);
+                runSourceAuthorizedTmux(leaderSource, `set-window-option -t ${leaderSource.windowId} main-pane-width ${half}`);
+                requireFrozenWindowTopologySync(teamTarget, frozenWindowPanePids, frozenWindowPaneOwners);
+                runSourceAuthorizedTmux(leaderSource, `select-layout -t ${leaderSource.windowId} main-vertical`);
             }
         }
         // Re-create a single team HUD as a full-width bottom strip spanning both
@@ -1322,82 +2013,159 @@ export function createTeamSession(teamName, workerCount, cwd, workerLaunchArgs =
         if (canRecreateTeamHud && omxEntry) {
             const hudCmd = `exec env ${formatHudEnvAssignments(process.env, { sessionId: ownerSessionId, leaderPaneId })} node ${shellQuoteSingle(translatePathForMsys(omxEntry))} hud --watch`;
             const hudCwd = translatePathForMsys(cwd);
-            const hudResult = runTmux([
-                'split-window', '-v', '-f', '-l', String(HUD_TMUX_TEAM_HEIGHT_LINES), '-t', teamTarget, '-d', '-P', '-F', '#{pane_id}', '-c', hudCwd, hudCmd,
-            ]);
-            if (hudResult.ok) {
-                const id = hudResult.stdout.split('\n')[0]?.trim() ?? '';
-                if (id.startsWith('%')) {
-                    rollbackPaneIds.push(id);
-                    if (isNativeWindows() && !waitForPaneToRemainPresent(teamTarget, id)) {
-                        throw new Error(`HUD pane did not remain present after tmux split-window returned ${id}`);
+            requireFrozenWindowTopologySync(teamTarget, frozenWindowPanePids, frozenWindowPaneOwners);
+            const hudSplitTarget = leaderPaneId;
+            const hudSource = captureSourcePaneAuthority(hudSplitTarget, teamPaneOwnerId);
+            let id;
+            try {
+                id = runSourceAuthorizedSplit(hudSource, (receipt) => `split-window -v -f -l ${HUD_TMUX_TEAM_HEIGHT_LINES} -t ${hudSplitTarget} -d -P -F '#{pane_id}' -c ${shellQuoteSingle(hudCwd)} ${shellQuoteSingle(bindSplitReceiptToPaneCommand(hudCmd, receipt))}`);
+            }
+            catch (error) {
+                if (error instanceof AmbiguousSplitWindowOutputError) {
+                    const isUnassignedAmbiguity = error.newlyObservedPaneIds.length > 1;
+                    for (const candidatePaneId of error.newlyObservedPaneIds) {
+                        rollbackPanes.set(candidatePaneId, null);
+                        if (isUnassignedAmbiguity)
+                            partialStartupCleanupPanePids.set(candidatePaneId, null);
                     }
-                    tagPaneInstance(id, ownerSessionId);
-                    tagPaneTeamOwner(id, teamPaneOwnerId);
-                    hudPaneId = id;
-                    if (isNativeWindows()) {
-                        // Native Windows tmux support may flow through psmux; issuing a
-                        // direct control-plane resize avoids nested run-shell PATH drift.
-                        const reconcile = runTmux(buildHudResizeArgs(hudPaneId));
-                        if (!reconcile.ok) {
-                            throw new Error(`failed to reconcile HUD resize: ${reconcile.stderr}`);
-                        }
+                    if (error.newlyObservedPaneIds.length === 1) {
+                        partialHudPaneId = error.newlyObservedPaneIds[0];
+                        partialHudPanePid = null;
                     }
-                    else {
-                        const hookTarget = buildResizeHookTarget(sessionName, windowIndex);
-                        const hookName = buildResizeHookName(safeTeamName, sessionName, windowIndex, hudPaneId);
-                        const registerHook = runTmux(buildRegisterResizeHookArgs(hookTarget, hookName, hudPaneId));
-                        const clientAttachedHookName = buildClientAttachedReconcileHookName(safeTeamName, sessionName, windowIndex, hudPaneId);
-                        if (registerHook.ok) {
-                            resizeHookTarget = hookTarget;
-                            resizeHookName = hookName;
-                            registeredResizeHook = { name: resizeHookName, target: resizeHookTarget };
+                    for (const candidatePaneId of error.newlyObservedPaneIds) {
+                        const reconciledPid = exactProveAndTagReconciledPane(candidatePaneId);
+                        if (reconciledPid === null) {
+                            rollbackPanes.delete(candidatePaneId);
+                            partialStartupCleanupPanePids.delete(candidatePaneId);
+                            if (partialHudPaneId === candidatePaneId)
+                                partialHudPaneId = null;
                         }
-                        else {
-                            // tmux versions/builds that reject indexed client-resized hooks should not
-                            // abort madmax/team startup after panes were successfully created. Keep the
-                            // fallback narrow: skip only the long-lived resize hook metadata, then
-                            // still try the one-shot client-attached reconcile plus the explicit
-                            // delayed/direct resize checks below so real tmux/run-shell failures
-                            // still surface.
-                            console.warn(`[omx] tmux resize hook unavailable for ${hookTarget} (${hookName}): ${registerHook.stderr}; `
-                                + 'continuing with best-effort HUD resize fallback.');
-                        }
-                        const registerClientAttachedHook = runTmux(buildRegisterClientAttachedReconcileArgs(hookTarget, clientAttachedHookName, hudPaneId));
-                        if (registerClientAttachedHook.ok) {
-                            registeredClientAttachedHook = { name: clientAttachedHookName, target: hookTarget };
+                        else if (isUnassignedAmbiguity) {
+                            partialStartupCleanupPanePids.set(candidatePaneId, reconciledPid);
                         }
                         else {
-                            console.warn(`[omx] tmux client-attached resize fallback unavailable for ${hookTarget} `
-                                + `(${clientAttachedHookName}): ${registerClientAttachedHook.stderr}; continuing with delayed HUD resize fallback.`);
-                        }
-                        const delayed = runTmux(buildScheduleDelayedHudResizeArgs(hudPaneId));
-                        if (!delayed.ok) {
-                            console.warn(`[omx] tmux delayed HUD resize unavailable for ${hudPaneId}: ${delayed.stderr}; continuing.`);
-                        }
-                        const reconcile = runTmux(buildReconcileHudResizeArgs(hudPaneId));
-                        if (!reconcile.ok) {
-                            console.warn(`[omx] tmux HUD resize reconcile unavailable for ${hudPaneId}: ${reconcile.stderr}; continuing.`);
+                            partialHudPanePid = reconciledPid;
                         }
                     }
                 }
+                throw error;
+            }
+            {
+                // split-window has created a concrete pane even though no proof has
+                // authorized an effect yet. Retain PID-less cleanup debt first.
+                rollbackPanes.set(id, null);
+                partialHudPaneId = id;
+                partialHudPanePid = null;
+                const hudProof = readExactPaneProofSync(id);
+                if (hudProof.status === 'unavailable')
+                    throw new ExactPaneProofUnavailableError(hudProof);
+                if (hudProof.status === 'gone')
+                    throw new Error(`tmux pane is not proven live: ${id}`);
+                const hudPanePid = hudProof.pid;
+                frozenWindowPanePids.set(id, hudPanePid);
+                rollbackPanes.set(id, hudPanePid);
+                partialHudPanePid = hudPanePid;
+                if (isNativeWindows() && !waitForPaneToRemainPresent(teamTarget, id)) {
+                    throw new Error(`HUD pane did not remain present after tmux split-window returned ${id}`);
+                }
+                const hudSource = captureSourcePaneAuthority(id);
+                if (hudSource.panePid !== hudPanePid)
+                    throw new Error(`tmux pane identity changed: ${id}`);
+                if (ownerSessionId) {
+                    runSourceAuthorizedTmux(hudSource, `set-option -p -t ${id} ${OMX_PANE_INSTANCE_OPTION} ${shellQuoteSingle(ownerSessionId)}`);
+                }
+                rollbackTaggedPaneOwnerIds.set(id, teamPaneOwnerId);
+                runSourceAuthorizedTmux(hudSource, `set-option -p -t ${id} ${OMX_TEAM_PANE_OWNER_OPTION} ${shellQuoteSingle(teamPaneOwnerId)}`);
+                frozenWindowPaneOwners.set(id, teamPaneOwnerId);
+                hudPaneId = id;
+                if (isNativeWindows()) {
+                    const provenHudPaneId = requireLiveTeamOwnedPaneSync(hudPaneId, hudPanePid, teamPaneOwnerId);
+                    const reconcile = runTmux(buildHudResizeArgs(provenHudPaneId));
+                    if (!reconcile.ok) {
+                        throw new Error(`failed to reconcile HUD resize: ${reconcile.stderr}`);
+                    }
+                }
+                else {
+                    const hookTarget = buildResizeHookTarget(sessionName, windowIndex);
+                    const hookName = buildResizeHookName(safeTeamName, sessionName, windowIndex, hudPaneId);
+                    requireLiveTeamOwnedPaneSync(hudPaneId, hudPanePid, teamPaneOwnerId);
+                    const registerHook = runTmux(buildRegisterResizeHookArgs(hookTarget, hookName, hudPaneId, HUD_TMUX_TEAM_HEIGHT_LINES, hudPanePid, teamPaneOwnerId));
+                    const clientAttachedHookName = buildClientAttachedReconcileHookName(safeTeamName, sessionName, windowIndex, hudPaneId);
+                    if (registerHook.ok) {
+                        resizeHookTarget = hookTarget;
+                        resizeHookName = hookName;
+                        registeredResizeHook = {
+                            name: resizeHookName,
+                            target: resizeHookTarget,
+                            leaderPaneId,
+                            leaderPanePid,
+                            hudPaneId,
+                            hudPanePid,
+                            teamPaneOwnerId,
+                        };
+                    }
+                    else {
+                        console.warn(`[omx] tmux resize hook unavailable for ${hookTarget} (${hookName}): ${registerHook.stderr}; `
+                            + 'continuing with best-effort HUD resize fallback.');
+                    }
+                    requireLiveTeamOwnedPaneSync(hudPaneId, hudPanePid, teamPaneOwnerId);
+                    const registerClientAttachedHook = runTmux(buildRegisterClientAttachedReconcileArgs(hookTarget, clientAttachedHookName, hudPaneId, HUD_TMUX_TEAM_HEIGHT_LINES, hudPanePid, teamPaneOwnerId));
+                    if (registerClientAttachedHook.ok) {
+                        registeredClientAttachedHook = {
+                            name: clientAttachedHookName,
+                            target: hookTarget,
+                            leaderPaneId,
+                            leaderPanePid,
+                            hudPaneId,
+                            hudPanePid,
+                            teamPaneOwnerId,
+                        };
+                    }
+                    else {
+                        console.warn(`[omx] tmux client-attached resize fallback unavailable for ${hookTarget} `
+                            + `(${clientAttachedHookName}): ${registerClientAttachedHook.stderr}; continuing with delayed HUD resize fallback.`);
+                    }
+                    requireLiveTeamOwnedPaneSync(hudPaneId, hudPanePid, teamPaneOwnerId);
+                    const delayed = runTmux(buildScheduleDelayedHudResizeArgs(hudPaneId, HUD_RESIZE_RECONCILE_DELAY_SECONDS, HUD_TMUX_TEAM_HEIGHT_LINES, hudPanePid, teamPaneOwnerId));
+                    if (!delayed.ok) {
+                        console.warn(`[omx] tmux delayed HUD resize unavailable for ${hudPaneId}: ${delayed.stderr}; continuing.`);
+                    }
+                    requireLiveTeamOwnedPaneSync(hudPaneId, hudPanePid, teamPaneOwnerId);
+                    const reconcile = runTmux(buildReconcileHudResizeArgs(hudPaneId, HUD_TMUX_TEAM_HEIGHT_LINES, hudPanePid, teamPaneOwnerId));
+                    if (!reconcile.ok) {
+                        console.warn(`[omx] tmux HUD resize reconcile unavailable for ${hudPaneId}: ${reconcile.stderr}; continuing.`);
+                    }
+                }
             }
         }
-        runTmux(['select-pane', '-t', leaderPaneId]);
-        redrawLeaderPaneAfterTeamLayout(leaderPaneId);
+        const focusedLeader = requireLiveTeamOwnedPaneSync(leaderPaneId, leaderPanePid, teamPaneOwnerId);
+        if (focusedLeader !== leaderSource.paneId)
+            throw new Error(`tmux pane identity changed: ${leaderPaneId}`);
+        runSourceAuthorizedTmux(leaderSource, `select-pane -t ${leaderPaneId}`);
+        redrawLeaderPaneAfterTeamLayout(leaderSource, teamPaneOwnerId);
         sleepSeconds(0.5);
         // Enable mouse scrolling so agent output panes can be scrolled with the
         // mouse wheel without conflicting with keyboard up/down arrow-key input
         // history navigation in the Codex CLI input field. (issue #103)
         // Opt-out: set OMX_TEAM_MOUSE=0 in the environment.
         if (process.env.OMX_TEAM_MOUSE !== '0') {
-            enableMouseScrolling(sessionName);
+            enableMouseScrolling(sessionName, () => { requireLiveTeamOwnedPaneSync(leaderPaneId, leaderPanePid, teamPaneOwnerId); });
         }
         return {
             name: teamTarget,
+            tmuxSessionId: leaderSource.sessionId,
+            tmuxSessionCreated: leaderSource.sessionCreated,
             workerCount,
             cwd,
             workerPaneIds,
+            workerPaneIdsByIndex: [...workerPaneIds],
+            workerPanePidsByIndex,
+            leaderPanePid,
+            workerStartupArgs: Object.freeze(workerStartupArgs),
+            leaderSessionId: leaderSource.sessionId,
+            leaderSessionCreated: leaderSource.sessionCreated,
+            leaderWindowId: leaderSource.windowId,
+            hudPanePid: partialHudPanePid,
             leaderPaneId,
             hudPaneId,
             resizeHookName,
@@ -1406,14 +2174,90 @@ export function createTeamSession(teamName, workerCount, cwd, workerLaunchArgs =
         };
     }
     catch (error) {
-        if (registeredClientAttachedHook) {
-            runTmux(buildUnregisterClientAttachedReconcileArgs(registeredClientAttachedHook.target, registeredClientAttachedHook.name));
+        const cleanupErrors = [];
+        if (error instanceof AmbiguousSplitWindowOutputError && error.reconciliationError) {
+            cleanupErrors.push('failed to reconcile tmux pane topology after ambiguous split output');
         }
-        if (registeredResizeHook) {
-            runTmux(buildUnregisterResizeHookArgs(registeredResizeHook.target, registeredResizeHook.name));
+        const unregisterAuthorizedHook = (hook, unregister, label) => {
+            try {
+                requireLiveTeamOwnedPaneSync(hook.leaderPaneId, hook.leaderPanePid, hook.teamPaneOwnerId);
+                requireLiveTeamOwnedPaneSync(hook.hudPaneId, hook.hudPanePid, hook.teamPaneOwnerId);
+                const unregistered = runTmux(unregister(hook.target, hook.name));
+                if (unregistered.ok)
+                    return true;
+                cleanupErrors.push(`failed to unregister tmux ${label} hook ${hook.name}: ${unregistered.stderr}`);
+            }
+            catch (cleanupError) {
+                cleanupErrors.push(`unable to authorize tmux ${label} hook cleanup ${hook.name}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+            return false;
+        };
+        if (registeredClientAttachedHook && unregisterAuthorizedHook(registeredClientAttachedHook, buildUnregisterClientAttachedReconcileArgs, 'client-attached')) {
+            registeredClientAttachedHook = null;
+        }
+        if (registeredResizeHook && unregisterAuthorizedHook(registeredResizeHook, buildUnregisterResizeHookArgs, 'resize')) {
+            registeredResizeHook = null;
+        }
+        const proofUnavailable = [];
+        if (error instanceof ExactPaneProofUnavailableError)
+            proofUnavailable.push(error.proof);
+        const unresolvedPaneIds = new Set(rollbackPanes.keys());
+        for (const [paneId, panePid] of rollbackPanes) {
+            // split-window IDs without a positive exact PID proof are cleanup debt,
+            // never authorization to affect a potentially recycled pane ID.
+            if (panePid === null)
+                continue;
+            try {
+                const expectedOwnerId = rollbackTaggedPaneOwnerIds.get(paneId);
+                killExactPaneSync(paneId, panePid, expectedOwnerId
+                    ? () => { requireLiveTeamOwnedPaneSync(paneId, panePid, expectedOwnerId); }
+                    : undefined);
+                unresolvedPaneIds.delete(paneId);
+            }
+            catch (cleanupError) {
+                if (cleanupError instanceof ExactPaneProofUnavailableError) {
+                    proofUnavailable.push(cleanupError.proof);
+                    break;
+                }
+                else {
+                    cleanupErrors.push(cleanupError instanceof Error ? cleanupError.message : String(cleanupError));
+                }
+            }
         }
-        for (const paneId of rollbackPaneIds) {
-            runTmux(['kill-pane', '-t', paneId]);
+        const unresolvedWorkerPaneIds = partialWorkerPaneIds.filter((paneId) => unresolvedPaneIds.has(paneId));
+        const unresolvedWorkerPaneIdsByIndex = partialWorkerPaneIdsByIndex
+            .map((paneId) => paneId && unresolvedPaneIds.has(paneId) ? paneId : null);
+        const unresolvedWorkerPanePidsByIndex = partialWorkerPanePidsByIndex
+            .map((panePid, index) => partialWorkerPaneIdsByIndex[index] && unresolvedPaneIds.has(partialWorkerPaneIdsByIndex[index]) ? panePid : null);
+        const unresolvedStartupCleanupPanes = [...partialStartupCleanupPanePids.entries()]
+            .filter(([paneId]) => unresolvedPaneIds.has(paneId))
+            .map(([paneId, panePid]) => ({ paneId, panePid }));
+        const unresolvedHudPaneId = partialHudPaneId && (unresolvedPaneIds.has(partialHudPaneId)
+            || registeredResizeHook !== null
+            || registeredClientAttachedHook !== null)
+            ? partialHudPaneId
+            : null;
+        const hasRecoverablePartialArtifact = unresolvedPaneIds.size > 0
+            || registeredResizeHook !== null
+            || registeredClientAttachedHook !== null
+            || (error instanceof AmbiguousSplitWindowOutputError && error.reconciliationError !== null);
+        if (hasRecoverablePartialArtifact && partialTeamTarget && partialLeaderPaneId) {
+            throw new CreateTeamSessionPartialError({
+                name: partialTeamTarget,
+                workerCount,
+                cwd,
+                workerPaneIds: unresolvedWorkerPaneIds,
+                workerPaneIdsByIndex: unresolvedWorkerPaneIdsByIndex,
+                workerPanePidsByIndex: unresolvedWorkerPanePidsByIndex,
+                startupCleanupPanes: unresolvedStartupCleanupPanes,
+                leaderPanePid: partialLeaderPanePid,
+                hudPanePid: unresolvedHudPaneId ? partialHudPanePid : null,
+                leaderPaneId: partialLeaderPaneId,
+                hudPaneId: unresolvedHudPaneId,
+                resizeHookName: registeredResizeHook?.name ?? null,
+                resizeHookTarget: registeredResizeHook?.target ?? null,
+                teamPaneOwnerId: partialTeamPaneOwnerId,
+            }, proofUnavailable, error, cleanupErrors);
         }
         throw error;
     }
@@ -1422,34 +2266,75 @@ export function restoreStandaloneHudPane(leaderPaneId, cwd, options = {}) {
     const normalizedLeaderPaneId = normalizePaneTarget(leaderPaneId);
     if (!normalizedLeaderPaneId)
         return null;
+    // The split is irreversible without a durable cleanup obligation. Validate
+    // its canonical Team-root location before authorizing any pane effect.
+    restoredHudCleanupDebtPath(cwd, options.stateRoot);
     const omxEntry = resolveOmxCliEntryPath();
     if (!omxEntry || omxEntry.trim() === '')
         return null;
-    const [existingHudPaneId, ...duplicateHudPaneIds] = findOwnedHudPaneIds(normalizedLeaderPaneId, normalizedLeaderPaneId);
+    const leaderPanePid = (() => {
+        const proof = readExactPaneProofSync(normalizedLeaderPaneId);
+        if (proof.status === 'unavailable')
+            throw new ExactPaneProofUnavailableError(proof);
+        if (proof.status === 'gone')
+            throw new Error(`tmux pane is not proven live: ${normalizedLeaderPaneId}`);
+        if (options.expectedLeaderPanePid !== undefined && proof.pid !== options.expectedLeaderPanePid) {
+            throw new Error(`tmux pane identity changed: ${normalizedLeaderPaneId}`);
+        }
+        return proof.pid;
+    })();
+    const requireAuthorizedLeaderPane = () => {
+        options.assertLeaderPaneAuthorization?.();
+        return requireLiveExactPaneSync(normalizedLeaderPaneId, options.expectedLeaderPanePid ?? leaderPanePid);
+    };
+    requireAuthorizedLeaderPane();
+    const paneListResult = listPanesResult(normalizedLeaderPaneId);
+    if (paneListResult.error)
+        throw new Error(`failed to read tmux pane topology: ${paneListResult.error}`);
+    const [existingHudPaneId, ...duplicateHudPaneIds] = findHudWatchPaneIds(paneListResult.panes, normalizedLeaderPaneId, { leaderPaneId: normalizedLeaderPaneId });
+    const ownedHudPanePids = new Map();
+    for (const paneId of [existingHudPaneId, ...duplicateHudPaneIds]) {
+        if (!paneId)
+            continue;
+        const proof = readExactPaneProofSync(paneId);
+        if (proof.status === 'unavailable')
+            throw new ExactPaneProofUnavailableError(proof);
+        if (proof.status === 'gone')
+            throw new Error(`tmux pane is not proven live: ${paneId}`);
+        ownedHudPanePids.set(paneId, proof.pid);
+    }
     for (const paneId of duplicateHudPaneIds) {
-        runTmux(['kill-pane', '-t', paneId]);
+        killExactPaneSync(paneId, ownedHudPanePids.get(paneId), requireAuthorizedLeaderPane);
     }
     if (existingHudPaneId) {
         if (isNativeWindows()) {
-            runTmux(buildHudResizeArgs(existingHudPaneId));
+            const exactHudPaneId = requireLiveExactPaneSync(existingHudPaneId, ownedHudPanePids.get(existingHudPaneId));
+            requireAuthorizedLeaderPane();
+            const reconcile = runTmux(buildHudResizeArgs(exactHudPaneId));
+            if (!reconcile.ok)
+                throw new Error(`failed to reconcile standalone HUD resize: ${reconcile.stderr}`);
         }
         else {
-            runTmux(buildScheduleDelayedHudResizeArgs(existingHudPaneId));
-            runTmux(buildReconcileHudResizeArgs(existingHudPaneId));
+            requireAuthorizedLeaderPane();
+            runTmux(buildScheduleDelayedHudResizeArgs(existingHudPaneId, HUD_RESIZE_RECONCILE_DELAY_SECONDS, HUD_TMUX_TEAM_HEIGHT_LINES, ownedHudPanePids.get(existingHudPaneId)));
+            requireAuthorizedLeaderPane();
+            runTmux(buildReconcileHudResizeArgs(existingHudPaneId, HUD_TMUX_TEAM_HEIGHT_LINES, ownedHudPanePids.get(existingHudPaneId)));
         }
-        runTmux(['select-pane', '-t', normalizedLeaderPaneId]);
+        runTmux(['select-pane', '-t', requireAuthorizedLeaderPane()]);
         return existingHudPaneId;
     }
-    const hudCmd = `exec env ${formatHudEnvAssignments(process.env, { sessionId: options.sessionId, leaderPaneId: normalizedLeaderPaneId })} ${shellQuoteSingle(translatePathForMsys(resolveLeaderNodePath()))} ${shellQuoteSingle(translatePathForMsys(omxEntry))} hud --watch`;
+    const beforeSplitPaneIds = new Set(paneListResult.panes.map((pane) => pane.paneId));
+    const splitReceipt = sourceTransactionReceipt();
+    const hudCmd = bindSplitReceiptToPaneCommand(`exec env ${formatHudEnvAssignments(process.env, { sessionId: options.sessionId, leaderPaneId: normalizedLeaderPaneId })} ${shellQuoteSingle(translatePathForMsys(resolveLeaderNodePath()))} ${shellQuoteSingle(translatePathForMsys(omxEntry))} hud --watch`, splitReceipt);
     let hudResult = null;
-    for (const restoreCwd of resolveStandaloneHudRestoreCwdCandidates(normalizedLeaderPaneId, cwd, options.cwd)) {
+    for (const restoreCwd of resolveStandaloneHudRestoreCwdCandidates(normalizedLeaderPaneId, cwd, options.cwd, requireAuthorizedLeaderPane)) {
         const candidateResult = runTmux([
             'split-window',
             '-v',
             '-l',
             String(HUD_TMUX_TEAM_HEIGHT_LINES),
             '-t',
-            normalizedLeaderPaneId,
+            requireAuthorizedLeaderPane(),
             '-d',
             '-P',
             '-F',
@@ -1457,7 +2342,7 @@ export function restoreStandaloneHudPane(leaderPaneId, cwd, options = {}) {
             '-c',
             translatePathForMsys(restoreCwd.rawPath),
             hudCmd,
-        ]);
+        ], true);
         if (candidateResult.ok) {
             hudResult = candidateResult;
             break;
@@ -1465,17 +2350,87 @@ export function restoreStandaloneHudPane(leaderPaneId, cwd, options = {}) {
     }
     if (!hudResult?.ok)
         return null;
-    const paneId = hudResult.stdout.split('\n')[0]?.trim() ?? '';
-    if (!paneId.startsWith('%'))
-        return null;
+    const paneId = parseSplitWindowPaneId(hudResult.stdout);
+    if (!paneId) {
+        const afterTopology = listPanesResult(normalizedLeaderPaneId);
+        if (afterTopology.error) {
+            throw new Error('restored_hud_split_topology_reconciliation_failed');
+        }
+        const newlyObservedPaneIds = afterTopology.panes
+            .filter((pane) => !beforeSplitPaneIds.has(pane.paneId) && pane.startCommand.includes(splitReceipt))
+            .map((pane) => pane.paneId);
+        if (newlyObservedPaneIds.length === 1) {
+            const reconciledPaneId = newlyObservedPaneIds[0];
+            persistRestoredHudCleanupDebtSync(cwd, {
+                schema_version: 1,
+                operation: 'restored_hud_cleanup',
+                pane_id: reconciledPaneId,
+                pane_pid: null,
+                leader_pane_id: normalizedLeaderPaneId,
+                leader_pane_pid: options.expectedLeaderPanePid ?? leaderPanePid,
+                leader_pane_owner_id: options.expectedLeaderPaneOwnerId?.trim() || null,
+                hud_owner_leader_pane_id: normalizedLeaderPaneId,
+            }, options.stateRoot);
+            const reconciledProof = readExactPaneProofSync(reconciledPaneId);
+            if (reconciledProof.status === 'unavailable')
+                throw new ExactPaneProofUnavailableError(reconciledProof);
+            if (reconciledProof.status === 'gone')
+                throw new Error(`tmux pane is not proven live: ${reconciledPaneId}`);
+            persistRestoredHudCleanupDebtSync(cwd, {
+                schema_version: 1,
+                operation: 'restored_hud_cleanup',
+                pane_id: reconciledPaneId,
+                pane_pid: reconciledProof.pid,
+                leader_pane_id: normalizedLeaderPaneId,
+                leader_pane_pid: options.expectedLeaderPanePid ?? leaderPanePid,
+                leader_pane_owner_id: options.expectedLeaderPaneOwnerId?.trim() || null,
+                hud_owner_leader_pane_id: normalizedLeaderPaneId,
+            }, options.stateRoot);
+        }
+        throw new Error('restored_hud_split_output_ambiguous');
+    }
+    persistRestoredHudCleanupDebtSync(cwd, {
+        schema_version: 1,
+        operation: 'restored_hud_cleanup',
+        pane_id: paneId,
+        pane_pid: null,
+        leader_pane_id: normalizedLeaderPaneId,
+        leader_pane_pid: options.expectedLeaderPanePid ?? leaderPanePid,
+        leader_pane_owner_id: options.expectedLeaderPaneOwnerId?.trim() || null,
+        hud_owner_leader_pane_id: normalizedLeaderPaneId,
+    }, options.stateRoot);
+    const hudPanePid = (() => {
+        const proof = readExactPaneProofSync(paneId);
+        if (proof.status === 'unavailable')
+            throw new ExactPaneProofUnavailableError(proof);
+        if (proof.status === 'gone')
+            throw new Error(`tmux pane is not proven live: ${paneId}`);
+        return proof.pid;
+    })();
+    persistRestoredHudCleanupDebtSync(cwd, {
+        schema_version: 1,
+        operation: 'restored_hud_cleanup',
+        pane_id: paneId,
+        pane_pid: hudPanePid,
+        leader_pane_id: normalizedLeaderPaneId,
+        leader_pane_pid: options.expectedLeaderPanePid ?? leaderPanePid,
+        leader_pane_owner_id: options.expectedLeaderPaneOwnerId?.trim() || null,
+        hud_owner_leader_pane_id: normalizedLeaderPaneId,
+    }, options.stateRoot);
     if (isNativeWindows()) {
-        runTmux(buildHudResizeArgs(paneId));
+        const exactHudPaneId = requireLiveExactPaneSync(paneId, hudPanePid);
+        requireAuthorizedLeaderPane();
+        const reconcile = runTmux(buildHudResizeArgs(exactHudPaneId));
+        if (!reconcile.ok)
+            throw new Error(`failed to reconcile standalone HUD resize: ${reconcile.stderr}`);
     }
     else {
-        runTmux(buildScheduleDelayedHudResizeArgs(paneId));
-        runTmux(buildReconcileHudResizeArgs(paneId));
+        requireAuthorizedLeaderPane();
+        runTmux(buildScheduleDelayedHudResizeArgs(paneId, HUD_RESIZE_RECONCILE_DELAY_SECONDS, HUD_TMUX_TEAM_HEIGHT_LINES, hudPanePid));
+        requireAuthorizedLeaderPane();
+        runTmux(buildReconcileHudResizeArgs(paneId, HUD_TMUX_TEAM_HEIGHT_LINES, hudPanePid));
     }
-    runTmux(['select-pane', '-t', normalizedLeaderPaneId]);
+    runTmux(['select-pane', '-t', requireAuthorizedLeaderPane()]);
     return paneId;
 }
 /**
@@ -1487,21 +2442,21 @@ export function restoreStandaloneHudPane(leaderPaneId, cwd, options = {}) {
  * oh-my-tmux, or other sessions. Returns true if the session mouse option
  * was set successfully, false otherwise.
  */
-export function enableMouseScrolling(sessionTarget) {
+export function enableMouseScrolling(sessionTarget, beforeEffect) {
+    beforeEffect?.();
     const result = runTmux(['set-option', '-t', sessionTarget, 'mouse', 'on']);
     if (!result.ok)
         return false;
     // Enable OSC 52 so copy-selection-and-cancel propagates selected text to
     // the terminal's clipboard without requiring xclip or pbcopy. (closes #206)
+    beforeEffect?.();
     runTmux(['set-option', '-t', sessionTarget, 'set-clipboard', 'on']);
     // Mouse selection enters tmux copy-mode. Keep the mitigation session-scoped
     // so OMX does not mutate users' global tmux style defaults. (issue #1448)
-    mitigateCopyModeUnderlineArtifacts(sessionTarget);
+    mitigateCopyModeUnderlineArtifacts(sessionTarget, beforeEffect);
     return true;
 }
-function paneTarget(sessionName, workerIndex, workerPaneId) {
-    if (workerPaneId && workerPaneId.startsWith('%'))
-        return workerPaneId;
+function paneTarget(sessionName, workerIndex) {
     if (sessionName.includes(':')) {
         return `${sessionName}.${workerIndex}`;
     }
@@ -1531,7 +2486,10 @@ function paneHasClaudeBypassPermissionsPrompt(captured) {
         && tail.some((line) => /Enter\s*to\s*confirm/i.test(line));
     return hasWarning && hasChoices;
 }
-export function evaluateStartupDirectTriggerSafetyCapture(captured, workerCli) {
+export function evaluateStartupDirectTriggerSafetyCapture(captured, workerCli, finalArgs) {
+    const incompatibleReason = classifyCodexBypassMdmIncompatibility(captured, workerCli, finalArgs);
+    if (incompatibleReason)
+        return { safe: false, reason: incompatibleReason };
     if (paneHasTrustPrompt(captured))
         return { safe: false, reason: 'trust_prompt' };
     if (paneHasClaudeBypassPermissionsPrompt(captured))
@@ -1544,27 +2502,53 @@ export function evaluateStartupDirectTriggerSafetyCapture(captured, workerCli) {
         return { safe: true, reason: 'codex_viewport' };
     return { safe: false, reason: 'not_agent_viewport' };
 }
-export async function evaluateStartupDirectTriggerSafety(sessionName, workerIndex, workerPaneId, workerCli) {
+export async function evaluateStartupDirectTriggerSafety(sessionName, workerIndex, workerPaneId, workerCli, finalArgs) {
     if (!isTmuxAvailable())
         return { safe: false, reason: 'tmux_unavailable' };
-    const target = paneTarget(sessionName, workerIndex, workerPaneId);
+    const target = await resolveWorkerPaneTargetAsync(sessionName, workerIndex, workerPaneId);
+    if (!target)
+        return { safe: false, reason: 'capture_failed' };
     const result = await runTmuxAsync(sharedBuildVisibleCapturePaneArgv(target));
     if (!result.ok)
         return { safe: false, reason: 'capture_failed' };
-    return evaluateStartupDirectTriggerSafetyCapture(result.stdout, workerCli);
+    return evaluateStartupDirectTriggerSafetyCapture(result.stdout, workerCli, finalArgs);
 }
-function acceptClaudeBypassPermissionsPrompt(target) {
-    runTmux(['send-keys', '-t', target, '-l', '--', '2']);
+function acceptClaudeBypassPermissionsPrompt(resolveTarget) {
+    const literalTarget = resolveTarget();
+    if (!literalTarget)
+        return false;
+    runTmux(['send-keys', '-t', literalTarget, '-l', '--', '2']);
     sleepFractionalSeconds(0.12);
-    runTmux(['send-keys', '-t', target, 'C-m']);
+    const submitTarget = resolveTarget();
+    if (!submitTarget)
+        return false;
+    runTmux(['send-keys', '-t', submitTarget, 'C-m']);
+    return true;
 }
-function dismissClaudeBypassPermissionsPromptIfPresent(target, captured) {
+function dismissClaudeBypassPermissionsPromptIfPresent(resolveTarget, captured) {
     if (process.env.OMX_TEAM_AUTO_ACCEPT_BYPASS === '0')
         return false;
     if (!paneHasClaudeBypassPermissionsPrompt(captured))
         return false;
-    acceptClaudeBypassPermissionsPrompt(target);
-    return true;
+    return acceptClaudeBypassPermissionsPrompt(resolveTarget);
+}
+async function dismissClaudeBypassPermissionsPromptIfPresentAsync(resolveTarget, captured) {
+    if (process.env.OMX_TEAM_AUTO_ACCEPT_BYPASS === '0')
+        return false;
+    if (!paneHasClaudeBypassPermissionsPrompt(captured))
+        return false;
+    const literalTarget = await resolveTarget();
+    if (!literalTarget)
+        return false;
+    const literalSend = await runTmuxAsync(['send-keys', '-t', literalTarget, '-l', '--', '2']);
+    if (!literalSend.ok)
+        return false;
+    await sleep(120);
+    const submitTarget = await resolveTarget();
+    if (!submitTarget)
+        return false;
+    const submitSend = await runTmuxAsync(['send-keys', '-t', submitTarget, 'C-m']);
+    return submitSend.ok;
 }
 export const paneHasActiveTask = sharedPaneHasActiveTask;
 export function classifyWorkerStartupInjectSafety(captured) {
@@ -1581,8 +2565,8 @@ export function classifyWorkerStartupInjectSafety(captured) {
     return 'safe';
 }
 export async function checkWorkerStartupInjectSafety(sessionName, workerIndex, workerPaneId) {
-    const target = paneTarget(sessionName, workerIndex, workerPaneId);
-    const visibleCapture = await captureVisiblePaneAsync(target);
+    const resolveTarget = () => resolveWorkerPaneTargetAsync(sessionName, workerIndex, workerPaneId);
+    const visibleCapture = await captureVisiblePaneAsync(resolveTarget);
     const visibleSafety = classifyWorkerStartupInjectSafety(visibleCapture);
     if (visibleSafety === 'safe')
         return { safe: true, reason: 'safe' };
@@ -1591,7 +2575,7 @@ export async function checkWorkerStartupInjectSafety(sessionName, workerIndex, w
     if (!sharedPaneShowsCodexViewport(visibleCapture)) {
         return { safe: false, reason: visibleSafety };
     }
-    const scrollbackCapture = await capturePaneAsync(target);
+    const scrollbackCapture = await capturePaneAsync(resolveTarget);
     const scrollbackSafety = classifyWorkerStartupInjectSafety(scrollbackCapture);
     return scrollbackSafety === 'safe'
         ? { safe: true, reason: 'safe' }
@@ -1669,8 +2653,9 @@ export function shouldAttemptAdaptiveRetry(strategy, paneBusyAtStart, allowAdapt
         return false;
     return true;
 }
-function sendLiteralTextOrThrow(target, text) {
-    const send = runTmux(['send-keys', '-t', target, '-l', '--', text]);
+async function sendLiteralTextOrThrow(resolveTarget, text) {
+    const target = await requireAsyncPaneTarget(resolveTarget);
+    const send = await runTmuxAsync(['send-keys', '-t', target, '-l', '--', text]);
     if (!send.ok) {
         throw new Error(`sendToWorker: failed to send text: ${send.stderr}`);
     }
@@ -1682,18 +2667,18 @@ function paneHasQueuedCodexSubmission(captured) {
     return /messages to be submitted after next tool call/i.test(normalized)
         || /press esc to interrupt and send immediately/i.test(normalized);
 }
-async function attemptSubmitRounds(target, text, rounds, queueFirstRound, submitKeyPressesPerRound) {
+async function attemptSubmitRounds(resolveTarget, text, rounds, queueFirstRound, submitKeyPressesPerRound) {
     const presses = Math.max(1, Math.floor(submitKeyPressesPerRound));
     for (let round = 0; round < rounds; round++) {
         await sleep(100);
         if (round === 0 && queueFirstRound) {
-            await sendKeyAsync(target, 'Tab');
+            await sendKeyAsync(resolveTarget, 'Tab');
             await sleep(80);
-            await sendKeyAsync(target, 'C-m');
+            await sendKeyAsync(resolveTarget, 'C-m');
         }
         else {
             for (let press = 0; press < presses; press++) {
-                await sendKeyAsync(target, 'C-m');
+                await sendKeyAsync(resolveTarget, 'C-m');
                 if (press < presses - 1) {
                     await sleep(200);
                 }
@@ -1701,8 +2686,8 @@ async function attemptSubmitRounds(target, text, rounds, queueFirstRound, submit
         }
         await sleep(140);
         const [captured, visibleCapture] = await Promise.all([
-            capturePaneAsync(target),
-            captureVisiblePaneAsync(target),
+            capturePaneAsync(resolveTarget),
+            captureVisiblePaneAsync(resolveTarget),
         ]);
         const normalizedCapture = normalizeWorkerTriggerForDraftMatch(captured);
         if (!normalizedCapture.includes(normalizeWorkerTriggerForDraftMatch(text))
@@ -1713,26 +2698,34 @@ async function attemptSubmitRounds(target, text, rounds, queueFirstRound, submit
     }
     return false;
 }
-export function waitForWorkerReady(sessionName, workerIndex, timeoutMs = 30_000, workerPaneId) {
+export function waitForWorkerReady(sessionName, workerIndex, timeoutMs = 30_000, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId) {
     const initialBackoffMs = 150;
     const maxBackoffMs = 8000;
     const startedAt = Date.now();
     let blockedByTrustPrompt = false;
     let promptDismissed = false;
+    const resolveTarget = createPinnedWorkerPaneTargetResolverSync(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId);
     const sendRobustEnter = () => {
-        const target = paneTarget(sessionName, workerIndex, workerPaneId);
         // Trust + follow-up splash can require two submits in Codex TUI.
         // Use C-m (carriage return) for raw-mode compatibility.
-        runTmux(['send-keys', '-t', target, 'C-m']);
+        const firstTarget = resolveTarget();
+        if (!firstTarget)
+            return;
+        runTmux(['send-keys', '-t', firstTarget, 'C-m']);
         sleepFractionalSeconds(0.12);
-        runTmux(['send-keys', '-t', target, 'C-m']);
+        const secondTarget = resolveTarget();
+        if (!secondTarget)
+            return;
+        runTmux(['send-keys', '-t', secondTarget, 'C-m']);
     };
     const check = () => {
-        const target = paneTarget(sessionName, workerIndex, workerPaneId);
+        const target = resolveTarget();
+        if (!target)
+            return false;
         const result = runTmux(sharedBuildVisibleCapturePaneArgv(target));
         if (!result.ok)
             return false;
-        if (dismissClaudeBypassPermissionsPromptIfPresent(target, result.stdout)) {
+        if (dismissClaudeBypassPermissionsPromptIfPresent(resolveTarget, result.stdout)) {
             promptDismissed = true;
             return false;
         }
@@ -1757,7 +2750,10 @@ export function waitForWorkerReady(sessionName, workerIndex, timeoutMs = 30_000,
         // scrollback for the prompt/helper text that may have slipped below the fold.
         if (!sharedPaneShowsCodexViewport(result.stdout))
             return false;
-        const scrollbackResult = runTmux(sharedBuildCapturePaneArgv(target, 80));
+        const scrollbackTarget = resolveTarget();
+        if (!scrollbackTarget)
+            return false;
+        const scrollbackResult = runTmux(sharedBuildCapturePaneArgv(scrollbackTarget, 80));
         if (!scrollbackResult.ok)
             return false;
         return paneLooksReady(scrollbackResult.stdout);
@@ -1785,26 +2781,41 @@ export function waitForWorkerReady(sessionName, workerIndex, timeoutMs = 30_000,
 // Async twin of waitForWorkerReady for team startup fan-out. Keep the readiness
 // semantics mirrored with the synchronous helper above, but yield between polls
 // so one slow worker pane cannot block later workers' startup attempts.
-export async function waitForWorkerReadyAsync(sessionName, workerIndex, timeoutMs = 30_000, workerPaneId) {
+export async function waitForWorkerReadyDetailedAsync(sessionName, workerIndex, timeoutMs = 30_000, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId, incompatibility) {
     const initialBackoffMs = 150;
     const maxBackoffMs = 8000;
     const startedAt = Date.now();
     let blockedByTrustPrompt = false;
     let promptDismissed = false;
+    let startupIncompatible = false;
+    const resolveTarget = createPinnedWorkerPaneTargetResolver(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId);
     const sendRobustEnter = async () => {
-        const target = paneTarget(sessionName, workerIndex, workerPaneId);
         // Trust + follow-up splash can require two submits in Codex TUI.
         // Use C-m (carriage return) for raw-mode compatibility.
-        await runTmuxAsync(['send-keys', '-t', target, 'C-m']);
+        const firstTarget = await resolveTarget();
+        if (!firstTarget)
+            return;
+        await runTmuxAsync(['send-keys', '-t', firstTarget, 'C-m']);
         await sleep(120);
-        await runTmuxAsync(['send-keys', '-t', target, 'C-m']);
+        const secondTarget = await resolveTarget();
+        if (!secondTarget)
+            return;
+        await runTmuxAsync(['send-keys', '-t', secondTarget, 'C-m']);
     };
     const check = async () => {
-        const target = paneTarget(sessionName, workerIndex, workerPaneId);
+        const target = await resolveTarget();
+        if (!target)
+            return false;
         const result = await runTmuxAsync(sharedBuildVisibleCapturePaneArgv(target));
         if (!result.ok)
             return false;
-        if (dismissClaudeBypassPermissionsPromptIfPresent(target, result.stdout)) {
+        const incompatibleReason = classifyCodexBypassMdmIncompatibility(result.stdout, incompatibility?.workerCli, incompatibility?.finalArgs);
+        if (incompatibleReason) {
+            startupIncompatible = true;
+            incompatibility?.onIncompatible(incompatibleReason);
+            return false;
+        }
+        if (await dismissClaudeBypassPermissionsPromptIfPresentAsync(resolveTarget, result.stdout)) {
             promptDismissed = true;
             return false;
         }
@@ -1829,7 +2840,10 @@ export async function waitForWorkerReadyAsync(sessionName, workerIndex, timeoutM
         // scrollback for the prompt/helper text that may have slipped below the fold.
         if (!sharedPaneShowsCodexViewport(result.stdout))
             return false;
-        const scrollbackResult = await runTmuxAsync(sharedBuildCapturePaneArgv(target, 80));
+        const scrollbackTarget = await resolveTarget();
+        if (!scrollbackTarget)
+            return false;
+        const scrollbackResult = await runTmuxAsync(sharedBuildCapturePaneArgv(scrollbackTarget, 80));
         if (!scrollbackResult.ok)
             return false;
         return paneLooksReady(scrollbackResult.stdout);
@@ -1838,6 +2852,8 @@ export async function waitForWorkerReadyAsync(sessionName, workerIndex, timeoutM
     while (Date.now() - startedAt < timeoutMs) {
         if (await check())
             return true;
+        if (startupIncompatible)
+            return false;
         if (blockedByTrustPrompt)
             return false;
         // After dismissing a trust prompt, reset backoff so we re-check quickly
@@ -1854,26 +2870,38 @@ export async function waitForWorkerReadyAsync(sessionName, workerIndex, timeoutM
     }
     return false;
 }
+export async function waitForWorkerReadyAsync(sessionName, workerIndex, timeoutMs = 30_000, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId) {
+    return waitForWorkerReadyDetailedAsync(sessionName, workerIndex, timeoutMs, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId);
+}
 /**
  * Detect and auto-dismiss a Codex "Trust this directory?" prompt in a worker pane.
  * Returns true if a trust prompt was found and dismissed, false otherwise.
  * Opt-out: set OMX_TEAM_AUTO_TRUST=0 to disable auto-dismissal.
  */
-export function dismissTrustPromptIfPresent(sessionName, workerIndex, workerPaneId) {
+export function dismissTrustPromptIfPresent(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId) {
     if (process.env.OMX_TEAM_AUTO_TRUST === '0')
         return false;
     if (!isTmuxAvailable())
         return false;
-    const target = paneTarget(sessionName, workerIndex, workerPaneId);
-    const result = runTmux(sharedBuildVisibleCapturePaneArgv(target));
+    const resolveTarget = createPinnedWorkerPaneTargetResolverSync(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId);
+    const captureTarget = resolveTarget();
+    if (!captureTarget)
+        return false;
+    const result = runTmux(sharedBuildVisibleCapturePaneArgv(captureTarget));
     if (!result.ok)
         return false;
     if (!paneHasTrustPrompt(result.stdout))
         return false;
     // Trust prompt detected; send C-m twice to dismiss (trust + follow-up splash)
-    runTmux(['send-keys', '-t', target, 'C-m']);
+    const firstTarget = resolveTarget();
+    if (!firstTarget)
+        return false;
+    runTmux(['send-keys', '-t', firstTarget, 'C-m']);
     sleepFractionalSeconds(0.12);
-    runTmux(['send-keys', '-t', target, 'C-m']);
+    const secondTarget = resolveTarget();
+    if (!secondTarget)
+        return false;
+    runTmux(['send-keys', '-t', secondTarget, 'C-m']);
     return true;
 }
 export const normalizeTmuxCapture = sharedNormalizeTmuxCapture;
@@ -1904,49 +2932,49 @@ export function sendToWorkerStdin(stdin, text) {
 // Send SHORT text (<200 chars) to worker via tmux send-keys
 // Validates: text < 200 chars, no injection marker
 // Throws on violation
-export async function sendToWorker(sessionName, workerIndex, text, workerPaneId, workerCli) {
+export async function sendToWorker(sessionName, workerIndex, text, workerPaneId, workerCli, expectedPanePid, expectedTeamOwnerId, hudPaneId) {
     assertWorkerTriggerText(text);
-    const target = paneTarget(sessionName, workerIndex, workerPaneId);
+    const resolveTarget = createPinnedWorkerPaneTargetResolver(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId);
     const strategy = resolveSendStrategyFromEnv();
     const resolvedWorkerCli = resolveWorkerCliForSend(workerIndex, workerCli);
     // Guard: if the trust prompt is still present, advance it first so our trigger text
     // doesn't get typed into the trust screen and ignored.
-    const capturedStr = await capturePaneAsync(target);
+    const capturedStr = await capturePaneAsync(resolveTarget);
     const paneBusy = paneHasActiveTask(capturedStr);
-    if (dismissClaudeBypassPermissionsPromptIfPresent(target, capturedStr)) {
+    if (await dismissClaudeBypassPermissionsPromptIfPresentAsync(resolveTarget, capturedStr)) {
         await sleep(200);
     }
     if (paneHasTrustPrompt(capturedStr)) {
-        await sendKeyAsync(target, 'C-m');
+        await sendKeyAsync(resolveTarget, 'C-m');
         await sleep(120);
-        await sendKeyAsync(target, 'C-m');
+        await sendKeyAsync(resolveTarget, 'C-m');
         await sleep(200);
     }
-    sendLiteralTextOrThrow(target, text);
+    await sendLiteralTextOrThrow(resolveTarget, text);
     // Allow the input buffer to settle before sending C-m
     await sleep(150);
     const allowAutoInterruptRetry = process.env[OMX_TEAM_AUTO_INTERRUPT_RETRY_ENV] !== '0';
     const submitPlan = buildWorkerSubmitPlan(strategy, resolvedWorkerCli, paneBusy, allowAutoInterruptRetry);
     if (submitPlan.shouldInterrupt) {
         // Explicit interrupt mode: abort current turn first, then submit the new command.
-        await sendKeyAsync(target, 'C-c');
+        await sendKeyAsync(resolveTarget, 'C-c');
         await sleep(100);
     }
     // Submit deterministically using CLI-specific plan:
     // - Codex: queue-first Tab+C-m when configured/busy, then double C-m rounds.
     // - Claude: direct C-m rounds only (never queue-first Tab).
-    if (await attemptSubmitRounds(target, text, submitPlan.rounds, submitPlan.queueFirstRound, submitPlan.submitKeyPressesPerRound))
+    if (await attemptSubmitRounds(resolveTarget, text, submitPlan.rounds, submitPlan.queueFirstRound, submitPlan.submitKeyPressesPerRound))
         return;
     // Adaptive escalation for "likely unsent trigger text at ready prompt" cases:
     // clear line, re-send trigger, then re-submit with deterministic C-m rounds.
-    const latestCapture = await capturePaneAsync(target);
+    const latestCapture = await capturePaneAsync(resolveTarget);
     if (shouldAttemptAdaptiveRetry(strategy, paneBusy, submitPlan.allowAdaptiveRetry, latestCapture || null, text)) {
         // Keep this branch non-interrupting to avoid canceling active turns on false positives.
-        await sendKeyAsync(target, 'C-u');
+        await sendKeyAsync(resolveTarget, 'C-u');
         await sleep(80);
-        sendLiteralTextOrThrow(target, text);
+        await sendLiteralTextOrThrow(resolveTarget, text);
         await sleep(120);
-        if (await attemptSubmitRounds(target, text, 4, false, submitPlan.submitKeyPressesPerRound))
+        if (await attemptSubmitRounds(resolveTarget, text, 4, false, submitPlan.submitKeyPressesPerRound))
             return;
     }
     // Fail-open by default: Codex may keep the last submitted line visible even after executing it.
@@ -1956,15 +2984,15 @@ export async function sendToWorker(sessionName, workerIndex, text, workerPaneId,
         throw new Error('sendToWorker: submit_failed (trigger text still visible after retries)');
     }
     // One last best-effort double C-m nudge, then verify.
-    await sendKeyAsync(target, 'C-m');
+    await sendKeyAsync(resolveTarget, 'C-m');
     await sleep(120);
-    await sendKeyAsync(target, 'C-m');
+    await sendKeyAsync(resolveTarget, 'C-m');
     // Post-submit verification: wait briefly and confirm the worker consumed the
     // trigger (draft disappeared or active-task indicator appeared). Fixes #391.
     await sleep(300);
     const [verifyCapture, verifyVisibleCapture] = await Promise.all([
-        capturePaneAsync(target),
-        captureVisiblePaneAsync(target),
+        capturePaneAsync(resolveTarget),
+        captureVisiblePaneAsync(resolveTarget),
     ]);
     if (verifyCapture) {
         if (paneHasActiveTask(verifyCapture))
@@ -1974,14 +3002,14 @@ export async function sendToWorker(sessionName, workerIndex, text, workerPaneId,
             return;
         }
         // Draft still visible and no active task — one more C-m attempt.
-        await sendKeyAsync(target, 'C-m');
+        await sendKeyAsync(resolveTarget, 'C-m');
         await sleep(150);
-        await sendKeyAsync(target, 'C-m');
-        const finalVisibleCapture = await captureVisiblePaneAsync(target);
+        await sendKeyAsync(resolveTarget, 'C-m');
+        const finalVisibleCapture = await captureVisiblePaneAsync(resolveTarget);
         if (paneHasQueuedCodexSubmission(finalVisibleCapture)) {
             throw new Error('sendToWorker: submit_queued_after_tool_call');
         }
-        const finalCapture = await capturePaneAsync(target);
+        const finalCapture = await capturePaneAsync(resolveTarget);
         if (normalizeWorkerTriggerForDraftMatch(finalCapture).includes(normalizeWorkerTriggerForDraftMatch(text))
             && !paneHasActiveTask(finalCapture)
             && paneLooksReady(finalCapture)) {
@@ -2000,8 +3028,12 @@ export function notifyLeaderStatus(sessionName, message) {
     return result.ok;
 }
 // Get PID of the shell process in a worker's tmux pane
-export function getWorkerPanePid(sessionName, workerIndex, workerPaneId) {
-    const result = runTmux(['list-panes', '-t', paneTarget(sessionName, workerIndex, workerPaneId), '-F', '#{pane_pid}']);
+export function getWorkerPanePid(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId) {
+    if (hasExplicitWorkerPaneId(workerPaneId)) {
+        const proof = requireExactWorkerPaneLivenessIdentity(workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId);
+        return proof.status === 'live' ? proof.pid : null;
+    }
+    const result = runTmux(['list-panes', '-t', paneTarget(sessionName, workerIndex), '-F', '#{pane_pid}']);
     if (!result.ok)
         return null;
     const firstLine = result.stdout.split('\n')[0]?.trim();
@@ -2013,15 +3045,25 @@ export function getWorkerPanePid(sessionName, workerIndex, workerPaneId) {
     return pid;
 }
 // Check if worker's tmux pane has a running process
-export function isWorkerAlive(sessionName, workerIndex, workerPaneId) {
-    if (workerPaneId?.startsWith('%')) {
-        const paneStatus = readPaneLivenessById(workerPaneId);
-        if (paneStatus !== null)
-            return paneStatus;
+export function isWorkerAlive(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId) {
+    if (hasExplicitWorkerPaneId(workerPaneId)) {
+        if (hudPaneId?.trim() && workerPaneId === hudPaneId.trim()) {
+            throw new Error(`tmux worker pane is HUD target: ${workerPaneId}`);
+        }
+        const proof = requireExactWorkerPaneLivenessIdentity(workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId);
+        if (proof.status === 'unavailable')
+            return true;
+        if (proof.status === 'gone')
+            return false;
+        if (typeof expectedPanePid !== 'number' || !Number.isSafeInteger(expectedPanePid) || expectedPanePid <= 0)
+            return true;
+        if (typeof expectedTeamOwnerId !== 'string' || expectedTeamOwnerId.trim() === '')
+            return true;
+        return probeProcessLiveness(proof.pid) !== 'gone';
     }
     const result = runTmux([
         'list-panes',
-        '-t', paneTarget(sessionName, workerIndex, workerPaneId),
+        '-t', paneTarget(sessionName, workerIndex),
         '-F',
         '#{pane_dead} #{pane_pid}',
     ]);
@@ -2039,23 +3081,17 @@ export function isWorkerAlive(sessionName, workerIndex, workerPaneId) {
         return false;
     if (!Number.isFinite(pid))
         return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    // Unknown is conservatively live so callers cannot classify a permission or
+    // transient failure as stale cleanup authority.
+    return probeProcessLiveness(pid) !== 'gone';
 }
-export function isWorkerPaneOpen(sessionName, workerIndex, workerPaneId) {
-    if (workerPaneId?.startsWith('%')) {
-        const paneStatus = readPaneLivenessById(workerPaneId);
-        if (paneStatus !== null)
-            return paneStatus;
+export function isWorkerPaneOpen(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId) {
+    if (hasExplicitWorkerPaneId(workerPaneId)) {
+        return createPinnedWorkerPaneTargetResolverSync(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId)() !== null;
     }
     const result = runTmux([
         'list-panes',
-        '-t', paneTarget(sessionName, workerIndex, workerPaneId),
+        '-t', paneTarget(sessionName, workerIndex),
         '-F',
         '#{pane_dead}',
     ]);
@@ -2068,28 +3104,69 @@ export function isWorkerPaneOpen(sessionName, workerIndex, workerPaneId) {
 }
 // Kill a specific worker: send C-c, then C-d, then kill-pane if still alive.
 // leaderPaneId: when provided, the kill is skipped entirely if workerPaneId matches it.
-export async function killWorker(sessionName, workerIndex, workerPaneId, leaderPaneId) {
+export async function killWorker(sessionName, workerIndex, workerPaneId, leaderPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId) {
     // Guard: never kill the leader's own pane.
     if (leaderPaneId && workerPaneId === leaderPaneId)
         return;
-    await runTmuxAsync(['send-keys', '-t', paneTarget(sessionName, workerIndex, workerPaneId), 'C-c']);
+    const resolveTarget = createPinnedWorkerPaneTargetResolver(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId);
+    const initialTarget = await resolveTarget();
+    if (!initialTarget)
+        return;
+    if (await isWorkerAliveAsync(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId, resolveTarget) !== 'alive')
+        return;
+    await runTmuxAsync(['send-keys', '-t', initialTarget, 'C-c']);
     await sleep(1000);
-    if (await isWorkerAliveAsync(sessionName, workerIndex, workerPaneId)) {
-        await runTmuxAsync(['send-keys', '-t', paneTarget(sessionName, workerIndex, workerPaneId), 'C-d']);
-        await sleep(1000);
-    }
-    if (await isWorkerAliveAsync(sessionName, workerIndex, workerPaneId)) {
-        await runTmuxAsync(['kill-pane', '-t', paneTarget(sessionName, workerIndex, workerPaneId)]);
+    if (await isWorkerAliveAsync(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId, resolveTarget) === 'alive') {
+        const exitTarget = await resolveTarget();
+        if (exitTarget) {
+            await runTmuxAsync(['send-keys', '-t', exitTarget, 'C-d']);
+            await sleep(1000);
+        }
     }
-}
-// leaderPaneId: when provided, the kill is skipped if workerPaneId matches it.
-export function killWorkerByPaneId(workerPaneId, leaderPaneId) {
-    if (!workerPaneId.startsWith('%'))
+    if (await isWorkerAliveAsync(sessionName, workerIndex, workerPaneId, expectedPanePid, expectedTeamOwnerId, hudPaneId, resolveTarget) === 'alive') {
+        const killTarget = await resolveTarget();
+        if (!killTarget)
+            return;
+        const killed = await runTmuxAsync(['kill-pane', '-t', killTarget]);
+        if (!killed.ok)
+            throw new Error(`failed to kill tmux pane ${killTarget}: ${killed.stderr}`);
+        const absence = await readExactPaneProof(killTarget);
+        if (absence.status === 'unavailable')
+            throw new ExactPaneProofUnavailableError(absence);
+        if (absence.status !== 'gone')
+            throw new Error(`tmux pane remains live after kill: ${killTarget}`);
+    }
+}
+// Explicit pane targets require frozen PID, canonical Team owner, and HUD
+// exclusion. A successful kill is only accepted after a fresh absence proof.
+export function killWorkerByPaneId(workerPaneId, expectedPanePid, leaderPaneId, expectedTeamOwnerId, hudPaneId) {
+    const expectedOwner = typeof expectedTeamOwnerId === 'string' ? expectedTeamOwnerId.trim() : '';
+    if (!hasExplicitWorkerPaneId(workerPaneId)
+        || typeof expectedPanePid !== 'number'
+        || !Number.isSafeInteger(expectedPanePid)
+        || expectedPanePid <= 0
+        || !expectedOwner
+        || workerPaneId === hudPaneId)
         return;
-    // Guard: never kill the leader's own pane.
     if (leaderPaneId && workerPaneId === leaderPaneId)
         return;
-    runTmux(['kill-pane', '-t', workerPaneId]);
+    const proof = readExactPaneProofSync(workerPaneId);
+    if (proof.status !== 'live' || proof.pid !== expectedPanePid)
+        return;
+    const owner = readPaneTeamOwnerTagResult(proof.paneId);
+    if (owner.status !== 'value' || owner.value !== expectedOwner)
+        return;
+    const finalProof = readExactPaneProofSync(proof.paneId);
+    if (finalProof.status !== 'live' || finalProof.pid !== expectedPanePid)
+        return;
+    const result = runTmux(['kill-pane', '-t', finalProof.paneId]);
+    if (!result.ok)
+        throw new Error(`failed to kill tmux pane ${finalProof.paneId}: ${result.stderr}`);
+    const absence = readExactPaneProofSync(finalProof.paneId);
+    if (absence.status === 'unavailable')
+        throw new ExactPaneProofUnavailableError(absence);
+    if (absence.status !== 'gone')
+        throw new Error(`tmux pane remains live after kill: ${finalProof.paneId}`);
 }
 export function paneHasOmxInstanceTag(paneId, instanceId) {
     const normalizedPaneId = normalizePaneTarget(paneId);
@@ -2140,13 +3217,34 @@ export function readPaneTeamOwnerTagResult(paneId) {
         return { status: 'missing' };
     return { status: 'error', error: stderr || `tmux show-option exited ${result.status ?? 'unknown'}` };
 }
-export async function killWorkerByPaneIdAsync(workerPaneId, leaderPaneId) {
-    if (!workerPaneId.startsWith('%'))
+export async function killWorkerByPaneIdAsync(workerPaneId, expectedPanePid, leaderPaneId, expectedTeamOwnerId, hudPaneId) {
+    const expectedOwner = typeof expectedTeamOwnerId === 'string' ? expectedTeamOwnerId.trim() : '';
+    if (!hasExplicitWorkerPaneId(workerPaneId)
+        || typeof expectedPanePid !== 'number'
+        || !Number.isSafeInteger(expectedPanePid)
+        || expectedPanePid <= 0
+        || !expectedOwner
+        || workerPaneId === hudPaneId)
         return;
-    // Guard: never kill the leader's own pane.
     if (leaderPaneId && workerPaneId === leaderPaneId)
         return;
-    await runTmuxAsync(['kill-pane', '-t', workerPaneId]);
+    const proof = await readExactPaneProof(workerPaneId);
+    if (proof.status !== 'live' || proof.pid !== expectedPanePid)
+        return;
+    const owner = readPaneTeamOwnerTagResult(proof.paneId);
+    if (owner.status !== 'value' || owner.value !== expectedOwner)
+        return;
+    const finalProof = await readExactPaneProof(proof.paneId);
+    if (finalProof.status !== 'live' || finalProof.pid !== expectedPanePid)
+        return;
+    const result = await runTmuxAsync(['kill-pane', '-t', finalProof.paneId]);
+    if (!result.ok)
+        throw new Error(`failed to kill tmux pane ${finalProof.paneId}: ${result.stderr}`);
+    const absence = await readExactPaneProof(finalProof.paneId);
+    if (absence.status === 'unavailable')
+        throw new ExactPaneProofUnavailableError(absence);
+    if (absence.status !== 'gone')
+        throw new Error(`tmux pane remains live after kill: ${finalProof.paneId}`);
 }
 function normalizePaneTarget(value) {
     if (typeof value !== 'string')
@@ -2184,7 +3282,10 @@ function normalizePaneTargets(paneIds, options = {}) {
     return { killablePaneIds, excluded };
 }
 export function resolveSharedSessionShutdownTopology(sessionName, preferredLeaderPaneId, teamName) {
-    const panes = listPanes(sessionName);
+    const paneList = listPanesResult(sessionName);
+    if (paneList.error !== null)
+        return { status: 'unavailable', detail: paneList.error };
+    const panes = paneList.panes;
     const livePaneIds = panes
         .map((pane) => normalizePaneTarget(pane.paneId))
         .filter((paneId) => Boolean(paneId));
@@ -2192,6 +3293,7 @@ export function resolveSharedSessionShutdownTopology(sessionName, preferredLeade
     if (panes.length === 0) {
         return {
             livePaneIds,
+            status: 'available',
             teamWorkerPaneIds: [],
             leaderPaneId: fallbackLeaderPaneId,
             hudPaneIds: [],
@@ -2222,6 +3324,7 @@ export function resolveSharedSessionShutdownTopology(sessionName, preferredLeade
         : [];
     return {
         livePaneIds,
+        status: 'available',
         teamWorkerPaneIds: normalizedTeamWorkerPaneIds,
         leaderPaneId: resolvedLeaderPaneId,
         hudPaneIds,
@@ -2336,7 +3439,8 @@ function escapeRegExp(value) {
 }
 /**
  * Shared pane-id-direct teardown primitive for worker pane cleanup.
- * Must remain liveness-agnostic: do not gate on isWorkerAlive/killWorker.
+ * A fresh exact global proof is required before each kill; proven-gone panes
+ * are teardown-compatible while unavailable proofs remain fail-closed.
  */
 export async function teardownWorkerPanes(paneIds, options = {}) {
     const { killablePaneIds, excluded } = normalizePaneTargets(paneIds, options);
@@ -2347,45 +3451,247 @@ export async function teardownWorkerPanes(paneIds, options = {}) {
     const summary = {
         attemptedPaneIds: killablePaneIds,
         excluded,
+        provenGonePaneIds: [],
+        killedPaneIds: [],
+        proofUnavailable: [],
         kill: {
-            attempted: killablePaneIds.length,
+            attempted: 0,
             succeeded: 0,
             failed: 0,
+            failedPaneIds: [],
         },
     };
     for (const paneId of killablePaneIds) {
-        const result = await runTmuxAsync(['kill-pane', '-t', paneId]);
-        if (result.ok)
+        const proof = await readExactPaneProof(paneId);
+        const expectedPid = options.expectedPanePids?.[paneId];
+        if (proof.status === 'gone') {
+            summary.provenGonePaneIds.push(proof.paneId);
+            continue;
+        }
+        if (proof.status === 'unavailable') {
+            summary.proofUnavailable.push(proof);
+            break;
+        }
+        if (typeof expectedPid !== 'number' || !Number.isSafeInteger(expectedPid) || expectedPid <= 0) {
+            summary.proofUnavailable.push({
+                status: 'unavailable',
+                paneId,
+                reason: 'pane_pid_changed',
+                detail: 'expected positive pane PID is required before teardown kill',
+            });
+            break;
+        }
+        if (proof.pid !== expectedPid) {
+            summary.proofUnavailable.push({
+                status: 'unavailable',
+                paneId,
+                reason: 'pane_pid_changed',
+                detail: `expected ${expectedPid}, got ${proof.pid}`,
+            });
+            break;
+        }
+        if (options.authorizePaneKill && !options.authorizePaneKill(proof.paneId, proof)) {
+            summary.proofUnavailable.push({
+                status: 'unavailable',
+                paneId: proof.paneId,
+                reason: 'pane_pid_changed',
+                detail: 'pane owner authorization changed',
+            });
+            break;
+        }
+        // Owner authorization can read tmux. Re-prove the persisted identity after
+        // it and immediately before kill-pane.
+        const finalProof = await readExactPaneProof(proof.paneId);
+        if (finalProof.status === 'gone') {
+            summary.provenGonePaneIds.push(finalProof.paneId);
+            continue;
+        }
+        if (finalProof.status === 'unavailable') {
+            summary.proofUnavailable.push(finalProof);
+            break;
+        }
+        if (finalProof.pid !== expectedPid) {
+            summary.proofUnavailable.push({
+                status: 'unavailable',
+                paneId: finalProof.paneId,
+                reason: 'pane_pid_changed',
+                detail: `expected ${expectedPid}, got ${finalProof.pid}`,
+            });
+            break;
+        }
+        summary.kill.attempted += 1;
+        const result = await runTmuxAsync(['kill-pane', '-t', finalProof.paneId]);
+        if (!result.ok) {
+            summary.kill.failed += 1;
+            summary.kill.failedPaneIds.push(proof.paneId);
+            await sleep(perPaneGrace);
+            break;
+        }
+        const afterKill = await readExactPaneProof(finalProof.paneId);
+        if (afterKill.status === 'gone') {
             summary.kill.succeeded += 1;
-        else
+            summary.killedPaneIds.push(proof.paneId);
+        }
+        else if (afterKill.status === 'unavailable') {
+            summary.proofUnavailable.push(afterKill);
+            break;
+        }
+        else {
             summary.kill.failed += 1;
+            summary.kill.failedPaneIds.push(proof.paneId);
+            await sleep(perPaneGrace);
+            break;
+        }
         await sleep(perPaneGrace);
     }
     return summary;
 }
-export async function killWorkerPanes(paneIds, leaderPaneId, graceMs = 2000, hudPaneId) {
-    return teardownWorkerPanes(paneIds, { leaderPaneId, hudPaneId: hudPaneId ?? null, graceMs });
-}
-// Kill entire tmux session. Tolerates already-dead sessions.
-export function destroyTeamSession(sessionName) {
-    try {
-        runTmux(['kill-session', '-t', sessionName]);
-    }
-    catch {
-        // tolerate
-    }
+export async function killWorkerPanes(paneIds, leaderPaneId, graceMs = 2000, hudPaneId, expectedPanePids) {
+    return teardownWorkerPanes(paneIds, {
+        leaderPaneId,
+        hudPaneId: hudPaneId ?? null,
+        graceMs,
+        expectedPanePids,
+    });
 }
-// List all tmux sessions matching omx-team-* pattern
-export function listTeamSessions() {
-    const result = runTmux(['list-sessions', '-F', '#{session_name}']);
-    if (!result.ok)
-        return [];
-    return result.stdout
+// Kill an entire detached tmux session only when the caller has already
+// established ownership. Success requires tmux to accept the kill and a fresh
+// session-list proof that the exact base session is absent.
+function parseTeamSessionNames(stdout) {
+    return stdout
         .split('\n')
         .map(line => line.trim())
         .filter(Boolean)
         .map(baseSessionName);
 }
+function isFinalTmuxServerGone(result) {
+    return !result.ok && /^no server running on .+$/i.test(result.stderr);
+}
+/**
+ * Reads pane and session incarnation in one tmux snapshot. This prevents a
+ * same-name replacement from combining a stale session proof with a live pane.
+ */
+export function queryDetachedSessionLeaderBinding(paneId, pid, sessionName, expected) {
+    const result = runTmuxStructured(['list-panes', '-a', '-F', '#{pane_id}\t#{pane_dead}\t#{pane_pid}\t#{session_name}\t#{session_id}\t#{session_created}']);
+    if (!result.ok)
+        return null;
+    const seenPaneIds = new Set();
+    let binding = null;
+    for (const line of result.stdout.split('\n').filter(Boolean)) {
+        const fields = line.split('\t');
+        if (fields.length !== 6)
+            return null;
+        const [currentPaneId, dead, panePid, currentSessionName, sessionId, sessionCreated] = fields;
+        if (!/^%[0-9]+$/.test(currentPaneId) || seenPaneIds.has(currentPaneId) || (dead !== '0' && dead !== '1')
+            || !/^[0-9]+$/.test(panePid) || !Number.isSafeInteger(Number(panePid)) || Number(panePid) <= 0
+            || !currentSessionName || !/^\$[0-9]+$/.test(sessionId) || !/^[0-9]+$/.test(sessionCreated))
+            return null;
+        seenPaneIds.add(currentPaneId);
+        if (currentPaneId !== paneId)
+            continue;
+        if (dead !== '0' || Number(panePid) !== pid || currentSessionName !== sessionName
+            || sessionId !== expected.sessionId || sessionCreated !== expected.sessionCreated)
+            return null;
+        binding = { paneId: currentPaneId, pid: Number(panePid), sessionName: currentSessionName, incarnation: { sessionId, sessionCreated } };
+    }
+    return binding;
+}
+function parseDetachedSessionIncarnation(stdout, sessionName) {
+    const baseName = baseSessionName(sessionName);
+    const matches = [];
+    for (const line of stdout.split('\n').filter(Boolean)) {
+        const fields = line.split('\t');
+        if (fields.length !== 3)
+            return 'malformed';
+        const [name, sessionId, sessionCreated] = fields;
+        if (!name || !sessionId || !sessionCreated || !/^\$[0-9]+$/.test(sessionId) || !/^[0-9]+$/.test(sessionCreated))
+            return 'malformed';
+        if (baseSessionName(name) === baseName)
+            matches.push({ sessionId, sessionCreated });
+    }
+    return matches.length === 0 ? null : matches.length === 1 ? matches[0] : 'malformed';
+}
+/**
+ * Reads stable tmux incarnation evidence. Name-only presence is never effect
+ * authority: malformed or unavailable evidence fails closed, and an expected
+ * incarnation distinguishes an exact survivor from a recycled same-name session.
+ */
+export function queryDetachedTeamSession(sessionName, expected) {
+    const sessions = runTmuxStructured(['list-sessions', '-F', '#{session_name}\t#{session_id}\t#{session_created}']);
+    if (!sessions.ok) {
+        return isFinalTmuxServerGone(sessions)
+            ? { status: 'absent' }
+            : { status: 'unavailable', detail: sessions.stderr };
+    }
+    const incarnation = parseDetachedSessionIncarnation(sessions.stdout, sessionName);
+    if (incarnation === 'malformed')
+        return { status: 'unavailable', detail: 'malformed_session_incarnation' };
+    if (incarnation === null)
+        return { status: 'absent' };
+    if (expected && (incarnation.sessionId !== expected.sessionId || incarnation.sessionCreated !== expected.sessionCreated)) {
+        return { status: 'replacement', incarnation };
+    }
+    return { status: 'exact', incarnation };
+}
+/**
+ * Re-proves every stable authorization component at the destructive sink. The
+ * final tmux command queues an in-server predicate with the kill, so no client
+ * can replace the session or pane between authorization and the effect.
+ */
+function buildDetachedSessionDestroyArgs(expected) {
+    const leaderPaneId = expected.leaderPaneId.trim();
+    const ownerId = expected.ownerId.trim();
+    if (!/^%[0-9]+$/.test(leaderPaneId)
+        || !Number.isSafeInteger(expected.leaderPanePid)
+        || expected.leaderPanePid <= 0
+        || !/^\$[0-9]+$/.test(expected.sessionId)
+        || !/^[0-9]+$/.test(expected.sessionCreated)
+        || !/^[A-Za-z0-9._:@/-]+$/.test(ownerId))
+        return null;
+    const predicate = [
+        '#{==:#{pane_dead},0}',
+        `#{==:#{pane_id},${leaderPaneId}}`,
+        `#{==:#{pane_pid},${expected.leaderPanePid}}`,
+        `#{==:#{${OMX_TEAM_PANE_OWNER_OPTION}},${ownerId}}`,
+        `#{==:#{session_id},${expected.sessionId}}`,
+        `#{==:#{session_created},${expected.sessionCreated}}`,
+    ].reduce((combined, condition) => `#{&&:${combined},${condition}}`);
+    return ['if-shell', '-F', '-t', leaderPaneId, predicate, `kill-session -t ${expected.sessionId}`, 'run-shell "exit 1"'];
+}
+export function requestDetachedTeamSessionDestroy(sessionName, expected) {
+    const incarnation = { sessionId: expected.sessionId, sessionCreated: expected.sessionCreated };
+    if (queryDetachedTeamSession(sessionName, incarnation).status !== 'exact')
+        return false;
+    if (!queryDetachedSessionLeaderBinding(expected.leaderPaneId, expected.leaderPanePid, sessionName, incarnation))
+        return false;
+    const pane = readExactPaneProofSync(expected.leaderPaneId);
+    if (pane.status !== 'live' || pane.pid !== expected.leaderPanePid)
+        return false;
+    const owner = readPaneTeamOwnerTagResult(expected.leaderPaneId);
+    if (owner.status !== 'value' || owner.value !== expected.ownerId)
+        return false;
+    const args = buildDetachedSessionDestroyArgs(expected);
+    return args !== null && runTmux(args).ok;
+}
+export function destroyTeamSession(sessionName) {
+    const result = runTmux(['kill-session', '-t', sessionName]);
+    if (!result.ok)
+        return false;
+    const sessions = runTmux(['list-sessions', '-F', '#{session_name}']);
+    // Killing tmux's final session also terminates its server. Its documented
+    // no-server response is the only post-kill query failure that proves absence.
+    if (!sessions.ok)
+        return isFinalTmuxServerGone(sessions);
+    return !parseTeamSessionNames(sessions.stdout).includes(baseSessionName(sessionName));
+}
+// A failed query is not a successful empty session list. Destructive callers
+// must require the latter before treating a detached session as absent.
+export function listTeamSessions() {
+    const result = runTmux(['list-sessions', '-F', '#{session_name}']);
+    if (!result.ok)
+        return null;
+    return parseTeamSessionNames(result.stdout);
+}
 /**
  * Notify the leader through durable mailbox state only.
  *