oh-my-codex 0.20.1 → 0.20.3

package/dist/scripts/notify-hook.js

@@ -19,16 +19,19 @@
 import { writeFile, appendFile, mkdir, readFile } from 'fs/promises';
 import { existsSync } from 'fs';
 import { dirname, join, resolve } from 'path';
-import { isSessionStateUsable } from '../hooks/session.js';
+import { fileURLToPath } from 'url';
+import { appendPromptSessionProvenanceRejection, isSessionStateUsable, readSessionPointer, normalizeSessionId, resolveSessionPointerContext, } from '../hooks/session.js';
+import { evaluateResolvedPromptTurn, extractSelectedTargetOwnerEvidence, preflightSelectedTargetOwner, } from '../hooks/prompt-session-provenance.js';
+import { readTeamModeConfig } from '../config/team-mode.js';
 import { safeString, asNumber } from './notify-hook/utils.js';
 import { getSessionTokenUsage, getQuotaUsage, normalizeInputMessages, } from './notify-hook/payload-parser.js';
 import { getBaseStateDir } from '../mcp/state-paths.js';
-import { getScopedStatePath, readCurrentSessionId, readScopedJsonIfExists, getScopedStateDirsForCurrentSession, normalizeNotifyState, pruneRecentTurns, readdir, } from './notify-hook/state-io.js';
+import { getScopedStatePath, getScopedStatePathAtScope, readScopedJsonAtScope, hasExistingScopedSessionDir, readCurrentSessionId, readScopedJsonIfExists, getScopedStateDirsForCurrentSession, normalizeNotifyState, pruneRecentTurns, readdir, } from './notify-hook/state-io.js';
 import { isLeaderStale, resolveLeaderStalenessThresholdMs, maybeNudgeTeamLeader } from './notify-hook/team-leader-nudge.js';
 import { drainPendingTeamDispatch } from './notify-hook/team-dispatch.js';
 import { handleTmuxInjection } from './notify-hook/tmux-injection.js';
 import { maybeAutoNudge, resolveNudgePaneTarget, isDeepInterviewStateActive, isDeepInterviewInputLockActive, syncSkillStateFromTurn, } from './notify-hook/auto-nudge.js';
-import { isManagedOmxSession } from './notify-hook/managed-tmux.js';
+import { isManagedOmxSessionAtPromptContext } from './notify-hook/managed-tmux.js';
 import { logNotifyHookEvent } from './notify-hook/log.js';
 import { reconcileRalphSessionResume } from './notify-hook/ralph-session-resume.js';
 import { sendPaneInput } from './notify-hook/team-tmux-guard.js';
