oh-my-codex 0.11.0 → 0.11.2

package/src/scripts/__tests__/smoke-packed-install.test.ts

@@ -1,67 +1,26 @@
 // @ts-nocheck
 import assert from 'node:assert/strict';
-import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { test } from 'node:test';
 import {
   ensureRepoDependencies,
-  hasSparkShellFallbackBanner,
   hasUsableNodeModules,
-  prepareLocalHydrationAssetDirectory,
+  PACKED_INSTALL_SMOKE_CORE_COMMANDS,
   resolveGitCommonDir,
   resolveReusableNodeModulesSource,
-  rewriteManifestDownloadUrls,
 } from '../smoke-packed-install.js';
 
-test('detects the sparkshell GLIBC fallback banner', () => {
+test('packed install smoke stays limited to boot + core commands', () => {
+  assert.deepEqual(PACKED_INSTALL_SMOKE_CORE_COMMANDS, [
+    ['--help'],
+    ['version'],
+  ]);
   assert.equal(
-    hasSparkShellFallbackBanner('[sparkshell] GLIBC-incompatible native sidecar detected; falling back to raw command execution without summary support.\n'),
-    true,
+    PACKED_INSTALL_SMOKE_CORE_COMMANDS.some((argv) => argv.includes('explore') || argv.includes('sparkshell')),
+    false,
   );
-  assert.equal(hasSparkShellFallbackBanner('node v20.0.0\n'), false);
-});
-
-test('rewrites copied native manifest download urls to the local smoke server', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'omx-smoke-packed-install-'));
-  try {
-    const sourceDir = join(root, 'source-release-assets');
-    await mkdir(sourceDir, { recursive: true });
-    await writeFile(join(sourceDir, 'omx-explore-harness-x86_64-unknown-linux-musl.tar.xz'), 'explore');
-    await writeFile(join(sourceDir, 'omx-sparkshell-x86_64-unknown-linux-musl.tar.xz'), 'sparkshell');
-    await writeFile(join(sourceDir, 'native-release-manifest.json'), JSON.stringify({
-      version: '0.9.0',
-      assets: [
-        {
-          product: 'omx-explore-harness',
-          archive: 'omx-explore-harness-x86_64-unknown-linux-musl.tar.xz',
-          download_url: 'https://github.com/example/omx-explore-harness-x86_64-unknown-linux-musl.tar.xz',
-        },
-        {
-          product: 'omx-sparkshell',
-          archive: 'omx-sparkshell-x86_64-unknown-linux-musl.tar.xz',
-          download_url: 'https://github.com/example/omx-sparkshell-x86_64-unknown-linux-musl.tar.xz',
-        },
-      ],
-    }, null, 2));
-
-    const copiedDir = prepareLocalHydrationAssetDirectory(sourceDir, root);
-    rewriteManifestDownloadUrls(join(copiedDir, 'native-release-manifest.json'), 'http://127.0.0.1:43123');
-
-    const originalManifest = JSON.parse(await readFile(join(sourceDir, 'native-release-manifest.json'), 'utf-8')) as { assets: Array<{ download_url: string }> };
-    const copiedManifest = JSON.parse(await readFile(join(copiedDir, 'native-release-manifest.json'), 'utf-8')) as { assets: Array<{ download_url: string }> };
-
-    assert.match(originalManifest.assets[0].download_url, /^https:\/\/github\.com\//);
-    assert.deepEqual(
-      copiedManifest.assets.map((asset) => asset.download_url),
-      [
-        'http://127.0.0.1:43123/omx-explore-harness-x86_64-unknown-linux-musl.tar.xz',
-        'http://127.0.0.1:43123/omx-sparkshell-x86_64-unknown-linux-musl.tar.xz',
-      ],
-    );
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
 });
 
 test('resolveGitCommonDir resolves relative git common dir output against the repo root', () => {

package/src/scripts/__tests__/test-reply-listener-live.test.ts

@@ -0,0 +1,101 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import {
+  resolveReplyListenerLiveEnv,
+  runReplyListenerLiveSmoke,
+} from '../test-reply-listener-live.js';
+
+function jsonResponse(body: unknown, init: ResponseInit = {}): Response {
+  const headers = new Headers(init.headers);
+  if (!headers.has('content-type')) {
+    headers.set('content-type', 'application/json');
+  }
+  return new Response(JSON.stringify(body), { ...init, headers });
+}
+
+test('resolveReplyListenerLiveEnv stays disabled until explicitly opted in', () => {
+  const result = resolveReplyListenerLiveEnv({
+    OMX_DISCORD_NOTIFIER_BOT_TOKEN: 'discord-token',
+    OMX_DISCORD_NOTIFIER_CHANNEL: 'channel-1',
+    OMX_TELEGRAM_BOT_TOKEN: 'telegram-token',
+    OMX_TELEGRAM_CHAT_ID: 'chat-1',
+  });
+
+  assert.deepEqual(result, {
+    enabled: false,
+    missing: [],
+    config: null,
+  });
+});
+
+test('resolveReplyListenerLiveEnv reports missing credentials when opted in', () => {
+  const result = resolveReplyListenerLiveEnv({
+    OMX_REPLY_LISTENER_LIVE: '1',
+    OMX_DISCORD_NOTIFIER_BOT_TOKEN: 'discord-token',
+    OMX_TELEGRAM_CHAT_ID: 'chat-1',
+  });
+
+  assert.equal(result.enabled, true);
+  assert.deepEqual(result.missing, [
+    'OMX_DISCORD_NOTIFIER_CHANNEL',
+    'OMX_TELEGRAM_BOT_TOKEN',
+  ]);
+  assert.equal(result.config, null);
+});
+
+test('runReplyListenerLiveSmoke exercises Discord and Telegram send + cleanup requests', async () => {
+  const calls: Array<{ url: string; init?: RequestInit }> = [];
+  const logs: string[] = [];
+
+  const fetchImpl: typeof fetch = async (input, init) => {
+    const url = String(input);
+    calls.push({ url, init });
+
+    if (url === 'https://discord.com/api/v10/channels/channel-1/messages') {
+      assert.equal(init?.method, 'POST');
+      assert.match(String(init?.body), /Discord connectivity probe/);
+      return jsonResponse({ id: 'discord-message-1' });
+    }
+
+    if (url === 'https://discord.com/api/v10/channels/channel-1/messages/discord-message-1') {
+      assert.equal(init?.method, 'DELETE');
+      return new Response(null, { status: 204 });
+    }
+
+    if (url === 'https://api.telegram.org/bottelegram-token/sendMessage') {
+      assert.equal(init?.method, 'POST');
+      assert.match(String(init?.body), /Telegram connectivity probe/);
+      return jsonResponse({ ok: true, result: { message_id: 42 } });
+    }
+
+    if (url === 'https://api.telegram.org/bottelegram-token/deleteMessage') {
+      assert.equal(init?.method, 'POST');
+      const payload = JSON.parse(String(init?.body)) as { chat_id: string; message_id: number };
+      assert.deepEqual(payload, { chat_id: 'chat-1', message_id: 42 });
+      return jsonResponse({ ok: true, result: true });
+    }
+
+    throw new Error(`Unexpected live smoke fetch url: ${url}`);
+  };
+
+  const result = await runReplyListenerLiveSmoke(
+    {
+      discordBotToken: 'discord-token',
+      discordChannelId: 'channel-1',
+      telegramBotToken: 'telegram-token',
+      telegramChatId: 'chat-1',
+    },
+    {
+      fetchImpl,
+      log: (message) => logs.push(message),
+    },
+  );
+
+  assert.deepEqual(result, {
+    discordMessageId: 'discord-message-1',
+    telegramMessageId: '42',
+  });
+  assert.equal(calls.length, 4);
+  assert.ok(logs.some((entry) => entry.includes('Discord probe message sent: discord-message-1')));
+  assert.ok(logs.some((entry) => entry.includes('Telegram probe message sent: 42')));
+});

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

@@ -231,9 +231,15 @@ async function withMailboxLock(teamDirPath, workerName, fn) {
   }
 }
 
+function resolveLeaderPaneId(config) {
+  return safeString(config?.leader_pane_id).trim();
+}
+
+
 function defaultInjectTarget(request, config) {
   if (request.to_worker === 'leader-fixed') {
-    if (config.leader_pane_id) return { type: 'pane', value: config.leader_pane_id };
+    const leaderPaneId = resolveLeaderPaneId(config);
+    if (leaderPaneId) return { type: 'pane', value: leaderPaneId };
     return null;
   }
   if (request.pane_id) return { type: 'pane', value: request.pane_id };
@@ -489,7 +495,7 @@ export async function drainPendingTeamDispatch({
           continue;
         }
 
-        if (request.to_worker === 'leader-fixed' && !safeString(config?.leader_pane_id).trim()) {
+        if (request.to_worker === 'leader-fixed' && !resolveLeaderPaneId(config)) {
           const nowIso = new Date().toISOString();
           const alreadyDeferred = safeString(request.last_reason).trim() === LEADER_PANE_MISSING_DEFERRED_REASON;
           request.updated_at = nowIso;

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

@@ -11,7 +11,7 @@ import { readJsonIfExists, getScopedStateDirsForCurrentSession } from './state-i
 import { runProcess } from './process-runner.js';
 import { logTmuxHookEvent } from './log.js';
 import { evaluatePaneInjectionReadiness, sendPaneInput } from './team-tmux-guard.js';
-import { DEFAULT_MARKER } from '../tmux-hook-engine.js';
+import { DEFAULT_MARKER, resolveCodexPane } from '../tmux-hook-engine.js';
 const LEADER_PANE_MISSING_NO_INJECTION_REASON = 'leader_pane_missing_no_injection';
 const LEADER_PANE_SHELL_NO_INJECTION_REASON = 'leader_pane_shell_no_injection';
 const LEADER_NOTIFICATION_DEFERRED_TYPE = 'leader_notification_deferred';
@@ -541,8 +541,9 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
     const workerPaneIds = Array.isArray(workers)
       ? workers.map((w) => safeString(w && w.pane_id ? w.pane_id : '')).filter(Boolean)
       : [];
-    if (!tmuxSession && !leaderPaneId) continue;
-    const tmuxTarget = leaderPaneId;
+    const canonicalLeaderPaneId = safeString(resolveCodexPane() || leaderPaneId).trim();
+    if (!tmuxSession && !canonicalLeaderPaneId) continue;
+    const tmuxTarget = canonicalLeaderPaneId;
     const paneStatus = tmuxSession
       ? await checkWorkerPanesAlive(tmuxSession, workerPaneIds)
       : { alive: false, paneCount: 0 };

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

@@ -10,6 +10,7 @@ import { asNumber, safeString, isTerminalPhase } from './utils.js';
 import { readJsonIfExists } from './state-io.js';
 import { logTmuxHookEvent } from './log.js';
 import { checkPaneReadyForTeamSendKeys, sendPaneInput } from './team-tmux-guard.js';
+import { resolvePaneTarget } from './tmux-injection.js';
 import { DEFAULT_MARKER } from '../tmux-hook-engine.js';
 const LEADER_PANE_SHELL_NO_INJECTION_REASON = 'leader_pane_shell_no_injection';
 
@@ -257,6 +258,21 @@ export async function readTeamWorkersForIdleCheck(stateDir, teamName) {
   }
 }
 
+async function resolveCanonicalLeaderPaneId(_tmuxSession, leaderPaneId) {
+  const normalizedLeaderPaneId = safeString(leaderPaneId).trim();
+  if (normalizedLeaderPaneId) {
+    try {
+      const resolved = await resolvePaneTarget({ type: 'pane', value: normalizedLeaderPaneId }, '', '', '');
+      const paneTarget = safeString(resolved?.paneTarget).trim();
+      if (paneTarget) return paneTarget;
+    } catch {
+      // fall through to tmux session scan
+    }
+    return normalizedLeaderPaneId;
+  }
+  return '';
+}
+
 async function emitLeaderPaneMissingDeferred({
   stateDir,
   logsDir,
@@ -342,6 +358,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
   const teamInfo = await readTeamWorkersForIdleCheck(stateDir, teamName);
   if (!teamInfo) return;
   const { workers, tmuxSession, leaderPaneId } = teamInfo;
+  const canonicalLeaderPaneId = await resolveCanonicalLeaderPaneId(tmuxSession, leaderPaneId);
 
   // Check cooldown to prevent notification spam
   const idleStatePath = join(stateDir, 'team', teamName, 'all-workers-idle.json');
@@ -364,7 +381,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
   );
   if (!allIdle) return;
 
-  if (!leaderPaneId) {
+  if (!canonicalLeaderPaneId) {
     const nextIdleState = {
       ...idleState,
       last_notified_at_ms: nowMs,
@@ -380,7 +397,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
       workerName,
       sourceType: 'all_workers_idle',
       tmuxSession,
-      leaderPaneId,
+      leaderPaneId: canonicalLeaderPaneId,
     });
     return;
   }
@@ -388,7 +405,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
   const N = workers.length;
   const nextAction = `Next: run omx team status ${teamName}, read unread worker messages, then decide whether to assign the next concrete task, reconcile results, or shut the team down.`;
   const message = `[OMX] All ${N} worker${N === 1 ? '' : 's'} idle. ${nextAction} ${DEFAULT_MARKER}`;
-  const tmuxTarget = leaderPaneId;
+  const tmuxTarget = canonicalLeaderPaneId;
   const paneGuard = await checkPaneReadyForTeamSendKeys(tmuxTarget);
   if (!paneGuard.ok) {
     const nextIdleState = {
@@ -409,7 +426,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
       paneCurrentCommand: paneGuard.paneCurrentCommand,
       sourceType: 'all_workers_idle',
       tmuxSession,
-      leaderPaneId,
+      leaderPaneId: canonicalLeaderPaneId,
     });
     return;
   }
@@ -548,8 +565,9 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
   const teamInfo = await readTeamWorkersForIdleCheck(stateDir, teamName);
   if (!teamInfo) return;
   const { tmuxSession, leaderPaneId } = teamInfo;
+  const canonicalLeaderPaneId = await resolveCanonicalLeaderPaneId(tmuxSession, leaderPaneId);
 
-  if (!leaderPaneId) {
+  if (!canonicalLeaderPaneId) {
     await emitLeaderPaneMissingDeferred({
       stateDir,
       logsDir,
@@ -557,11 +575,11 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
       workerName,
       sourceType: 'worker_idle',
       tmuxSession,
-      leaderPaneId,
+      leaderPaneId: canonicalLeaderPaneId,
     });
     return;
   }
-  const tmuxTarget = leaderPaneId;
+  const tmuxTarget = canonicalLeaderPaneId;
   const paneGuard = await checkPaneReadyForTeamSendKeys(tmuxTarget);
   if (!paneGuard.ok) {
     try {
@@ -584,7 +602,7 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
       paneCurrentCommand: paneGuard.paneCurrentCommand,
       sourceType: 'worker_idle',
       tmuxSession,
-      leaderPaneId,
+      leaderPaneId: canonicalLeaderPaneId,
     });
     return;
   }

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

@@ -23,75 +23,132 @@ import {
   pickActiveMode,
   evaluateInjectionGuards,
   buildSendKeysArgv,
+  resolveCodexPane,
 } from '../tmux-hook-engine.js';
 
-export async function resolveSessionToPane(sessionName: any): Promise<string | null> {
-  const result = await runProcess('tmux', ['list-panes', '-t', sessionName, '-F', '#{pane_id} #{pane_active}']);
-  const lines = result.stdout
-    .split('\n')
-    .map((line: string) => line.trim())
-    .filter(Boolean);
-  if (lines.length === 0) return null;
-  const active = lines.find((line: string) => line.endsWith(' 1')) || lines[0];
-  const paneId = active.split(' ')[0];
-  return paneId || null;
+function isHudPaneStartCommand(startCommand: any): boolean {
+  return /\bomx\b.*\bhud\b.*--watch/i.test(safeString(startCommand));
 }
 
-export async function resolvePaneByCwd(expectedCwd: any): Promise<any> {
+async function resolvePaneCwdMismatch(paneId: string, expectedCwd: any): Promise<any | null> {
   if (!expectedCwd) return null;
-  const result = await runProcess('tmux', ['list-panes', '-a', '-F', '#{pane_id}\t#{pane_current_path}\t#{pane_active}\t#{session_name}']);
-  const lines = result.stdout
+  try {
+    const paneCwdResult = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#{pane_current_path}']);
+    const paneCwd = safeString(paneCwdResult.stdout).trim();
+    if (paneCwd && resolvePath(paneCwd) !== resolvePath(expectedCwd)) {
+      return {
+        paneTarget: null,
+        reason: 'pane_cwd_mismatch',
+        pane_cwd: paneCwd,
+        expected_cwd: expectedCwd,
+      };
+    }
+  } catch {
+    // Best effort only — if tmux cannot report cwd, keep the explicit pane target.
+  }
+  return null;
+}
+
+async function finalizeResolvedPane(paneId: string, reason: string, expectedCwd: any): Promise<any> {
+  const cwdMismatch = await resolvePaneCwdMismatch(paneId, expectedCwd);
+  if (cwdMismatch) return cwdMismatch;
+  let sessionName = '';
+  try {
+    const currentSession = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#S']);
+    sessionName = safeString(currentSession.stdout).trim();
+  } catch {
+    sessionName = '';
+  }
+  return {
+    paneTarget: paneId,
+    reason,
+    matched_session: sessionName || null,
+  };
+}
+
+async function resolveCanonicalPaneFromPaneTarget(paneTarget: any, expectedCwd: any): Promise<any> {
+  const paneResult = await runProcess('tmux', ['display-message', '-p', '-t', paneTarget, '#{pane_id}']);
+  const paneId = safeString(paneResult.stdout).trim();
+  if (!paneId) return { paneTarget: null, reason: 'target_not_found' };
+
+  let startCommand = '';
+  try {
+    const startResult = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#{pane_start_command}']);
+    startCommand = safeString(startResult.stdout).trim();
+  } catch {
+    startCommand = '';
+  }
+  if (!startCommand || !isHudPaneStartCommand(startCommand)) {
+    return finalizeResolvedPane(paneId, 'ok', expectedCwd);
+  }
+
+  let sessionName = '';
+  try {
+    const sessionResult = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#S']);
+    sessionName = safeString(sessionResult.stdout).trim();
+  } catch {
+    sessionName = '';
+  }
+  if (!sessionName) return { paneTarget: null, reason: 'target_is_hud_pane' };
+
+  const healedPaneId = await resolveSessionToPane(sessionName);
+  if (!healedPaneId) return { paneTarget: null, reason: 'target_is_hud_pane' };
+  return finalizeResolvedPane(healedPaneId, 'healed_hud_pane_target', expectedCwd);
+}
+
+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
     .split('\n')
     .map((line: string) => line.trim())
-    .filter(Boolean);
-
-  const expected = resolvePath(expectedCwd);
-  const candidates: any[] = [];
-  for (const line of lines) {
-    const parts = line.split('\t');
-    if (parts.length < 4) continue;
-    const [paneId, paneCwd, activeRaw, sessionName] = parts;
-    if (!paneId || !paneCwd) continue;
-    if (resolvePath(paneCwd) !== expected) continue;
-    const active = activeRaw === '1';
-    candidates.push({ paneId, paneCwd, active, sessionName: sessionName || null });
-  }
-  if (candidates.length === 0) return null;
+    .filter(Boolean)
+    .map((line: string) => {
+      const parts = line.includes('\t')
+        ? line.split('\t')
+        : line.split(/\s+/, 4);
+      const [paneId = '', activeRaw = '0', currentCommand = '', startCommand = ''] = parts;
+      return {
+        paneId,
+        active: activeRaw === '1',
+        currentCommand: safeString(currentCommand).trim().toLowerCase(),
+        startCommand: safeString(startCommand).trim(),
+      };
+    })
+    .filter((row: any) => row.paneId.startsWith('%'));
+  if (rows.length === 0) return null;
 
-  const pick = candidates.find((c: any) => c.active) || candidates[0];
-  return pick;
+  const nonHudRows = rows.filter((row: any) => !isHudPaneStartCommand(row.startCommand));
+  const canonicalRows = nonHudRows.filter((row: any) => /\bcodex\b/i.test(row.startCommand));
+  const activeCanonical = canonicalRows.find((row: any) => row.active);
+  if (activeCanonical) return activeCanonical.paneId;
+  if (canonicalRows[0]) return canonicalRows[0].paneId;
+
+  const activeNonHud = nonHudRows.find((row: any) => row.active);
+  if (activeNonHud) return activeNonHud.paneId;
+  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
+    }
+  }
+
   if (modePane) {
     try {
-      const modePaneResult = await runProcess('tmux', ['display-message', '-p', '-t', modePane, '#{pane_id}']);
-      const paneId = safeString(modePaneResult.stdout).trim();
-      if (paneId) {
-        if (expectedCwd) {
-          const paneCwdResult = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#{pane_current_path}']);
-          const paneCwd = safeString(paneCwdResult.stdout).trim();
-          if (!paneCwd || resolvePath(paneCwd) === resolvePath(expectedCwd)) {
-            const currentSession = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#S']);
-            const sessionName = safeString(currentSession.stdout).trim();
-            return {
-              paneTarget: paneId,
-              reason: 'fallback_mode_state_pane',
-              matched_session: sessionName || null,
-            };
-          }
-        } else {
-          const currentSession = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#S']);
-          const sessionName = safeString(currentSession.stdout).trim();
-          return {
-            paneTarget: paneId,
-            reason: 'fallback_mode_state_pane',
-            matched_session: sessionName || null,
-          };
-        }
+      const resolved = await resolveCanonicalPaneFromPaneTarget(modePane, expectedCwd);
+      if (resolved.paneTarget) {
+        return {
+          ...resolved,
+          reason: resolved.reason === 'ok' ? 'fallback_mode_state_pane' : resolved.reason,
+        };
       }
     } catch {
-      // Fall through to config/fallback probes
+      // Fall through to config probes
     }
   }
 
@@ -99,65 +156,20 @@ export async function resolvePaneTarget(target: any, fallbackPane: any, expected
 
   if (target.type === 'pane') {
     try {
-      const result = await runProcess('tmux', ['display-message', '-p', '-t', target.value, '#{pane_id}']);
-      const paneId = safeString(result.stdout).trim();
-      if (paneId) return { paneTarget: paneId, reason: 'ok' };
+      const resolved = await resolveCanonicalPaneFromPaneTarget(target.value, expectedCwd);
+      if (resolved.paneTarget) return resolved;
     } catch {
-      // Fall through to fallback probe
+      // Fall through
     }
   } else {
     try {
       const paneId = await resolveSessionToPane(target.value);
-      if (paneId) return { paneTarget: paneId, reason: 'ok' };
-    } catch {
-      // Fall through to fallback probe
-    }
-  }
-
-  if (fallbackPane) {
-    try {
-      const currentPane = await runProcess('tmux', ['display-message', '-p', '-t', fallbackPane, '#{pane_id}']);
-      const paneId = safeString(currentPane.stdout).trim();
-      if (paneId) {
-        if (expectedCwd) {
-          const paneCwdResult = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#{pane_current_path}']);
-          const paneCwd = safeString(paneCwdResult.stdout).trim();
-          if (paneCwd && resolvePath(paneCwd) !== resolvePath(expectedCwd)) {
-            return {
-              paneTarget: null,
-              reason: 'pane_cwd_mismatch',
-              pane_cwd: paneCwd,
-              expected_cwd: expectedCwd,
-            };
-          }
-        }
-
-        const currentSession = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#S']);
-        const sessionName = safeString(currentSession.stdout).trim();
-        return {
-          paneTarget: paneId,
-          reason: 'fallback_current_pane',
-          matched_session: sessionName || null,
-        };
-      }
+      if (paneId) return await finalizeResolvedPane(paneId, 'ok', expectedCwd);
     } catch {
       // Fall through
     }
   }
 
-  try {
-    const match = await resolvePaneByCwd(expectedCwd);
-    if (match && match.paneId) {
-      return {
-        paneTarget: match.paneId,
-        reason: 'fallback_pane_by_cwd',
-        matched_session: match.sessionName,
-      };
-    }
-  } catch {
-    // Fall through
-  }
-
   return { paneTarget: null, reason: 'target_not_found' };
 }
 
@@ -268,8 +280,7 @@ export async function handleTmuxInjection({
     turnId,
     timestamp: nowIso,
   }), sourceText);
-  const { resolveCodexPane } = await import('../tmux-hook-engine.js');
-  const fallbackPane = resolveCodexPane() || safeString(process.env.TMUX_PANE || '');
+  const fallbackPane = resolveCodexPane();
   const resolution = await resolvePaneTarget(config.target, fallbackPane, cwd, modePane);
   if (!resolution.paneTarget) {
     state.last_reason = resolution.reason;
@@ -307,8 +318,8 @@ export async function handleTmuxInjection({
     return;
   }
 
-  // Pane-canonical healing: persist resolved pane target so routing stops depending on session names.
-  if (config.target && config.target.type !== 'pane') {
+  // 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)) {
     try {
       const healed = {
         ...(rawConfig && typeof rawConfig === 'object' ? rawConfig : {}),