oh-my-codex 0.11.12 → 0.11.13

package/src/scripts/notify-hook/team-dispatch.ts

@@ -10,7 +10,7 @@ import { resolveBridgeStateDir, resolveRuntimeBinaryPath } from '../../runtime/b
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { runProcess } from './process-runner.js';
-import { resolvePaneTarget } from './tmux-injection.js';
+import { resolvePaneTarget, resolveSessionToPane } from './tmux-injection.js';
 import { evaluatePaneInjectionReadiness, sendPaneInput } from './team-tmux-guard.js';
 import {
   buildCapturePaneArgv,
@@ -70,7 +70,7 @@ async function readBridgeDispatchRequests(stateDir, teamName) {
         transport_preference: safeString(metadata.transport_preference).trim() || 'hook_preferred_with_fallback',
         fallback_allowed: typeof metadata.fallback_allowed === 'boolean' ? metadata.fallback_allowed : true,
         status: safeString(record.status).trim() || 'pending',
-        attempt_count: 0,
+        attempt_count: Number.isFinite(metadata.attempt_count) ? Number(metadata.attempt_count) : 0,
         created_at: safeString(record.created_at).trim() || new Date().toISOString(),
         updated_at:
           safeString(record.delivered_at).trim()
@@ -182,8 +182,7 @@ function parseTriggerCooldownEntry(entry) {
   };
 }
 
-async function withDispatchLock(teamDirPath, fn) {
-  const lockDir = join(teamDirPath, 'dispatch', '.lock');
+async function withLockDirectory(lockDir, timeoutError, fn) {
   const ownerPath = join(lockDir, 'owner');
   const ownerToken = `${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
   const deadline = Date.now() + 5_000;
@@ -210,7 +209,7 @@ async function withDispatchLock(teamDirPath, fn) {
       } catch {
         // best effort
       }
-      if (Date.now() > deadline) throw new Error(`Timed out acquiring dispatch lock for ${teamDirPath}`);
+      if (Date.now() > deadline) throw new Error(timeoutError);
       await new Promise((resolveDelay) => setTimeout(resolveDelay, 25));
     }
   }
@@ -229,57 +228,63 @@ async function withDispatchLock(teamDirPath, fn) {
   }
 }
 
-async function withMailboxLock(teamDirPath, workerName, fn) {
-  const lockDir = join(teamDirPath, 'mailbox', `.lock-${workerName}`);
-  const ownerPath = join(lockDir, 'owner');
-  const ownerToken = `${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
-  const deadline = Date.now() + 5_000;
-  await mkdir(dirname(lockDir), { recursive: true });
-
-  while (true) {
-    try {
-      await mkdir(lockDir, { recursive: false });
-      try {
-        await writeFile(ownerPath, ownerToken, 'utf8');
-      } catch (error) {
-        await rm(lockDir, { recursive: true, force: true });
-        throw error;
-      }
-      break;
-    } catch (error) {
-      if (error?.code !== 'EEXIST') throw error;
-      try {
-        const info = await stat(lockDir);
-        if (Date.now() - info.mtimeMs > DISPATCH_LOCK_STALE_MS) {
-          await rm(lockDir, { recursive: true, force: true });
-          continue;
-        }
-      } catch {
-        // best effort
-      }
-      if (Date.now() > deadline) throw new Error(`Timed out acquiring mailbox lock for ${teamDirPath}/${workerName}`);
-      await new Promise((resolveDelay) => setTimeout(resolveDelay, 25));
-    }
-  }
+async function withDispatchLock(teamDirPath, fn) {
+  return await withLockDirectory(
+    join(teamDirPath, 'dispatch', '.lock'),
+    `Timed out acquiring dispatch lock for ${teamDirPath}`,
+    fn,
+  );
+}
 
-  try {
-    return await fn();
-  } finally {
-    try {
-      const currentOwner = await readFile(ownerPath, 'utf8');
-      if (currentOwner.trim() === ownerToken) {
-        await rm(lockDir, { recursive: true, force: true });
-      }
-    } catch {
-      // best effort
-    }
-  }
+async function withMailboxLock(teamDirPath, workerName, fn) {
+  return await withLockDirectory(
+    join(teamDirPath, 'mailbox', `.lock-${workerName}`),
+    `Timed out acquiring mailbox lock for ${teamDirPath}/${workerName}`,
+    fn,
+  );
 }
 
 function resolveLeaderPaneId(config) {
   return safeString(config?.leader_pane_id).trim();
 }
 
+function serializeDispatchRequestRecord(request) {
+  return {
+    request_id: safeString(request.request_id).trim(),
+    target: safeString(request.to_worker).trim(),
+    status: safeString(request.status).trim() || 'pending',
+    created_at: safeString(request.created_at).trim() || new Date().toISOString(),
+    notified_at: safeString(request.notified_at).trim() || null,
+    delivered_at: safeString(request.delivered_at).trim() || null,
+    failed_at: safeString(request.failed_at).trim() || null,
+    reason: safeString(request.last_reason).trim() || null,
+    metadata: {
+      kind: safeString(request.kind).trim() || 'inbox',
+      team_name: safeString(request.team_name).trim(),
+      worker_index: Number.isFinite(request.worker_index) ? Number(request.worker_index) : undefined,
+      pane_id: safeString(request.pane_id).trim() || undefined,
+      trigger_message: safeString(request.trigger_message).trim(),
+      message_id: safeString(request.message_id).trim() || undefined,
+      inbox_correlation_key: safeString(request.inbox_correlation_key).trim() || undefined,
+      transport_preference: safeString(request.transport_preference).trim() || 'hook_preferred_with_fallback',
+      fallback_allowed: typeof request.fallback_allowed === 'boolean' ? request.fallback_allowed : true,
+      attempt_count: Number.isFinite(request.attempt_count) ? Number(request.attempt_count) : 0,
+    },
+  };
+}
+
+async function writeBridgeDispatchCompat(stateDir, teamName, requests) {
+  const compatPath = join(stateDir, 'dispatch.json');
+  const current = await readJson(compatPath, { records: [] });
+  const existing = Array.isArray(current?.records) ? current.records : [];
+  const otherTeams = existing.filter((record) => {
+    const metadata = record?.metadata && typeof record.metadata === 'object' ? record.metadata : {};
+    return safeString(metadata.team_name).trim() !== teamName;
+  });
+  const records = [...otherTeams, ...requests.map(serializeDispatchRequestRecord)];
+  await writeJsonAtomic(compatPath, { records });
+}
+
 
 function defaultInjectTarget(request, config) {
   if (request.to_worker === 'leader-fixed') {
@@ -367,7 +372,15 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
   if (!target) {
     return { ok: false, reason: 'missing_tmux_target' };
   }
-  const resolution = await resolvePaneTarget(target, '', cwd, '');
+  let resolution;
+  if (target.type === 'session') {
+    const paneId = await resolveSessionToPane(target.value).catch(() => null);
+    resolution = paneId
+      ? { paneTarget: paneId, reason: 'session_target_resolved' }
+      : { paneTarget: null, reason: 'target_not_found' };
+  } else {
+    resolution = await resolvePaneTarget(target, '', '', '', {});
+  }
   if (!resolution.paneTarget) {
     return { ok: false, reason: `target_resolution_failed:${resolution.reason}` };
   }
@@ -676,9 +689,11 @@ export async function drainPendingTeamDispatch({
           request.notified_at = nowIso;
           request.last_reason = result.reason;
           runtimeExec({ command: 'MarkNotified', request_id: request.request_id, channel: 'tmux' }, stateDir);
-          if (usingLegacyRequests && request.kind === 'mailbox' && request.message_id) {
+          if (request.kind === 'mailbox' && request.message_id) {
             runtimeExec({ command: 'MarkMailboxNotified', message_id: request.message_id }, stateDir);
-            await updateMailboxNotified(stateDir, teamName, request.to_worker, request.message_id).catch(() => {});
+            if (usingLegacyRequests) {
+              await updateMailboxNotified(stateDir, teamName, request.to_worker, request.message_id).catch(() => {});
+            }
           }
           processed += 1;
           mutated = true;
@@ -725,8 +740,9 @@ export async function drainPendingTeamDispatch({
         await writeJsonAtomic(issueCooldownStatePath(teamDirPath), issueCooldownState);
         triggerCooldownState.by_trigger = triggerCooldownByKey;
         await writeJsonAtomic(triggerCooldownStatePath(teamDirPath), triggerCooldownState);
-        if (usingLegacyRequests) {
-          await writeJsonAtomic(requestsPath, requests);
+        await writeJsonAtomic(requestsPath, requests);
+        if (!usingLegacyRequests) {
+          await writeBridgeDispatchCompat(stateDir, teamName, requests);
         }
       }
     });

package/src/scripts/notify-hook/team-leader-nudge.ts

@@ -510,7 +510,13 @@ async function emitLeaderNudgeDeferredEvent(cwd, teamName, reason, nowIso, { tmu
   }
 }
 
-export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputedLeaderStale }) {
+export async function maybeNudgeTeamLeader({
+  cwd,
+  stateDir,
+  logsDir,
+  preComputedLeaderStale,
+  allowFreshMailboxNudges = true,
+}) {
   const intervalMs = resolveLeaderNudgeIntervalMs();
   const idleCooldownMs = resolveLeaderAllIdleNudgeCooldownMs();
   const fallbackProgressStallThresholdMs = resolveFallbackProgressStallThresholdMs();
@@ -683,7 +689,8 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
     const stalledTeamNudge = teamProgressStalled && (dueByTime || !previousStalledTeamNudge);
     const staleFollowupDue = stalePanesNudge && dueByTime;
 
-    if (!shouldSendAllIdleNudge && !hasNewMessage && !stalledTeamNudge && !staleFollowupDue) continue;
+    const hasActionableNewMessage = hasNewMessage && (allowFreshMailboxNudges || leaderStale);
+    if (!shouldSendAllIdleNudge && !hasActionableNewMessage && !stalledTeamNudge && !staleFollowupDue) continue;
 
     let nudgeReason = '';
     let text = '';
@@ -717,7 +724,7 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
         `Team ${teamName}: ${stallPrefix}no progress ${formatDurationMs(stalledForMs)}. `
         + `${leaderActionGuidance} `
         + `(p:${pending} ip:${in_progress} b:${blocked}${missingSignals})`;
-    } else if (stalePanesNudge && hasNewMessage) {
+    } else if (stalePanesNudge && hasActionableNewMessage) {
       nudgeReason = 'stale_leader_with_messages';
       text =
         `Team ${teamName}: leader stale, ${paneStatus.paneCount} pane(s) active, ${messages.length} msg(s) pending. `
@@ -727,7 +734,7 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
       text =
         `Team ${teamName}: leader stale, ${paneStatus.paneCount} worker pane(s) still active. `
         + leaderActionGuidance;
-    } else if (hasNewMessage) {
+    } else if (hasActionableNewMessage) {
       nudgeReason = 'new_mailbox_message';
       text = `Team ${teamName}: ${messages.length} msg(s) for leader. ${buildMailboxCheckReminder(teamName)}`;
     } else {
@@ -763,7 +770,14 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
       continue;
     }
 
-    const paneGuard = await evaluatePaneInjectionReadiness(tmuxTarget, { skipIfScrolling: true });
+    const paneGuard = await evaluatePaneInjectionReadiness(tmuxTarget, {
+      skipIfScrolling: true,
+      // Leader nudges should still queue into a live Codex pane even while the
+      // agent is busy; shell/copy-mode guards stay enforced.
+      requireRunningAgent: true,
+      requireReady: false,
+      requireIdle: false,
+    });
     if (!paneGuard.ok) {
       const deferredReason = paneGuard.reason === 'pane_running_shell'
         ? LEADER_PANE_SHELL_NO_INJECTION_REASON

package/src/scripts/notify-hook/team-tmux-guard.ts

@@ -8,7 +8,6 @@ import {
   isPaneRunningShell,
   paneHasActiveTask,
   paneLooksReady,
-  resolveCodexPane,
 } from '../tmux-hook-engine.js';
 
 export function mapPaneInjectionReadinessReason(reason: any): any {
@@ -33,25 +32,6 @@ export async function evaluatePaneInjectionReadiness(paneTarget: any, {
       paneCapture: '',
     };
   }
-
-  // Canonical bypass: if resolveCodexPane confirms this is a codex pane
-  // (via pane_start_command), skip all readiness guards. The pane IS running
-  // codex even though tmux may report cmd=sh (shell wrapper).
-  try {
-    if (resolveCodexPane() === target) {
-      return {
-        ok: true,
-        sent: false,
-        reason: 'ok',
-        paneTarget: target,
-        paneCurrentCommand: 'codex',
-        paneCapture: '',
-      };
-    }
-  } catch {
-    // Non-fatal: fall through to normal readiness checks
-  }
-
   if (skipIfScrolling) {
     try {
       const modeResult = await runProcess('tmux', buildPaneInModeArgv(target), 1000);

package/src/scripts/notify-hook/team-worker.ts

@@ -262,7 +262,7 @@ async function resolveCanonicalLeaderPaneId(_tmuxSession, leaderPaneId) {
   const normalizedLeaderPaneId = safeString(leaderPaneId).trim();
   if (normalizedLeaderPaneId) {
     try {
-      const resolved = await resolvePaneTarget({ type: 'pane', value: normalizedLeaderPaneId }, '', '', '');
+      const resolved = await resolvePaneTarget({ type: 'pane', value: normalizedLeaderPaneId }, '', '', '', {});
       const paneTarget = safeString(resolved?.paneTarget).trim();
       if (paneTarget) return paneTarget;
     } catch {
@@ -541,8 +541,8 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
     await rename(tmpPath, prevStatePath);
   } catch { /* best effort */ }
 
-  // Only fire on working->idle transition (non-idle to idle)
-  if (currentState !== 'idle') return;
+  // Fire when a worker leaves active work into an idle-ish terminal state.
+  if (currentState !== 'idle' && currentState !== 'done') return;
   if (!statusFresh) return;
   if (prevState === 'idle' || prevState === 'done') return;
 
@@ -608,7 +608,7 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
   }
 
   // Build notification message with context
-  const parts = [`[OMX] ${workerName} idle`];
+  const parts = [`[OMX] ${workerName} ${currentState}`];
   if (prevState && prevState !== 'unknown') parts.push(`(was: ${prevState})`);
   if (currentTaskId) parts.push(`task: ${currentTaskId}`);
   if (currentReason) parts.push(`reason: ${currentReason}`);

package/src/scripts/notify-hook/tmux-injection.ts

@@ -17,13 +17,13 @@ import {
 } from './state-io.js';
 import { runProcess } from './process-runner.js';
 import { logTmuxHookEvent } from './log.js';
+import { resolveManagedCurrentPane, resolveManagedSessionContext, verifyManagedPaneTarget } from './managed-tmux.js';
 import { evaluatePaneInjectionReadiness, mapPaneInjectionReadinessReason, sendPaneInput } from './team-tmux-guard.js';
 import {
   normalizeTmuxHookConfig,
   pickActiveMode,
   evaluateInjectionGuards,
   buildSendKeysArgv,
-  resolveCodexPane,
 } from '../tmux-hook-engine.js';
 
 function isHudPaneStartCommand(startCommand: any): boolean {
@@ -96,6 +96,25 @@ async function resolveCanonicalPaneFromPaneTarget(paneTarget: any, expectedCwd:
   return finalizeResolvedPane(healedPaneId, 'healed_hud_pane_target', expectedCwd);
 }
 
+async function resolvePreferredModePane(stateDir: string, allowedModes: string[]): Promise<{ mode: string; state: any; pane: string } | null> {
+  const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir).catch(() => [stateDir]);
+  const dirs = [...scopedDirs];
+  if (!dirs.map((dir) => resolvePath(dir)).includes(resolvePath(stateDir))) {
+    dirs.push(stateDir);
+  }
+  for (const dir of dirs) {
+    for (const mode of allowedModes || []) {
+      const path = join(dir, `${mode}-state.json`);
+      const parsed = await readJsonIfExists(path, null);
+      const pane = safeString(parsed?.tmux_pane_id || '').trim();
+      if (parsed?.active && pane) {
+        return { mode, state: parsed, pane };
+      }
+    }
+  }
+  return null;
+}
+
 export async function resolveSessionToPane(sessionName: any): Promise<string | null> {
   const result = await runProcess('tmux', ['list-panes', '-t', sessionName, '-F', '#{pane_id}\t#{pane_active}\t#{pane_current_command}\t#{pane_start_command}']);
   const rows = result.stdout
@@ -128,27 +147,35 @@ export async function resolveSessionToPane(sessionName: any): Promise<string | n
   return nonHudRows[0]?.paneId || null;
 }
 
-export async function resolvePaneTarget(target: any, fallbackPane: any, expectedCwd: any, modePane: any): Promise<any> {
-  const canonicalFallbackPane = safeString(fallbackPane).trim();
-  if (canonicalFallbackPane) {
-    try {
-      return await finalizeResolvedPane(canonicalFallbackPane, 'fallback_current_pane', expectedCwd);
-    } catch {
-      // Fall through to mode/config probes
-    }
+export async function resolvePaneTarget(target: any, expectedCwd: any, modePane: any, cwd: string, payload: any): Promise<any> {
+  const requiresManagedOwnership = safeString(cwd).trim() !== '' && safeString(payload?.session_id || payload?.['session-id'] || process.env.OMX_SESSION_ID || '').trim() !== '';
+  const managedContext = requiresManagedOwnership
+    ? await resolveManagedSessionContext(cwd, payload, { allowTeamWorker: false })
+    : { managed: false, reason: 'not_required', invocationSessionId: '', sessionState: null, expectedTmuxSessionName: '', currentTmuxSessionName: '' };
+  if (requiresManagedOwnership && !managedContext.managed) {
+    return { paneTarget: null, reason: managedContext.reason || 'unmanaged_session' };
   }
 
-  if (modePane) {
+  const canonicalModePane = safeString(modePane).trim();
+  if (canonicalModePane) {
     try {
-      const resolved = await resolveCanonicalPaneFromPaneTarget(modePane, expectedCwd);
+      const resolved = await resolveCanonicalPaneFromPaneTarget(canonicalModePane, expectedCwd);
       if (resolved.paneTarget) {
-        return {
-          ...resolved,
-          reason: resolved.reason === 'ok' ? 'fallback_mode_state_pane' : resolved.reason,
-        };
+        const ownership = requiresManagedOwnership
+          ? await verifyManagedPaneTarget(resolved.paneTarget, cwd, payload, { allowTeamWorker: false })
+          : { ok: true };
+        if (ownership.ok) {
+          return {
+            ...resolved,
+            reason: resolved.reason === 'ok' ? 'fallback_mode_state_pane' : resolved.reason,
+            source: 'mode_state',
+            healTarget: true,
+          };
+        }
+        return { paneTarget: null, reason: ownership.reason || 'pane_not_managed_session' };
       }
     } catch {
-      // Fall through to config probes
+      // Fall through to explicit config target
     }
   }
 
@@ -157,20 +184,52 @@ export async function resolvePaneTarget(target: any, fallbackPane: any, expected
   if (target.type === 'pane') {
     try {
       const resolved = await resolveCanonicalPaneFromPaneTarget(target.value, expectedCwd);
-      if (resolved.paneTarget) return resolved;
-    } catch {
-      // Fall through
-    }
-  } else {
-    try {
-      const paneId = await resolveSessionToPane(target.value);
-      if (paneId) return await finalizeResolvedPane(paneId, 'ok', expectedCwd);
+      if (resolved.paneTarget) {
+        const ownership = requiresManagedOwnership
+          ? await verifyManagedPaneTarget(resolved.paneTarget, cwd, payload, { allowTeamWorker: false })
+          : { ok: true };
+        if (ownership.ok) {
+          return {
+            ...resolved,
+            reason: resolved.reason === 'ok' ? 'explicit_pane_target' : resolved.reason,
+            source: 'explicit_target',
+            healTarget: true,
+          };
+        }
+        return { paneTarget: null, reason: ownership.reason || 'pane_not_managed_session' };
+      }
     } catch {
       // Fall through
     }
+    return { paneTarget: null, reason: 'target_not_found' };
   }
 
-  return { paneTarget: null, reason: 'target_not_found' };
+  try {
+    if (!requiresManagedOwnership) return { paneTarget: null, reason: 'target_session_requires_managed_context' };
+    const explicitSessionTarget = safeString(target.value).trim();
+    const expectedSessionTarget = safeString(managedContext.expectedTmuxSessionName).trim();
+    const sessionIdTarget = safeString(managedContext.invocationSessionId).trim();
+    const stateSessionTarget = safeString(managedContext.sessionState?.session_id).trim();
+    const allowedSessionTargets = new Set([expectedSessionTarget, sessionIdTarget, stateSessionTarget].filter(Boolean));
+    if (!allowedSessionTargets.has(explicitSessionTarget)) {
+      return { paneTarget: null, reason: 'target_session_not_managed' };
+    }
+    const paneId = await resolveSessionToPane(expectedSessionTarget);
+    if (!paneId) return { paneTarget: null, reason: 'target_not_found' };
+    const resolved = await finalizeResolvedPane(paneId, 'managed_session_target', expectedCwd);
+    if (!resolved.paneTarget) return resolved;
+    const ownership = await verifyManagedPaneTarget(resolved.paneTarget, cwd, payload, { allowTeamWorker: false });
+    if (!ownership.ok) {
+      return { paneTarget: null, reason: ownership.reason || 'pane_not_managed_session' };
+    }
+    return {
+      ...resolved,
+      source: 'explicit_target',
+      healTarget: true,
+    };
+  } catch {
+    return { paneTarget: null, reason: 'target_not_found' };
+  }
 }
 
 export async function handleTmuxInjection({
@@ -202,7 +261,6 @@ export async function handleTmuxInjection({
   const activeModes: string[] = [];
   const activeModeStates: Record<string, any> = {};
   const scannedStateDirs = new Set<string>();
-  const payloadSessionId = safeString(payload.session_id || payload['session-id'] || '');
   const scanActiveModeStateDirs = async (dirs: string[], preserveExisting = false) => {
     for (const scopedDir of dirs) {
       const resolvedScopedDir = resolvePath(scopedDir);
@@ -225,7 +283,7 @@ export async function handleTmuxInjection({
     }
   };
   try {
-    const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir, payloadSessionId);
+    const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir);
     await scanActiveModeStateDirs(scopedDirs);
 
     if (!pickActiveMode(activeModes, config.allowed_modes) && !scannedStateDirs.has(resolvePath(stateDir))) {
@@ -235,9 +293,10 @@ export async function handleTmuxInjection({
     // Non-fatal
   }
 
-  const mode = pickActiveMode(activeModes, config.allowed_modes);
-  const modeState = mode ? (activeModeStates[mode] || {}) : {};
-  const modePane = safeString(modeState.tmux_pane_id || '');
+  const preferredModePane = await resolvePreferredModePane(stateDir, config.allowed_modes).catch(() => null);
+  const mode = preferredModePane?.mode || pickActiveMode(activeModes, config.allowed_modes);
+  const modeState = preferredModePane?.state || (mode ? (activeModeStates[mode] || {}) : {});
+  const modePane = preferredModePane?.pane || safeString(modeState.tmux_pane_id || '');
   const preGuard = evaluateInjectionGuards({
     config,
     mode,
@@ -280,8 +339,19 @@ export async function handleTmuxInjection({
     turnId,
     timestamp: nowIso,
   }), sourceText);
-  const fallbackPane = resolveCodexPane();
-  const resolution = await resolvePaneTarget(config.target, fallbackPane, cwd, modePane);
+  const preferredPaneTarget = modePane || await resolveManagedCurrentPane(cwd, payload, { allowTeamWorker: false });
+  let resolution = preferredModePane
+    ? await resolveCanonicalPaneFromPaneTarget(preferredModePane.pane, cwd).then((resolved) => (
+      resolved.paneTarget
+        ? { ...resolved, reason: 'fallback_mode_state_pane', source: 'mode_state', healTarget: true }
+        : resolved
+    ))
+    : preferredPaneTarget
+      ? await resolvePaneTarget({ type: 'pane', value: preferredPaneTarget }, cwd, '', cwd, payload)
+      : await resolvePaneTarget(config.target, cwd, modePane, cwd, payload);
+  if (!resolution.paneTarget && preferredPaneTarget) {
+    resolution = await resolvePaneTarget(config.target, cwd, modePane, cwd, payload);
+  }
   if (!resolution.paneTarget) {
     state.last_reason = resolution.reason;
     state.last_event_at = nowIso;
@@ -319,7 +389,7 @@ export async function handleTmuxInjection({
   }
 
   // Pane-canonical healing: persist resolved pane target so routing stops depending on session names or stale pane ids.
-  if (config.target && (config.target.type !== 'pane' || safeString(config.target.value).trim() !== paneTarget)) {
+  if (resolution.healTarget && config.target && (config.target.type !== 'pane' || safeString(config.target.value).trim() !== paneTarget)) {
     try {
       const healed = {
         ...(rawConfig && typeof rawConfig === 'object' ? rawConfig : {}),