@@ -37,6 +40,7 @@ import { parseTeamWorkerEnv, resolveTeamStateDirForWorker, updateWorkerHeartbeat
 import { DEFAULT_MARKER } from './tmux-hook-engine.js';
 import { sameFilePath } from '../utils/paths.js';
 import { MAX_NOTIFY_ARGV_JSON_BYTES, extractRawJsonStringField, utf8ByteLength, } from './hook-payload-guard.js';
+import { classifyKeywordInput, recordSkillActivation, } from '../hooks/keyword-detector.js';
 const RALPH_ACTIVE_PROGRESS_PHASES = new Set([
     'start',
     'started',
@@ -51,6 +55,8 @@ const RALPH_ACTIVE_PROGRESS_PHASES = new Set([
     'fixing',
 ]);
 const IDLE_NOTIFICATION_SUMMARY_MAX_LENGTH = 240;
+const NOTIFY_SKILL_ACTIVATION_ERROR_MAX_LENGTH = 512;
+const NOTIFY_SKILL_ACTIVATION_CONTEXT_MAX_LENGTH = 200;
 async function readJsonFileIfObject(path) {
     try {
         const raw = await readFile(path, 'utf-8');
@@ -227,13 +233,6 @@ function classifyIdleNotificationPhase(message) {
     }
     return 'idle';
 }
-function isExplicitAutopilotActivationText(text) {
-    return /(?:^|[^\w])\$autopilot\b/i.test(text)
-        || /^\s*\/autopilot\b/i.test(text)
-        || /^\s*(?:please\s+)?autopilot(?:\s+(?:this|mode|workflow|skill|loop|now))?\s*[.!]?\s*$/i.test(text)
-        || /\b(?:use|run|start|enable|launch|invoke|activate|resume|continue)\s+(?:the\s+)?autopilot(?:\s+(?:mode|workflow|skill|loop|now))?\s*[.!]?\s*$/i.test(text)
-        || /\bautopilot\s+(?:mode|workflow|skill|loop)\b/i.test(text);
-}
 function looksLikeAutopilotTerminalHandoff(text) {
     return /\bAutopilot complete\b/i.test(text)
         || /\btask_complete\b/i.test(text)
@@ -281,6 +280,72 @@ async function shouldSuppressAutopilotTerminalReplayActivation(stateDir, payload
         return false;
     return hasTerminalAutopilotStateForNotifyTurn(stateDir, sessionId, payload);
 }
+function boundedNotifySkillActivationContext(value) {
+    try {
+        const context = safeString(value).trim().slice(0, NOTIFY_SKILL_ACTIVATION_CONTEXT_MAX_LENGTH);
+        return context || null;
+    }
+    catch {
+        return null;
+    }
+}
+function boundedNotifySkillActivationError(error) {
+    try {
+        const message = error instanceof Error ? error.message : String(error);
+        return message.slice(0, NOTIFY_SKILL_ACTIVATION_ERROR_MAX_LENGTH);
+    }
+    catch {
+        return 'unknown_error';
+    }
+}
+async function logNotifySkillActivationFailure(logsDir, input, error) {
+    await logNotifyHookEvent(logsDir, {
+        timestamp: new Date().toISOString(),
+        level: 'warn',
+        type: 'notify_skill_activation_failure',
+        error: boundedNotifySkillActivationError(error),
+        session_id: boundedNotifySkillActivationContext(input.sessionId),
+        thread_id: boundedNotifySkillActivationContext(input.threadId),
+        turn_id: boundedNotifySkillActivationContext(input.turnId),
+    }).catch(() => { });
+}
+/**
+ * Records prompt skill activation using one shared input classification for the
+ * terminal-replay check and the state writer.
+ */
+export async function recordNotifySkillActivation(input, dependencies = {}) {
+    const classification = (dependencies.classifyKeywordInput ?? classifyKeywordInput)(input.text);
+    const teamEnabled = readTeamModeConfig(input.sourceCwd).enabled;
+    const runtimeMatches = teamEnabled
+        ? classification.matches
+        : classification.matches.filter((match) => match.skill !== 'team');
+    const terminalAutopilotReplay = await shouldSuppressAutopilotTerminalReplayActivation(input.stateDir, input.payload, runtimeMatches.some((match) => match.skill === 'autopilot'), input.sessionId || '');
+    if (terminalAutopilotReplay && runtimeMatches[0]?.skill === 'autopilot')
+        return null;
+    return (dependencies.recordSkillActivation ?? recordSkillActivation)({
+        stateDir: input.stateDir,
+        sourceCwd: input.sourceCwd,
+        text: input.text,
+        sessionId: input.sessionId,
+        threadId: input.threadId,
+        turnId: input.turnId,
+        nowIso: input.nowIso,
+        classification,
+        allowSecondaryAutopilot: !terminalAutopilotReplay,
+    });
+}
+/**
+ * Non-fatal notify-hook boundary for shared classification and state writes.
+ */
+export async function recordNotifySkillActivationNonFatal(input, logsDir, dependencies = {}) {
+    try {
+        return await recordNotifySkillActivation(input, dependencies);
+    }
+    catch (error) {
+        await logNotifySkillActivationFailure(logsDir, input, error);
+        return null;
+    }
+}
 function buildIdleNotificationFingerprint(payload) {
     const lastAssistantMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
     const summary = summarizeIdleNotificationMessage(lastAssistantMessage);
@@ -300,6 +365,70 @@ function isNotifyFallbackTaskCompletePayload(payload) {
         return false;
     return normalizeInputMessages(payload).some((message) => (message.includes('[notify-fallback] synthesized from rollout task_complete')));
 }
+async function preflightLeaderNotifyTarget(stateDir, context) {
+    if (context.status !== 'authorized')
+        return context;
+    const scope = {
+        targetSessionId: context.authorization.targetSessionId,
+        ownerCodexSessionId: context.authorization.ownerCodexSessionId,
+        allowedStorageSessionIds: context.authorization.allowedStorageSessionIds,
+    };
+    const probePath = await getScopedStatePathAtScope(stateDir, 'prompt-provenance-probe.json', scope);
+    const targetDir = dirname(probePath);
+    const evidence = [];
+    let filenames;
+    try {
+        filenames = await readdir(targetDir);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return context;
+        return preflightSelectedTargetOwner(context, [{ ownerCodexSessionId: {} }], 'notify', new Date().toISOString());
+    }
+    for (const filename of filenames) {
+        if (!filename.endsWith('-state.json') && filename !== 'skill-active-state.json')
+            continue;
+        try {
+            const value = JSON.parse(await readFile(join(targetDir, filename), 'utf8'));
+            evidence.push(...extractSelectedTargetOwnerEvidence(value));
+        }
+        catch {
+            evidence.push({ ownerCodexSessionId: {} });
+        }
+    }
+    return preflightSelectedTargetOwner(context, evidence, 'notify', new Date().toISOString());
+}
+async function resolveLeaderNotifyWriteDecision(cwd, stateDir, payloadSessionId) {
+    const pointerContext = resolveSessionPointerContext(cwd);
+    const selectedPointer = await readSessionPointer(pointerContext);
+    const ownerEnvSessionId = process.env.OMX_SESSION_ID;
+    const normalizedOwnerEnvSessionId = normalizeSessionId(ownerEnvSessionId);
+    const forkScopeExists = normalizedOwnerEnvSessionId
+        ? await hasExistingScopedSessionDir(stateDir, normalizedOwnerEnvSessionId)
+        : false;
+    const context = evaluateResolvedPromptTurn({
+        producer: 'notify',
+        payloadSessionId,
+        ownerEnvSessionId,
+        selectedPointer,
+        forkScopeExists,
+        nowIso: new Date().toISOString(),
+    });
+    const preflightedContext = await preflightLeaderNotifyTarget(stateDir, context);
+    if (preflightedContext.status !== 'authorized')
+        return { context: preflightedContext, pointerContext };
+    if (context.status !== 'authorized')
+        return { context, pointerContext };
+    return {
+        context: preflightedContext,
+        pointerContext,
+        scope: {
+            targetSessionId: preflightedContext.authorization.targetSessionId,
+            ownerCodexSessionId: preflightedContext.authorization.ownerCodexSessionId,
+            allowedStorageSessionIds: preflightedContext.authorization.allowedStorageSessionIds,
+        },
+    };
+}
 async function main() {
     const rawPayload = process.argv[process.argv.length - 1];
     if (!rawPayload || rawPayload.startsWith('-')) {
@@ -319,7 +448,8 @@ async function main() {
     if (!(await isOmxManagedCwd(cwd))) {
         process.exit(0);
     }
-    const payloadSessionId = safeString(payload.session_id || payload['session-id'] || '');
+    const rawPayloadSessionId = payload.session_id ?? payload['session-id'];
+    const payloadSessionId = safeString(rawPayloadSessionId);
     const payloadThreadId = safeString(payload['thread-id'] || payload.thread_id || '');
     const inputMessages = normalizeInputMessages(payload);
     const latestUserInput = safeString(inputMessages.length > 0 ? inputMessages[inputMessages.length - 1] : '');
@@ -336,43 +466,65 @@ async function main() {
     const stateDir = resolvedWorkerStateDir || getBaseStateDir(cwd);
     const logsDir = join(cwd, '.omx', 'logs');
     const omxDir = join(cwd, '.omx');
-    let currentOmxSessionId = '';
+    const leaderWriteDecision = isTeamWorker
+        ? null
+        : await resolveLeaderNotifyWriteDecision(cwd, stateDir, rawPayloadSessionId);
+    if (!isTeamWorker && leaderWriteDecision?.context.status === 'rejected') {
+        await appendPromptSessionProvenanceRejection(leaderWriteDecision.pointerContext, leaderWriteDecision.context.diagnostic).catch(() => { });
+        return;
+    }
+    if (!isTeamWorker && leaderWriteDecision?.context.status === 'suppressed-target-child')
+        return;
+    const leaderAuthorization = leaderWriteDecision?.context.status === 'authorized'
+        ? leaderWriteDecision.context.authorization
+        : null;
+    const canWriteLeaderScopedState = Boolean(leaderWriteDecision?.scope && leaderAuthorization);
+    let currentOmxSessionId = isTeamWorker
+        ? ''
+        : leaderWriteDecision?.scope?.targetSessionId || '';
     const getEffectiveSessionId = () => currentOmxSessionId || payloadSessionId;
     // Ensure directories exist
     await mkdir(logsDir, { recursive: true }).catch(() => { });
-    if (workerStateRootResolved) {
+    if (isTeamWorker && workerStateRootResolved) {
         await mkdir(stateDir, { recursive: true }).catch(() => { });
         currentOmxSessionId = await readCurrentSessionId(stateDir).catch(() => '') || '';
     }
     // Turn-level dedupe prevents double-processing when native notify and fallback
     // watcher both emit the same completed turn.
-    try {
-        if (!workerStateRootResolved)
-            throw new Error('worker_state_root_unresolved');
-        const turnId = safeString(payload['turn-id'] || payload.turn_id || '');
-        if (turnId) {
-            const now = Date.now();
-            const threadId = safeString(payload['thread-id'] || payload.thread_id || '');
-            const eventType = safeString(payload.type || 'agent-turn-complete');
-            const key = `${threadId || 'no-thread'}|${turnId}|${eventType}`;
-            const dedupeSessionId = getEffectiveSessionId();
-            const dedupeStatePath = await getScopedStatePath(stateDir, 'notify-hook-state.json', dedupeSessionId);
-            const dedupeState = normalizeNotifyState(await readScopedJsonIfExists(stateDir, 'notify-hook-state.json', dedupeSessionId, null));
-            dedupeState.recent_turns = pruneRecentTurns(dedupeState.recent_turns, now);
-            if (dedupeState.recent_turns[key]) {
-                process.exit(0);
+    if (isTeamWorker || canWriteLeaderScopedState) {
+        try {
+            if (!workerStateRootResolved)
+                throw new Error('worker_state_root_unresolved');
+            const turnId = safeString(payload['turn-id'] || payload.turn_id || '');
+            if (turnId) {
+                const now = Date.now();
+                const threadId = safeString(payload['thread-id'] || payload.thread_id || '');
+                const eventType = safeString(payload.type || 'agent-turn-complete');
+                const key = `${threadId || 'no-thread'}|${turnId}|${eventType}`;
+                const dedupeSessionId = getEffectiveSessionId();
+                const scope = leaderWriteDecision?.scope;
+                const dedupeStatePath = scope
+                    ? await getScopedStatePathAtScope(stateDir, 'notify-hook-state.json', scope)
+                    : await getScopedStatePath(stateDir, 'notify-hook-state.json', dedupeSessionId);
+                const dedupeState = normalizeNotifyState(scope
+                    ? await readScopedJsonAtScope(stateDir, 'notify-hook-state.json', scope, null)
+                    : await readScopedJsonIfExists(stateDir, 'notify-hook-state.json', dedupeSessionId, null));
+                dedupeState.recent_turns = pruneRecentTurns(dedupeState.recent_turns, now);
+                if (dedupeState.recent_turns[key]) {
+                    process.exit(0);
+                }
+                dedupeState.recent_turns[key] = now;
+                dedupeState.last_event_at = new Date().toISOString();
+                await mkdir(dirname(dedupeStatePath), { recursive: true }).catch(() => { });
+                await writeFile(dedupeStatePath, JSON.stringify(dedupeState, null, 2)).catch(() => { });
             }
-            dedupeState.recent_turns[key] = now;
-            dedupeState.last_event_at = new Date().toISOString();
-            await mkdir(dirname(dedupeStatePath), { recursive: true }).catch(() => { });
-            await writeFile(dedupeStatePath, JSON.stringify(dedupeState, null, 2)).catch(() => { });
         }
-    }
-    catch {
-        // Non-critical
+        catch {
+            // Non-critical
+        }
     }
     // 0.5. Track leader + native subagent thread activity (lead session only)
-    if (!isTeamWorker) {
+    if (!isTeamWorker && canWriteLeaderScopedState) {
         try {
             const threadId = safeString(payload['thread-id'] || payload.thread_id || '');
             const turnId = safeString(payload['turn-id'] || payload.turn_id || '');
@@ -444,14 +596,22 @@ async function main() {
     }
     // Reconcile Ralph ownership for same-Codex-session continuation before
     // lifecycle counters or injection read the active scope.
-    if (!isTeamWorker) {
+    if (!isTeamWorker && canWriteLeaderScopedState) {
         try {
             const resumeResult = await reconcileRalphSessionResume({
                 stateDir,
-                payloadSessionId,
+                authorization: leaderAuthorization,
+                env: {
+                    ...process.env,
+                    OMX_SESSION_ID: leaderAuthorization.targetSessionId,
+                    CODEX_SESSION_ID: '',
+                    SESSION_ID: '',
+                },
                 payloadThreadId,
             });
-            currentOmxSessionId = resumeResult.currentOmxSessionId;
+            if (resumeResult.currentOmxSessionId && resumeResult.currentOmxSessionId === leaderAuthorization.targetSessionId) {
+                currentOmxSessionId = resumeResult.currentOmxSessionId;
+            }
             if (resumeResult.resumed || resumeResult.updatedCurrentOwner) {
                 await logNotifyHookEvent(logsDir, {
                     timestamp: new Date().toISOString(),
@@ -478,9 +638,9 @@ async function main() {
     }
     // 2. Update active mode state (increment iteration)
     // GUARD: Skip when running inside a team worker to prevent state corruption
-    if (!isTeamWorker) {
+    if (!isTeamWorker && canWriteLeaderScopedState) {
         try {
-            const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir);
+            const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir, getEffectiveSessionId());
             for (const scopedDir of scopedDirs) {
                 const stateFiles = await readdir(scopedDir).catch(() => []);
                 for (const f of stateFiles) {
@@ -608,11 +768,13 @@ async function main() {
         }
     }
     // 4. Write HUD state summary for `omx hud` (lead session only)
-    if (!isTeamWorker) {
+    if (!isTeamWorker && canWriteLeaderScopedState) {
         try {
-            const scopedSessionId = getEffectiveSessionId();
-            const hudStatePath = await getScopedStatePath(stateDir, 'hud-state.json', scopedSessionId);
-            let hudState = await readScopedJsonIfExists(stateDir, 'hud-state.json', scopedSessionId, {
+            const scope = leaderWriteDecision?.scope;
+            if (!scope)
+                return;
+            const hudStatePath = await getScopedStatePathAtScope(stateDir, 'hud-state.json', scope);
+            let hudState = await readScopedJsonAtScope(stateDir, 'hud-state.json', scope, {
                 last_turn_at: '',
                 turn_count: 0,
             });
@@ -641,35 +803,36 @@ async function main() {
             // Non-critical: heartbeat write failure should never block the hook
         }
     }
+    let skillSyncResult = null;
     // 4.45. Skill activation tracking: update skill-active-state.json before any nudge logic.
-    try {
-        const { detectKeywords, recordSkillActivation } = await import('../hooks/keyword-detector.js');
+    if (isTeamWorker || canWriteLeaderScopedState) {
         if (latestUserInput) {
-            const activationSessionId = getEffectiveSessionId();
-            const isAutopilotActivation = detectKeywords(latestUserInput)
-                .some((match) => match.skill === 'autopilot')
-                || isExplicitAutopilotActivationText(latestUserInput);
-            const suppressTerminalReplay = await shouldSuppressAutopilotTerminalReplayActivation(stateDir, payload, isAutopilotActivation, activationSessionId);
-            if (!suppressTerminalReplay) {
-                await recordSkillActivation({
-                    stateDir,
-                    sourceCwd: cwd,
-                    text: latestUserInput,
-                    sessionId: activationSessionId,
-                    threadId: payloadThreadId,
-                    turnId: safeString(payload['turn-id'] || payload.turn_id || ''),
-                });
-            }
+            await recordNotifySkillActivationNonFatal({
+                stateDir,
+                sourceCwd: cwd,
+                text: latestUserInput,
+                sessionId: getEffectiveSessionId(),
+                threadId: payloadThreadId,
+                turnId: safeString(payload['turn-id'] || payload.turn_id || ''),
+                payload,
+            }, logsDir, {
+                recordSkillActivation: async (input) => recordSkillActivation({
+                    ...input,
+                    ...(!isTeamWorker && leaderWriteDecision ? {
+                        resolvedPromptTurnContext: leaderWriteDecision.context,
+                        onProvenanceRejected: async (diagnostic) => {
+                            await appendPromptSessionProvenanceRejection(leaderWriteDecision.pointerContext, diagnostic).catch(() => { });
+                        },
+                    } : {}),
+                }),
+            });
+        }
+        try {
+            skillSyncResult = await syncSkillStateFromTurn(stateDir, payload, !isTeamWorker && leaderAuthorization ? leaderAuthorization.targetSessionId : '', !isTeamWorker ? leaderAuthorization : null);
+        }
+        catch {
+            // Non-fatal: lifecycle sync should not block the hook
         }
-    }
-    catch {
-        // Non-fatal: keyword detector module may not be built yet
-    }
-    try {
-        await syncSkillStateFromTurn(stateDir, payload);
-    }
-    catch {
-        // Non-fatal: lifecycle sync should not block the hook
     }
     const effectiveSessionId = getEffectiveSessionId();
     const deepInterviewStateActive = effectiveSessionId
@@ -696,16 +859,16 @@ async function main() {
     }
     // 5. Optional tmux prompt injection workaround (non-fatal, opt-in)
     // Skip for team workers - only the lead should inject prompts
-    if (!isTeamWorker) {
+    if (!isTeamWorker && canWriteLeaderScopedState) {
         try {
-            await handleTmuxInjection({ payload, cwd, stateDir, logsDir });
+            await handleTmuxInjection({ payload, cwd, stateDir, logsDir, context: leaderWriteDecision.context });
         }
         catch {
             // Non-critical
         }
     }
     // 5.5. Opportunistic team dispatch drain (leader session only).
-    if (!isTeamWorker) {
+    if (!isTeamWorker && canWriteLeaderScopedState) {
         try {
             await drainPendingTeamDispatch({ cwd, stateDir, logsDir, maxPerTick: 5 });
         }
@@ -714,7 +877,7 @@ async function main() {
         }
     }
     // 6. Team leader nudge (lead session only): remind the leader to check teammate/mailbox state.
-    if (!isTeamWorker && !deepInterviewStateActive) {
+    if (!isTeamWorker && canWriteLeaderScopedState && !deepInterviewStateActive) {
         try {
             await maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputedLeaderStale });
         }
@@ -783,17 +946,20 @@ async function main() {
             const { shouldSendIdleNotification, recordIdleNotificationSent, shouldSendSessionIdleHookEvent, recordSessionIdleHookEventSent, } = await import('../notifications/idle-cooldown.js');
             const idleFingerprint = buildIdleNotificationFingerprint(payload);
             const notifySessionId = getEffectiveSessionId();
-            const shouldNotifyLifecycle = notifySessionId
-                && shouldSendIdleNotification(stateDir, notifySessionId, idleFingerprint);
-            const shouldDispatchSessionIdleHookEvent = notifySessionId
+            const shouldNotifyLifecycle = notifySessionId && (!canWriteLeaderScopedState
+                || shouldSendIdleNotification(stateDir, notifySessionId, idleFingerprint));
+            const shouldDispatchSessionIdleHookEvent = canWriteLeaderScopedState
+                && notifySessionId
                 && shouldSendSessionIdleHookEvent(stateDir, notifySessionId, idleFingerprint);
             if (shouldNotifyLifecycle || shouldDispatchSessionIdleHookEvent) {
                 if (shouldNotifyLifecycle) {
                     const idleResult = await notifyLifecycle('session-idle', {
                         sessionId: notifySessionId,
                         projectPath: cwd,
+                    }, undefined, {
+                        persistScopedReceipts: canWriteLeaderScopedState,
                     });
-                    if (idleResult && idleResult.anySuccess) {
+                    if (canWriteLeaderScopedState && idleResult && idleResult.anySuccess) {
                         recordIdleNotificationSent(stateDir, notifySessionId, idleFingerprint);
                     }
                 }
@@ -835,9 +1001,16 @@ async function main() {
     }
     // 9. Auto-nudge: detect Codex stall patterns and automatically send a continuation prompt.
     //    Works for both leader and worker contexts.
-    if (!deepInterviewStateActive || deepInterviewInputLockActive) {
+    if ((isTeamWorker || canWriteLeaderScopedState) && (!deepInterviewStateActive || deepInterviewInputLockActive)) {
         try {
-            await maybeAutoNudge({ cwd, stateDir, logsDir, payload });
+            await maybeAutoNudge({
+                cwd,
+                stateDir,
+                logsDir,
+                payload,
+                context: isTeamWorker ? null : leaderWriteDecision.context,
+                syncResult: skillSyncResult,
+            });
         }
         catch {
             // Non-critical
@@ -854,6 +1027,7 @@ async function main() {
                 logsDir,
                 sessionId: getEffectiveSessionId(),
                 turnId: safeString(payload['turn-id'] || payload.turn_id || ''),
+                persistRuntimeFeedback: canWriteLeaderScopedState,
             });
         }
         catch (err) {
@@ -872,12 +1046,12 @@ async function main() {
     }
     // 10. Code simplifier: delegate recently modified files for simplification.
     //     Opt-in via ~/.omx/config.json: { "codeSimplifier": { "enabled": true } }
-    if (!isTeamWorker) {
+    if (!isTeamWorker && canWriteLeaderScopedState) {
         try {
             const { processCodeSimplifier } = await import('../hooks/code-simplifier/index.js');
             const csResult = processCodeSimplifier(cwd, stateDir);
             if (csResult.triggered) {
-                const managedSession = await isManagedOmxSession(cwd, payload, { allowTeamWorker: false });
+                const managedSession = await isManagedOmxSessionAtPromptContext(cwd, leaderWriteDecision.context, { allowTeamWorker: false });
                 if (!managedSession) {
                     const { logTmuxHookEvent } = await import('./notify-hook/log.js');
                     await logTmuxHookEvent(logsDir, {
@@ -887,11 +1061,12 @@ async function main() {
                     });
                 }
                 else {
-                    const csPaneId = await resolveNudgePaneTarget(stateDir, cwd, payload);
+                    const csPaneId = await resolveNudgePaneTarget(stateDir, cwd, payload, leaderWriteDecision.context);
                     if (csPaneId) {
                         const csText = `${csResult.message} ${DEFAULT_MARKER}`;
                         const sendResult = await sendPaneInput({
                             paneTarget: csPaneId,
+                            exactPaneId: csPaneId,
                             prompt: csText,
                             submitKeyPresses: 2,
                             submitDelayMs: 100,
@@ -941,10 +1116,12 @@ async function logFatalNotifyHookError(err) {
         error: err instanceof Error ? err.message : String(err),
     }) + '\n').catch(() => { });
 }
-main().catch((err) => {
-    // Notify hooks are auxiliary background work. Avoid printing stack traces into
-    // Codex TUI/PowerShell foreground panes; record diagnostics in .omx/logs.
-    process.exitCode = 0;
-    void logFatalNotifyHookError(err);
-});
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    main().catch((err) => {
+        // Notify hooks are auxiliary background work. Avoid printing stack traces into
+        // Codex TUI/PowerShell foreground panes; record diagnostics in .omx/logs.
+        process.exitCode = 0;
+        void logFatalNotifyHookError(err);
+    });
+}
 //# sourceMappingURL=notify-hook.js.map