oh-my-codex 0.15.0 → 0.15.2

package/src/scripts/codex-native-pre-post.ts

@@ -152,6 +152,7 @@ export function detectMcpTransportFailure(
   payload: CodexHookPayload,
 ): McpTransportFailureSignal | null {
   const normalized = normalizePostToolUsePayload(payload);
+  if (normalized.isBash) return null;
   const combined = [
     normalized.stderrText,
     normalized.stdoutText,
@@ -591,10 +592,6 @@ function buildGitCommitEnforcementOutput(commandText: string): Record<string, un
       "git commit is blocked until the inline commit message satisfies the Lore format and includes the required OmX co-author trailer.",
     hookSpecificOutput: {
       hookEventName: "PreToolUse",
-      additionalContext: [
-        "Lore-format git commit enforcement triggered.",
-        ...errors.map((error) => `- ${error}`),
-      ].join("\n"),
     },
     systemMessage: [
       "git commit is blocked until the inline commit message follows the Lore protocol and includes `Co-authored-by: OmX <omx@oh-my-codex.dev>`.",
@@ -764,10 +761,17 @@ function containsHardFailure(text: string): boolean {
   return /command not found|permission denied|no such file or directory/i.test(text);
 }
 
+function hasActionableBashHardFailure(normalized: NormalizedPostToolUsePayload): boolean {
+  if (containsHardFailure(normalized.stderrText)) return true;
+  if (normalized.exitCode === null || normalized.exitCode === 0) return false;
+  return containsHardFailure(`${normalized.stderrText}\n${normalized.stdoutText}`);
+}
+
 export function buildNativePostToolUseOutput(
   payload: CodexHookPayload,
 ): Record<string, unknown> | null {
-  const mcpTransportFailure = detectMcpTransportFailure(payload);
+  const normalized = normalizePostToolUsePayload(payload);
+  const mcpTransportFailure = normalized.isBash ? null : detectMcpTransportFailure(payload);
   if (mcpTransportFailure) {
     const fallbackCommand = buildOmxParityFallbackCommand(payload, mcpTransportFailure.toolName);
     const fallbackText = fallbackCommand
@@ -784,12 +788,10 @@ export function buildNativePostToolUseOutput(
     };
   }
 
-  const normalized = normalizePostToolUsePayload(payload);
   if (!normalized.isBash) return null;
 
   const combined = `${normalized.stderrText}\n${normalized.stdoutText}`.trim();
-  if (normalized.exitCode === 0) return null;
-  if (containsHardFailure(combined)) {
+  if (hasActionableBashHardFailure(normalized)) {
     return {
       decision: "block",
       reason: "The Bash output indicates a command/setup failure that should be fixed before retrying.",

package/src/scripts/generate-release-body.ts

@@ -75,6 +75,15 @@ export function resolveCurrentTag(cwd: string, explicit?: string): string {
   throw new Error('unable to determine current release tag; pass --current-tag or set GITHUB_REF_NAME');
 }
 
+function isAncestorTag(cwd: string, possibleAncestor: string, currentTag: string): boolean {
+  const result = spawnSync('git', ['merge-base', '--is-ancestor', possibleAncestor, currentTag], {
+    cwd,
+    encoding: 'utf-8',
+    stdio: 'pipe',
+  });
+  return result.status === 0;
+}
+
 export function resolvePreviousTag(cwd: string, currentTag: string, explicit?: string): string | undefined {
   if (explicit) return explicit;
   const tags = runGit(['tag', '--list', 'v*', '--sort=-v:refname'], cwd, true)
@@ -83,8 +92,10 @@ export function resolvePreviousTag(cwd: string, currentTag: string, explicit?: s
     .filter(Boolean);
   if (tags.length === 0) return undefined;
   const currentIndex = tags.indexOf(currentTag);
-  if (currentIndex >= 0) return tags.slice(currentIndex + 1).find(Boolean);
-  return tags.find((tag) => tag !== currentTag);
+  const candidates = currentIndex >= 0
+    ? tags.slice(currentIndex + 1)
+    : tags.filter((tag) => tag !== currentTag);
+  return candidates.find((tag) => isAncestorTag(cwd, tag, currentTag));
 }
 
 function verifyGitCommitRef(cwd: string, ref: string, label: string): void {

package/src/scripts/notify-hook/__tests__/team-worker-posttooluse.test.ts

@@ -0,0 +1,180 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { execFileSync } from 'node:child_process';
+import { chmod, mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { handleTeamWorkerPostToolUseSuccess, teamWorkerPostToolUseInternals } from '../team-worker-posttooluse.js';
+import { readTeamEvents } from '../../../team/state/events.js';
+
+async function initWorkerFixture(): Promise<{ cwd: string; stateRoot: string; env: NodeJS.ProcessEnv }> {
+  const cwd = await mkdtemp(join(tmpdir(), 'omx-posttooluse-worker-'));
+  execFileSync('git', ['init'], { cwd, stdio: 'ignore' });
+  execFileSync('git', ['config', 'user.email', 'test@example.com'], { cwd, stdio: 'ignore' });
+  execFileSync('git', ['config', 'user.name', 'Test User'], { cwd, stdio: 'ignore' });
+  await writeFile(join(cwd, 'README.md'), 'hello\n', 'utf-8');
+  execFileSync('git', ['add', 'README.md'], { cwd, stdio: 'ignore' });
+  execFileSync('git', ['commit', '-m', 'init'], { cwd, stdio: 'ignore' });
+
+  const stateRoot = join(cwd, '.omx', 'state');
+  const workerDir = join(stateRoot, 'team', 'demo-team', 'workers', 'worker-1');
+  await mkdir(workerDir, { recursive: true });
+  await writeFile(join(workerDir, 'identity.json'), JSON.stringify({
+    name: 'worker-1',
+    team_state_root: stateRoot,
+    worktree_path: cwd,
+  }, null, 2), 'utf-8');
+  await writeFile(join(stateRoot, 'team', 'demo-team', 'phase.json'), JSON.stringify({ current_phase: 'team-exec' }, null, 2), 'utf-8');
+  await writeFile(join(stateRoot, 'team', 'demo-team', 'config.json'), JSON.stringify({ leader_cwd: cwd }, null, 2), 'utf-8');
+  return {
+    cwd,
+    stateRoot,
+    env: {
+      ...process.env,
+      OMX_TEAM_WORKER: 'demo-team/worker-1',
+      OMX_TEAM_STATE_ROOT: stateRoot,
+    },
+  };
+}
+
+const successPayload = {
+  hook_event_name: 'PostToolUse',
+  tool_name: 'Bash',
+  tool_response: { exit_code: 0 },
+  tool_use_id: 'tool-1',
+};
+
+describe('handleTeamWorkerPostToolUseSuccess', () => {
+  it('creates a safe worker checkpoint, ledger entries, leader signal, and dedupe marker', async () => {
+    const fixture = await initWorkerFixture();
+    await writeFile(join(fixture.cwd, 'feature.txt'), 'feature\n', 'utf-8');
+
+    const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
+
+    assert.equal(result.handled, true);
+    assert.equal(result.status, 'applied');
+    assert.ok(result.checkpointCommit);
+    assert.deepEqual(result.operationKinds, ['auto_checkpoint', 'worker_clean_rebase', 'leader_integration_attempt']);
+
+    const log = execFileSync('git', ['log', '-1', '--pretty=%s'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    assert.equal(log, 'omx(team): auto-checkpoint worker-1');
+
+    const events = await readTeamEvents('demo-team', fixture.cwd, { type: 'worker_integration_attempt_requested' });
+    assert.equal(events.length, 1);
+    const event = events[0]!;
+    assert.equal(event.type, 'worker_integration_attempt_requested');
+    assert.equal(event.worker, 'worker-1');
+    const metadata = event.metadata as Record<string, unknown>;
+    assert.equal(metadata.operation_kind, 'leader_integration_attempt');
+    assert.equal(metadata.outcome_status, 'applied');
+    assert.equal(metadata.source, 'posttooluse');
+    assert.equal(metadata.dedupe_key, result.dedupeKey);
+    assert.match(String(metadata.leader_head_observed), /^[0-9a-f]{40}$/);
+
+    const dedupe = JSON.parse(await readFile(join(fixture.stateRoot, 'team', 'demo-team', 'workers', 'worker-1', 'posttooluse-dedupe.json'), 'utf-8')) as { keys: string[] };
+    assert.equal(dedupe.keys.includes(result.dedupeKey!), true);
+
+    const ledger = JSON.parse(await readFile(join(fixture.cwd, '.omx', 'reports', 'team-commit-hygiene', 'demo-team.ledger.json'), 'utf-8')) as { entries: Array<{ operation: string; status: string }> };
+    assert.equal(ledger.entries.some((entry) => entry.operation === 'auto_checkpoint' && entry.status === 'applied'), true);
+    assert.equal(ledger.entries.some((entry) => entry.operation === 'worker_clean_rebase' && entry.status === 'noop'), true);
+    assert.equal(ledger.entries.some((entry) => entry.operation === 'leader_integration_attempt' && entry.status === 'applied'), true);
+  });
+
+  it('records noop without creating a checkpoint commit', async () => {
+    const fixture = await initWorkerFixture();
+    const before = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+
+    const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
+
+    const after = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    assert.equal(result.status, 'noop');
+    assert.equal(result.checkpointCommit, null);
+    assert.equal(after, before);
+  });
+
+  it('skips protected runtime-only changes', async () => {
+    const fixture = await initWorkerFixture();
+    await writeFile(join(fixture.cwd, 'AGENTS.md'), 'generated worker instructions\n', 'utf-8');
+
+    const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
+
+    assert.equal(result.status, 'skipped');
+    assert.equal(result.reason, 'only_protected_paths_changed');
+    assert.equal(result.checkpointCommit, null);
+  });
+
+  it('does not checkpoint its own runtime report artifacts on a repeated PostToolUse turn', async () => {
+    const fixture = await initWorkerFixture();
+    await writeFile(join(fixture.cwd, 'feature.txt'), 'feature\n', 'utf-8');
+
+    const first = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
+    const headAfterFirst = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    const second = await handleTeamWorkerPostToolUseSuccess({ ...successPayload, tool_use_id: 'tool-2' }, fixture.cwd, fixture.env);
+    const headAfterSecond = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    const events = await readTeamEvents('demo-team', fixture.cwd, { type: 'worker_integration_attempt_requested' });
+
+    assert.equal(first.status, 'applied');
+    assert.equal(second.status, 'noop');
+    assert.equal(headAfterSecond, headAfterFirst);
+    assert.equal(events.length, 1);
+  });
+
+  it('skips checkpointing when the index is already staged and preserves staged changes', async () => {
+    const fixture = await initWorkerFixture();
+    await writeFile(join(fixture.cwd, 'pre-staged.txt'), 'already staged\n', 'utf-8');
+    execFileSync('git', ['add', 'pre-staged.txt'], { cwd: fixture.cwd, stdio: 'ignore' });
+    await writeFile(join(fixture.cwd, 'unstaged.txt'), 'new work\n', 'utf-8');
+
+    const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
+    const staged = execFileSync('git', ['diff', '--name-only', '--cached'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim().split('\n').filter(Boolean);
+    const status = execFileSync('git', ['status', '--porcelain=v1', '-uall'], { cwd: fixture.cwd, encoding: 'utf-8' });
+
+    assert.equal(result.status, 'skipped');
+    assert.equal(result.reason, 'index_not_clean');
+    assert.deepEqual(staged, ['pre-staged.txt']);
+    assert.match(status, /\?\? unstaged\.txt/);
+  });
+
+  it('unstages checkpointable paths when checkpoint commit fails after staging', async () => {
+    const fixture = await initWorkerFixture();
+    const hookPath = join(fixture.cwd, '.git', 'hooks', 'prepare-commit-msg');
+    await writeFile(hookPath, '#!/bin/sh\nexit 42\n', 'utf-8');
+    await chmod(hookPath, 0o755);
+    await writeFile(join(fixture.cwd, 'commit-fail.txt'), 'must not remain staged\n', 'utf-8');
+
+    const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
+    const staged = execFileSync('git', ['diff', '--name-only', '--cached'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    const status = execFileSync('git', ['status', '--porcelain=v1', '-uall'], { cwd: fixture.cwd, encoding: 'utf-8' });
+
+    assert.equal(result.status, 'skipped');
+    assert.match(result.reason ?? '', /^git_commit_failed:/);
+    assert.equal(staged, '');
+    assert.match(status, /\?\? commit-fail\.txt/);
+  });
+
+  it('exports canonical dedupe and protected-path helpers for fallback suppression', () => {
+    const key = teamWorkerPostToolUseInternals.buildDedupeKey({
+      teamName: 'team',
+      workerName: 'worker-1',
+      workerHeadAfter: 'after',
+      operationKind: 'leader_integration_attempt',
+    });
+    assert.equal(key, 'team|worker-1|after|leader_integration_attempt');
+    assert.equal(teamWorkerPostToolUseInternals.isProtectedCheckpointPath('.omx/state/team/x'), true);
+    assert.equal(teamWorkerPostToolUseInternals.isProtectedCheckpointPath('src/index.ts'), false);
+  });
+
+  it('fails closed for missing worker identity without guessed state writes', async () => {
+    const cwd = await mkdtemp(join(tmpdir(), 'omx-posttooluse-missing-identity-'));
+    const result = await handleTeamWorkerPostToolUseSuccess(successPayload, cwd, {
+      ...process.env,
+      OMX_TEAM_WORKER: 'demo-team/worker-1',
+      OMX_TEAM_STATE_ROOT: join(cwd, '.omx', 'state'),
+    });
+
+    assert.equal(result.handled, false);
+    assert.equal(result.status, 'skipped');
+    assert.equal(existsSync(join(cwd, '.omx', 'state', 'team')), false);
+  });
+});

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

@@ -6,6 +6,9 @@ import { runProcess } from './process-runner.js';
 import { safeString } from './utils.js';
 import { sameFilePath } from '../../utils/paths.js';
 
+const OMX_INSTANCE_OPTION = '@omx_instance_id';
+const OMX_PANE_INSTANCE_OPTION = '@omx_pane_instance_id';
+
 function sanitizeTmuxToken(value: string): string {
   const cleaned = safeString(value)
     .toLowerCase()
@@ -61,6 +64,10 @@ function readNativeSessionId(sessionState: { native_session_id?: unknown; codex_
   return safeString(sessionState.native_session_id || sessionState.codex_session_id || '').trim();
 }
 
+function readAuthoritativeTmuxSessionName(sessionState: { tmux_session_name?: unknown; tmuxSessionName?: unknown }): string {
+  return safeString(sessionState.tmux_session_name || sessionState.tmuxSessionName || '').trim();
+}
+
 function readCurrentTmuxSessionName(): string {
   if (!process.env.TMUX) return '';
   try {
@@ -74,6 +81,54 @@ function readCurrentTmuxSessionName(): string {
   }
 }
 
+async function readTmuxOption(targetValue: string, optionName: string, { pane = false } = {}): Promise<string> {
+  const target = safeString(targetValue).trim();
+  if (!target) return '';
+  const args = ['show-option', '-qv'];
+  if (pane) args.push('-p');
+  args.push('-t', target, optionName);
+  try {
+    const result = await runProcess('tmux', args, 2000);
+    return safeString(result.stdout).trim();
+  } catch {
+    return '';
+  }
+}
+
+async function readTmuxSessionInstanceId(sessionTarget: string): Promise<string> {
+  return readTmuxOption(sessionTarget, OMX_INSTANCE_OPTION);
+}
+
+async function readTmuxPaneInstanceId(paneTarget: string): Promise<string> {
+  return readTmuxOption(paneTarget, OMX_PANE_INSTANCE_OPTION, { pane: true });
+}
+
+function warnPaneInstanceFallback(paneTarget: string): void {
+  const target = safeString(paneTarget).trim();
+  if (!target) return;
+  try {
+    console.warn(`[omx] missing ${OMX_PANE_INSTANCE_OPTION} on ${target}; falling back to ${OMX_INSTANCE_OPTION}`);
+  } catch {
+    // warning is best effort only
+  }
+}
+
+export async function resolveTmuxSessionForInstance(instanceId: string): Promise<string> {
+  const expected = safeString(instanceId).trim();
+  if (!expected) return '';
+  try {
+    const result = await runProcess('tmux', ['list-sessions', '-F', `#{session_name}\t#{${OMX_INSTANCE_OPTION}}`], 2000);
+    const rows = safeString(result.stdout).split('\n').map(line => line.trim()).filter(Boolean);
+    for (const row of rows) {
+      const [sessionName = '', taggedInstanceId = ''] = row.split('\t');
+      if (sessionName && taggedInstanceId === expected) return sessionName;
+    }
+  } catch {
+    // best effort only
+  }
+  return '';
+}
+
 function readParentPid(pid: number): number | null {
   if (!Number.isInteger(pid) || pid <= 1) return null;
   try {
@@ -111,7 +166,11 @@ function processHasAncestorPid(targetPid: number, currentPid = process.pid): boo
   return false;
 }
 
-export async function resolveManagedSessionContext(cwd: string, payload: any, { allowTeamWorker = true } = {}): Promise<any> {
+export async function resolveManagedSessionContext(
+  cwd: string,
+  payload: any,
+  { allowTeamWorker = true, paneTarget = '' }: { allowTeamWorker?: boolean; paneTarget?: string } = {},
+): Promise<any> {
   if (allowTeamWorker && safeString(process.env.OMX_TEAM_WORKER || '').trim() !== '') {
     return {
       managed: true,
@@ -150,15 +209,88 @@ export async function resolveManagedSessionContext(cwd: string, payload: any, {
       return { managed: false, reason: 'session_id_mismatch', invocationSessionId, sessionState, expectedTmuxSessionName: '', currentTmuxSessionName: '' };
     }
     if (isSessionStale(sessionState)) {
-      return { managed: false, reason: 'stale_session', invocationSessionId, sessionState, expectedTmuxSessionName: '', currentTmuxSessionName: '' };
+      return { managed: false, reason: 'stale_session', invocationSessionId, sessionState, expectedTmuxSessionName: '', currentTmuxSessionName: '', taggedTmuxSessionName: '' };
     }
 
     const authoritativeSessionCwd = safeString(sessionState.cwd || cwd).trim() || cwd;
-    const expectedTmuxSessionName = buildExpectedManagedTmuxSessionName(
-      authoritativeSessionCwd,
-      canonicalSessionId || invocationSessionId,
-    );
+    const authoritativeTmuxSessionName = readAuthoritativeTmuxSessionName(sessionState);
+    const expectedTmuxSessionName = authoritativeTmuxSessionName
+      || buildExpectedManagedTmuxSessionName(
+        authoritativeSessionCwd,
+        canonicalSessionId || invocationSessionId,
+      );
     const currentTmuxSessionName = readCurrentTmuxSessionName();
+    const currentTmuxPaneTarget = safeString(paneTarget || process.env.TMUX_PANE || '').trim();
+    const currentTmuxPaneInstanceId = currentTmuxPaneTarget ? await readTmuxPaneInstanceId(currentTmuxPaneTarget) : '';
+    if (currentTmuxPaneInstanceId && currentTmuxPaneInstanceId !== invocationSessionId) {
+      return {
+        managed: false,
+        reason: 'pane_instance_mismatch',
+        invocationSessionId,
+        sessionState,
+        expectedTmuxSessionName,
+        currentTmuxSessionName,
+        currentTmuxPaneTarget,
+        currentTmuxPaneInstanceId,
+        taggedTmuxSessionName: '',
+      };
+    }
+    if (currentTmuxPaneInstanceId === invocationSessionId) {
+      return {
+        managed: true,
+        reason: 'tmux_pane_instance_match',
+        invocationSessionId,
+        sessionState,
+        expectedTmuxSessionName,
+        currentTmuxSessionName,
+        currentTmuxPaneTarget,
+        currentTmuxPaneInstanceId,
+        taggedTmuxSessionName: currentTmuxSessionName,
+      };
+    }
+
+    const currentTmuxInstanceId = currentTmuxSessionName ? await readTmuxSessionInstanceId(currentTmuxSessionName) : '';
+    if (currentTmuxInstanceId && currentTmuxInstanceId !== invocationSessionId) {
+      return {
+        managed: false,
+        reason: 'tmux_instance_mismatch',
+        invocationSessionId,
+        sessionState,
+        expectedTmuxSessionName,
+        currentTmuxSessionName,
+        currentTmuxInstanceId,
+        taggedTmuxSessionName: '',
+      };
+    }
+    if (currentTmuxInstanceId === invocationSessionId) {
+      if (currentTmuxPaneTarget) warnPaneInstanceFallback(currentTmuxPaneTarget);
+      return {
+        managed: true,
+        reason: 'tmux_instance_match',
+        invocationSessionId,
+        sessionState,
+        expectedTmuxSessionName,
+        currentTmuxSessionName,
+        currentTmuxInstanceId,
+        currentTmuxPaneTarget,
+        paneInstanceWarning: 'missing_pane_instance_tag_session_fallback',
+        taggedTmuxSessionName: currentTmuxSessionName,
+      };
+    }
+
+    const taggedTmuxSessionName = await resolveTmuxSessionForInstance(invocationSessionId);
+    if (taggedTmuxSessionName) {
+      return {
+        managed: true,
+        reason: 'tmux_instance_tag_match',
+        invocationSessionId,
+        sessionState,
+        expectedTmuxSessionName,
+        currentTmuxSessionName,
+        taggedTmuxSessionName,
+      };
+    }
+
     if (currentTmuxSessionName && currentTmuxSessionName === expectedTmuxSessionName) {
       return {
         managed: true,
@@ -171,6 +303,19 @@ export async function resolveManagedSessionContext(cwd: string, payload: any, {
         currentTmuxSessionName,
       };
     }
+    if (authoritativeTmuxSessionName && currentTmuxSessionName) {
+      return {
+        managed: false,
+        reason: 'tmux_session_mismatch',
+        invocationSessionId,
+        canonicalSessionId,
+        nativeSessionId,
+        sessionState,
+        expectedTmuxSessionName,
+        currentTmuxSessionName,
+        taggedTmuxSessionName: '',
+      };
+    }
 
     if (processHasAncestorPid(sessionState.pid)) {
       return {
@@ -182,6 +327,7 @@ export async function resolveManagedSessionContext(cwd: string, payload: any, {
         sessionState,
         expectedTmuxSessionName,
         currentTmuxSessionName: '',
+        taggedTmuxSessionName: '',
       };
     }
 
@@ -194,6 +340,7 @@ export async function resolveManagedSessionContext(cwd: string, payload: any, {
       sessionState,
       expectedTmuxSessionName,
       currentTmuxSessionName,
+      taggedTmuxSessionName: '',
     };
   } catch {
     return {
@@ -203,6 +350,7 @@ export async function resolveManagedSessionContext(cwd: string, payload: any, {
       sessionState: null,
       expectedTmuxSessionName: '',
       currentTmuxSessionName: '',
+      taggedTmuxSessionName: '',
     };
   }
 }
@@ -218,7 +366,7 @@ export async function verifyManagedPaneTarget(paneId: string, cwd: string, paylo
     return { ok: false, reason: 'missing_pane_target', paneTarget: '' };
   }
 
-  const managedContext = await resolveManagedSessionContext(cwd, payload, { allowTeamWorker });
+  const managedContext = await resolveManagedSessionContext(cwd, payload, { allowTeamWorker, paneTarget });
   if (!managedContext.managed) {
     return { ok: false, reason: managedContext.reason || 'unmanaged_session', paneTarget, managedContext };
   }
@@ -238,10 +386,49 @@ export async function verifyManagedPaneTarget(paneId: string, cwd: string, paylo
     if (!paneSessionName) {
       return { ok: false, reason: 'pane_session_missing', paneTarget, managedContext };
     }
+    const paneInstanceId = await readTmuxPaneInstanceId(paneTarget);
+    const sessionInstanceId = paneInstanceId ? '' : await readTmuxSessionInstanceId(paneSessionName);
+    if (paneInstanceId && paneInstanceId !== managedContext.invocationSessionId) {
+      return { ok: false, reason: 'pane_instance_mismatch', paneTarget, paneSessionName, paneInstanceId, managedContext };
+    }
+    if (!paneInstanceId && sessionInstanceId) {
+      warnPaneInstanceFallback(paneTarget);
+      if (sessionInstanceId !== managedContext.invocationSessionId) {
+        return {
+          ok: false,
+          reason: 'pane_instance_mismatch',
+          paneTarget,
+          paneSessionName,
+          paneInstanceId: sessionInstanceId,
+          paneInstanceWarning: 'missing_pane_instance_tag_session_fallback',
+          managedContext,
+        };
+      }
+    }
     if (paneSessionName !== expectedSession) {
+      const taggedSession = safeString(managedContext.taggedTmuxSessionName).trim();
+      if (taggedSession && paneSessionName === taggedSession) {
+        return {
+          ok: true,
+          reason: 'ok',
+          paneTarget,
+          paneSessionName,
+          paneInstanceId: paneInstanceId || sessionInstanceId,
+          paneInstanceWarning: paneInstanceId ? '' : 'missing_pane_instance_tag_session_fallback',
+          managedContext,
+        };
+      }
       return { ok: false, reason: 'pane_not_managed_session', paneTarget, paneSessionName, managedContext };
     }
-    return { ok: true, reason: 'ok', paneTarget, paneSessionName, managedContext };
+    return {
+      ok: true,
+      reason: 'ok',
+      paneTarget,
+      paneSessionName,
+      paneInstanceId: paneInstanceId || sessionInstanceId,
+      paneInstanceWarning: paneInstanceId ? '' : 'missing_pane_instance_tag_session_fallback',
+      managedContext,
+    };
   } catch {
     return { ok: false, reason: 'pane_session_lookup_failed', paneTarget, managedContext };
   }
@@ -334,7 +521,7 @@ export async function resolveManagedCurrentPane(cwd: string, payload: any, { all
 export async function resolveManagedSessionPane(cwd: string, payload: any): Promise<string> {
   const managedContext = await resolveManagedSessionContext(cwd, payload, { allowTeamWorker: false });
   if (!managedContext.managed) return '';
-  const expectedSession = safeString(managedContext.expectedTmuxSessionName).trim();
+  const expectedSession = safeString(managedContext.taggedTmuxSessionName || managedContext.expectedTmuxSessionName).trim();
   if (!expectedSession) return '';
 
   try {

package/src/scripts/notify-hook/process-runner.ts

@@ -6,7 +6,11 @@ import { spawn } from 'child_process';
 
 export function runProcess(command: string, args: string[], timeoutMs = 3000): Promise<{ stdout: string; stderr: string; code: number | null }> {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    const usingTestTmux = command === 'tmux' && process.env.OMX_TEST_TMUX_BIN;
+    const relaxingTestTmuxTimeout = command === 'tmux' && process.env.OMX_TEST_RELAX_TMUX_TIMEOUT === '1';
+    const executable = usingTestTmux ? process.env.OMX_TEST_TMUX_BIN as string : command;
+    const effectiveTimeoutMs = usingTestTmux || relaxingTestTmuxTimeout ? Math.max(timeoutMs, 10_000) : timeoutMs;
+    const child = spawn(executable, args, { stdio: ['ignore', 'pipe', 'pipe'] });
     let stdout = '';
     let stderr = '';
     let finished = false;
@@ -15,8 +19,8 @@ export function runProcess(command: string, args: string[], timeoutMs = 3000): P
       if (finished) return;
       finished = true;
       child.kill('SIGTERM');
-      reject(new Error(`timeout after ${timeoutMs}ms`));
-    }, timeoutMs);
+      reject(new Error(`timeout after ${effectiveTimeoutMs}ms`));
+    }, effectiveTimeoutMs);
 
     child.stdout.on('data', (chunk: Buffer) => {
       stdout += chunk.toString();