oh-my-codex-pennix 0.18.13

package/dist/scripts/notify-hook/team-leader-nudge.js

@@ -0,0 +1,1029 @@
+// @ts-nocheck
+/**
+ * Team leader nudge: remind the leader to check teammate/mailbox state.
+ */
+import { readFile, writeFile, mkdir, appendFile, readdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, resolve } from 'path';
+import { readUsableSessionState } from '../../hooks/session.js';
+import { asNumber, safeString, isTerminalPhase } from './utils.js';
+import { readJsonIfExists, getScopedStateDirsForCurrentSession } from './state-io.js';
+import { runProcess } from './process-runner.js';
+import { logTmuxHookEvent } from './log.js';
+import { evaluatePaneInjectionReadiness, queuePaneInput, sendPaneInput } from './team-tmux-guard.js';
+import { resolvePaneTarget } from './tmux-injection.js';
+import { listNotifyCanonicalActiveTeams } from './active-team.js';
+import { classifyLeaderActionState, resolveLeaderNudgeIntent, } from './orchestration-intent.js';
+import { DEFAULT_MARKER, paneHasActiveTask } from '../tmux-hook-engine.js';
+import { isLeaderRuntimeStale } from '../../team/leader-activity.js';
+import { appendTeamDeliveryLog } from '../../team/delivery-log.js';
+import { writeTeamLeaderAttention } from '../../team/state.js';
+import { readLatestTeamProgressEvidenceMs } from '../../team/progress-evidence.js';
+import { validateSessionId } from '../../mcp/state-paths.js';
+import { TEAM_NAME_SAFE_PATTERN } from '../../team/contracts.js';
+import { isDeepInterviewStateActive } from './auto-nudge.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_PANE_SAME_CLASSIFIED_STATE_SUPPRESSED_REASON = 'pane_already_shows_same_classified_state';
+const LEADER_NOTIFICATION_DEFERRED_TYPE = 'leader_notification_deferred';
+const ACK_WITHOUT_START_EVIDENCE_REASON = 'ack_without_start_evidence';
+const ACK_LIKE_PATTERNS = [
+    /^ack(?::\s*[a-z0-9-]+(?:\s+initialized)?)?[.!]*$/i,
+    /^(?:ok|okay|k|roger|copy|received|got it|understood|sounds good)[.!]*$/i,
+    /^(?:on it|will do|i(?:'|')ll do it|working on it)[.!]*$/i,
+];
+function normalizeValidSessionId(value) {
+    const trimmed = safeString(value).trim();
+    if (!trimmed)
+        return '';
+    try {
+        return validateSessionId(trimmed) ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+function normalizeValidTeamName(value) {
+    const trimmed = safeString(value).trim();
+    return TEAM_NAME_SAFE_PATTERN.test(trimmed) ? trimmed : '';
+}
+export function resolveLeaderNudgeIntervalMs() {
+    const raw = safeString(process.env.OMX_TEAM_LEADER_NUDGE_MS || '');
+    const parsed = asNumber(raw);
+    // Default: 30 seconds for stale-leader follow-up. Guard against spam.
+    if (parsed !== null && parsed >= 10_000 && parsed <= 30 * 60_000)
+        return parsed;
+    return 30_000;
+}
+export function resolveLeaderAllIdleNudgeCooldownMs() {
+    const raw = safeString(process.env.OMX_TEAM_LEADER_ALL_IDLE_COOLDOWN_MS || '');
+    const parsed = asNumber(raw);
+    // Default: 30 seconds.
+    if (parsed !== null && parsed >= 5_000 && parsed <= 10 * 60_000)
+        return parsed;
+    return 30_000;
+}
+export function resolveLeaderStalenessThresholdMs() {
+    const raw = safeString(process.env.OMX_TEAM_LEADER_STALE_MS || '');
+    const parsed = asNumber(raw);
+    // Default: 3 minutes. Guard against unreasonable values.
+    if (parsed !== null && parsed >= 10_000 && parsed <= 30 * 60_000)
+        return parsed;
+    return 180_000;
+}
+function buildStatusCheckReminder(teamName) {
+    return `Next: check messages; keep orchestrating; if done, gracefully shut down: omx team shutdown ${teamName}.`;
+}
+function buildMailboxCheckReminder(teamName) {
+    return `Next: read messages; keep orchestrating; if done, gracefully shut down: omx team shutdown ${teamName}.`;
+}
+function buildWorkerStartEvidenceReminder(teamName, workerName) {
+    return `Next: check ${workerName} msg/output, confirm task in omx team status ${teamName}, then reassign/nudge.`;
+}
+function buildLeaderActionGuidance(teamName, { allWorkersIdle = false, workerPanesAlive = false, taskCounts = {}, leaderActionState = 'still_actionable', } = {}) {
+    const pending = Number.isFinite(taskCounts.pending) ? taskCounts.pending : 0;
+    const blocked = Number.isFinite(taskCounts.blocked) ? taskCounts.blocked : 0;
+    const inProgress = Number.isFinite(taskCounts.in_progress) ? taskCounts.in_progress : 0;
+    const pendingFollowUpTasks = allWorkersIdle && pending > 0 && blocked === 0 && inProgress === 0;
+    if (pendingFollowUpTasks) {
+        return workerPanesAlive
+            ? 'Next: assign the next follow-up task to this idle team.'
+            : 'Next: launch a new team for the next task set.';
+    }
+    if (leaderActionState === 'done_waiting_on_leader') {
+        return `Next: decide whether to reconcile/merge results or gracefully shut down: omx team shutdown ${teamName}.`;
+    }
+    if (leaderActionState === 'stuck_waiting_on_leader') {
+        return `Next: omx team status ${teamName}; read worker messages; unblock/reassign or shutdown.`;
+    }
+    return buildStatusCheckReminder(teamName);
+}
+function buildIdleContextText(teamName, { allWorkersIdle = false, workerPanesAlive = false, taskCounts = {}, leaderActionState = 'still_actionable', } = {}) {
+    const pending = Number.isFinite(taskCounts.pending) ? taskCounts.pending : 0;
+    const blocked = Number.isFinite(taskCounts.blocked) ? taskCounts.blocked : 0;
+    const inProgress = Number.isFinite(taskCounts.in_progress) ? taskCounts.in_progress : 0;
+    const pendingFollowUpTasks = allWorkersIdle && pending > 0 && blocked === 0 && inProgress === 0;
+    if (pendingFollowUpTasks) {
+        return workerPanesAlive
+            ? ` Team ${teamName} has idle workers ready.`
+            : ` Team ${teamName} has follow-up work ready.`;
+    }
+    if (leaderActionState === 'done_waiting_on_leader') {
+        return ` Team ${teamName} looks complete.`;
+    }
+    if (leaderActionState === 'stuck_waiting_on_leader') {
+        return ` Team ${teamName} needs leader review.`;
+    }
+    return '';
+}
+export async function checkWorkerPanesAlive(tmuxTarget, workerPaneIds = []) {
+    const sessionName = tmuxTarget.split(':')[0];
+    try {
+        const result = await runProcess('tmux', ['list-panes', '-t', sessionName, '-F', '#{pane_id} #{pane_pid}'], 2000);
+        const lines = (result.stdout || '')
+            .split('\n')
+            .map(l => l.trim())
+            .filter(Boolean);
+        const workerPaneIdSet = new Set(Array.isArray(workerPaneIds)
+            ? workerPaneIds.map((paneId) => safeString(paneId).trim()).filter(Boolean)
+            : []);
+        const relevantLines = workerPaneIdSet.size > 0
+            ? lines.filter((line) => workerPaneIdSet.has(line.split(/\s+/, 1)[0] || ''))
+            : lines;
+        return { alive: relevantLines.length > 0, paneCount: relevantLines.length };
+    }
+    catch {
+        return { alive: false, paneCount: 0 };
+    }
+}
+export async function isLeaderStale(stateDir, thresholdMs, nowMs) {
+    return isLeaderRuntimeStale(stateDir, thresholdMs, nowMs);
+}
+function resolveTerminalAtFromPhaseDoc(parsed, fallbackIso) {
+    const transitions = Array.isArray(parsed && parsed.transitions) ? parsed.transitions : [];
+    for (let idx = transitions.length - 1; idx >= 0; idx -= 1) {
+        const at = safeString(transitions[idx] && transitions[idx].at).trim();
+        if (at)
+            return at;
+    }
+    const updatedAt = safeString(parsed && parsed.updated_at).trim();
+    return updatedAt || fallbackIso;
+}
+async function readTeamPhaseSnapshot(stateDir, teamName, nowIso) {
+    const phasePath = join(stateDir, 'team', teamName, 'phase.json');
+    try {
+        if (!existsSync(phasePath))
+            return { currentPhase: '', terminal: false, completedAt: '' };
+        const parsed = JSON.parse(await readFile(phasePath, 'utf-8'));
+        const currentPhase = safeString(parsed && parsed.current_phase).trim();
+        return {
+            currentPhase,
+            terminal: isTerminalPhase(currentPhase),
+            completedAt: resolveTerminalAtFromPhaseDoc(parsed, nowIso),
+        };
+    }
+    catch {
+        return { currentPhase: '', terminal: false, completedAt: '' };
+    }
+}
+async function syncScopedTeamStateFromPhase(teamStatePath, teamName, phaseSnapshot, nowIso) {
+    if (!phaseSnapshot || !phaseSnapshot.terminal)
+        return false;
+    try {
+        if (!existsSync(teamStatePath))
+            return false;
+        const parsed = JSON.parse(await readFile(teamStatePath, 'utf-8'));
+        if (!parsed || safeString(parsed.team_name).trim() !== teamName)
+            return false;
+        let changed = false;
+        if (parsed.active !== false) {
+            parsed.active = false;
+            changed = true;
+        }
+        if (safeString(parsed.current_phase).trim() !== phaseSnapshot.currentPhase) {
+            parsed.current_phase = phaseSnapshot.currentPhase;
+            changed = true;
+        }
+        if (safeString(parsed.completed_at).trim() !== phaseSnapshot.completedAt && phaseSnapshot.completedAt) {
+            parsed.completed_at = phaseSnapshot.completedAt;
+            changed = true;
+        }
+        if (safeString(parsed.last_turn_at).trim() !== nowIso) {
+            parsed.last_turn_at = nowIso;
+            changed = true;
+        }
+        if (changed) {
+            await writeFile(teamStatePath, JSON.stringify(parsed, null, 2));
+        }
+        return changed;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveCurrentSessionId(stateDir) {
+    const fromEnv = safeString(process.env.OMX_SESSION_ID
+        || process.env.CODEX_SESSION_ID
+        || process.env.SESSION_ID
+        || '').trim();
+    const envSessionId = normalizeValidSessionId(fromEnv);
+    if (envSessionId)
+        return envSessionId;
+    return normalizeValidSessionId((await readUsableSessionState(resolve(stateDir, '..', '..')))?.session_id);
+}
+async function readWorkerStatusSnapshot(stateDir, teamName, workerName) {
+    if (!workerName)
+        return { state: 'unknown', current_task_id: '' };
+    const path = join(stateDir, 'team', teamName, 'workers', workerName, 'status.json');
+    try {
+        if (!existsSync(path))
+            return { state: 'unknown', current_task_id: '', missing: true };
+        const parsed = JSON.parse(await readFile(path, 'utf-8'));
+        return {
+            state: safeString(parsed && parsed.state ? parsed.state : 'unknown') || 'unknown',
+            current_task_id: safeString(parsed && parsed.current_task_id ? parsed.current_task_id : '').trim(),
+            missing: false,
+        };
+    }
+    catch {
+        return { state: 'unknown', current_task_id: '', missing: false };
+    }
+}
+async function readWorkerStatusState(stateDir, teamName, workerName) {
+    const snapshot = await readWorkerStatusSnapshot(stateDir, teamName, workerName);
+    return snapshot.state;
+}
+async function readWorkerHeartbeatSnapshot(stateDir, teamName, workerName) {
+    if (!workerName)
+        return { turn_count: null, missing: true };
+    const path = join(stateDir, 'team', teamName, 'workers', workerName, 'heartbeat.json');
+    try {
+        if (!existsSync(path))
+            return { turn_count: null, missing: true };
+        const parsed = JSON.parse(await readFile(path, 'utf-8'));
+        return {
+            turn_count: Number.isFinite(parsed?.turn_count) ? parsed.turn_count : null,
+            missing: false,
+        };
+    }
+    catch {
+        return { turn_count: null, missing: false };
+    }
+}
+async function readTeamTaskProgressSnapshot(stateDir, teamName) {
+    const tasksDir = join(stateDir, 'team', teamName, 'tasks');
+    if (!existsSync(tasksDir)) {
+        return {
+            taskCounts: { pending: 0, blocked: 0, in_progress: 0, completed: 0, failed: 0 },
+            taskSignature: [],
+            workRemaining: false,
+        };
+    }
+    const taskCounts = { pending: 0, blocked: 0, in_progress: 0, completed: 0, failed: 0 };
+    const taskSignature = [];
+    try {
+        const taskFiles = (await readdir(tasksDir))
+            .filter((entry) => /^task-\d+\.json$/.test(entry))
+            .sort();
+        for (const entry of taskFiles) {
+            try {
+                const parsed = JSON.parse(await readFile(join(tasksDir, entry), 'utf-8'));
+                const id = safeString(parsed?.id || entry.replace(/^task-/, '').replace(/\.json$/, '')).trim();
+                const status = safeString(parsed?.status || 'pending').trim() || 'pending';
+                const owner = safeString(parsed?.owner || '').trim();
+                if (Object.hasOwn(taskCounts, status))
+                    taskCounts[status] += 1;
+                taskSignature.push({ id, owner, status });
+            }
+            catch {
+                // ignore malformed task files
+            }
+        }
+    }
+    catch {
+        // ignore task-read failures
+    }
+    return {
+        taskCounts,
+        taskSignature,
+        workRemaining: taskCounts.pending > 0 || taskCounts.blocked > 0 || taskCounts.in_progress > 0,
+    };
+}
+async function readTeamProgressSnapshot(stateDir, teamName, workerNames) {
+    const [taskSnapshot, workerSnapshot] = await Promise.all([
+        readTeamTaskProgressSnapshot(stateDir, teamName),
+        Promise.all(workerNames.map(async (workerName) => {
+            const [status, heartbeat] = await Promise.all([
+                readWorkerStatusSnapshot(stateDir, teamName, workerName),
+                readWorkerHeartbeatSnapshot(stateDir, teamName, workerName),
+            ]);
+            return {
+                worker: workerName,
+                state: status.state,
+                current_task_id: status.current_task_id,
+                status_missing: status.missing === true,
+                turn_count: heartbeat.turn_count,
+                heartbeat_missing: heartbeat.missing === true,
+            };
+        })),
+    ]);
+    const missingSignalWorkers = workerSnapshot.filter(({ status_missing, heartbeat_missing }) => status_missing || heartbeat_missing).length;
+    return {
+        ...taskSnapshot,
+        workerSnapshot,
+        missingSignalWorkers,
+        signature: JSON.stringify({
+            tasks: taskSnapshot.taskSignature,
+            workers: workerSnapshot,
+        }),
+    };
+}
+function readPreviousWorkerTurnCounts(previousSignature) {
+    try {
+        const parsed = JSON.parse(previousSignature || '{}');
+        const workers = Array.isArray(parsed?.workers) ? parsed.workers : [];
+        return new Map(workers
+            .map((worker) => [safeString(worker?.worker).trim(), Number.isFinite(worker?.turn_count) ? Number(worker.turn_count) : null])
+            .filter(([workerName]) => workerName.length > 0));
+    }
+    catch {
+        return new Map();
+    }
+}
+function hasWorkerTurnProgress(workerSnapshot, previousTurnCounts) {
+    return workerSnapshot.some((worker) => {
+        if (worker.state !== 'working' && worker.state !== 'blocked')
+            return false;
+        if (!Number.isFinite(worker.turn_count) || worker.turn_count === null)
+            return false;
+        const previousTurnCount = previousTurnCounts.get(worker.worker);
+        return Number.isFinite(previousTurnCount) && previousTurnCount !== null && worker.turn_count > previousTurnCount;
+    });
+}
+function hasTrackableActiveWorkerTurns(workerSnapshot, previousTurnCounts) {
+    return workerSnapshot.some((worker) => {
+        if (worker.state !== 'working' && worker.state !== 'blocked')
+            return false;
+        if (!Number.isFinite(worker.turn_count) || worker.turn_count === null)
+            return false;
+        const previousTurnCount = previousTurnCounts.get(worker.worker);
+        return Number.isFinite(previousTurnCount) && previousTurnCount !== null;
+    });
+}
+function formatDurationMs(durationMs) {
+    const seconds = Math.max(1, Math.round(durationMs / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds % 60 === 0)
+        return `${seconds / 60}m`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m${remainingSeconds}s`;
+}
+function normalizeMailboxMessages(rawMailbox) {
+    if (Array.isArray(rawMailbox))
+        return rawMailbox;
+    if (rawMailbox && typeof rawMailbox === 'object' && Array.isArray(rawMailbox.messages)) {
+        return rawMailbox.messages;
+    }
+    return [];
+}
+function normalizeMessageIdentity(msg) {
+    if (!msg || typeof msg !== 'object')
+        return '';
+    const explicitId = safeString(msg.message_id || '').trim();
+    if (explicitId)
+        return explicitId;
+    const createdAt = safeString(msg.created_at || msg.timestamp || '').trim();
+    const from = safeString(msg.from_worker || msg.from || '').trim();
+    const body = safeString(msg.body || '').trim();
+    return [createdAt, from, body].filter(Boolean).join('|');
+}
+function normalizeMailboxBody(body) {
+    return safeString(body).replace(/\s+/g, ' ').trim();
+}
+function isAckLikeMailboxBody(body) {
+    const normalized = normalizeMailboxBody(body);
+    if (!normalized)
+        return false;
+    return ACK_LIKE_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function formatMailboxBodyForLeader(body, maxLength = 40) {
+    const normalized = normalizeMailboxBody(body);
+    if (!normalized)
+        return 'ack-like update';
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, maxLength - 1)}…`;
+}
+function normalizeVisibleLeaderStateText(text) {
+    return safeString(text)
+        .toLowerCase()
+        .replace(/\[omx_tmux_inject\]/g, ' ')
+        .replace(/\[omx_intent:[^\]]+\]/g, ' ')
+        .replace(/said\s+"[^"]*"/g, 'said "<content>"')
+        .replace(/said\s+'[^']*'/g, 'said "<content>"')
+        .replace(/\b\d+[smhd](?:\s+\d+[smhd])*\b/g, '<duration>')
+        .replace(/\b\d+\b/g, '<n>')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function paneAlreadyShowsVisibleLeaderState(paneCapture, visibleText) {
+    const normalizedVisibleText = normalizeVisibleLeaderStateText(visibleText);
+    if (!normalizedVisibleText)
+        return false;
+    const normalizedPaneCapture = normalizeVisibleLeaderStateText(paneCapture);
+    if (!normalizedPaneCapture)
+        return false;
+    return normalizedPaneCapture.includes(normalizedVisibleText);
+}
+async function workerHasOwnedStartedTask(stateDir, teamName, workerName) {
+    const tasksDir = join(stateDir, 'team', teamName, 'tasks');
+    if (!existsSync(tasksDir))
+        return false;
+    try {
+        const taskFiles = (await readdir(tasksDir))
+            .filter((entry) => /^task-\d+\.json$/.test(entry))
+            .sort();
+        for (const entry of taskFiles) {
+            try {
+                const parsed = JSON.parse(await readFile(join(tasksDir, entry), 'utf-8'));
+                if (safeString(parsed?.owner).trim() !== workerName)
+                    continue;
+                const status = safeString(parsed?.status).trim();
+                if (status === 'in_progress' || status === 'completed' || status === 'failed')
+                    return true;
+            }
+            catch {
+                // ignore malformed task files
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+async function getAckWithoutStartEvidence(stateDir, teamName, msg) {
+    if (!msg || typeof msg !== 'object')
+        return null;
+    const fromWorker = safeString(msg.from_worker || '').trim();
+    if (!fromWorker || fromWorker === 'leader-fixed')
+        return null;
+    if (!isAckLikeMailboxBody(msg.body))
+        return null;
+    const status = await readWorkerStatusSnapshot(stateDir, teamName, fromWorker);
+    if (status.current_task_id
+        || status.state === 'working'
+        || status.state === 'blocked'
+        || status.state === 'done'
+        || status.state === 'failed') {
+        return null;
+    }
+    if (await workerHasOwnedStartedTask(stateDir, teamName, fromWorker)) {
+        return null;
+    }
+    return {
+        worker: fromWorker,
+        body: formatMailboxBodyForLeader(msg.body),
+        statusState: status.state,
+    };
+}
+export async function emitTeamNudgeEvent(cwd, teamName, reason, orchestrationIntent, nowIso) {
+    const eventsDir = join(cwd, '.omx', 'state', 'team', teamName, 'events');
+    const eventsPath = join(eventsDir, 'events.ndjson');
+    try {
+        await mkdir(eventsDir, { recursive: true });
+        const event = {
+            event_id: `nudge-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+            team: teamName,
+            type: 'team_leader_nudge',
+            worker: 'leader-fixed',
+            reason,
+            orchestration_intent: orchestrationIntent,
+            created_at: nowIso,
+        };
+        await appendFile(eventsPath, JSON.stringify(event) + '\n');
+    }
+    catch {
+        // Best effort
+    }
+}
+async function emitLeaderNudgeDeferredEvent(cwd, teamName, reason, orchestrationIntent, nowIso, { tmuxSession = '', leaderPaneId = '', paneCurrentCommand = '', sourceType = 'leader_nudge' } = {}) {
+    const eventsDir = join(cwd, '.omx', 'state', 'team', teamName, 'events');
+    const eventsPath = join(eventsDir, 'events.ndjson');
+    try {
+        await mkdir(eventsDir, { recursive: true });
+        const event = {
+            event_id: `leader-deferred-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+            team: teamName,
+            type: LEADER_NOTIFICATION_DEFERRED_TYPE,
+            worker: 'leader-fixed',
+            to_worker: 'leader-fixed',
+            reason,
+            created_at: nowIso,
+            tmux_session: tmuxSession || null,
+            leader_pane_id: leaderPaneId || null,
+            orchestration_intent: orchestrationIntent,
+            tmux_injection_attempted: false,
+            pane_current_command: paneCurrentCommand || null,
+            source_type: sourceType,
+        };
+        await appendFile(eventsPath, JSON.stringify(event) + '\n');
+    }
+    catch {
+        // Best effort
+    }
+}
+export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputedLeaderStale, allowFreshMailboxNudges = true, source = 'notify_hook', }) {
+    const intervalMs = resolveLeaderNudgeIntervalMs();
+    const idleCooldownMs = resolveLeaderAllIdleNudgeCooldownMs();
+    const nowMs = Date.now();
+    const nowIso = new Date().toISOString();
+    const omxDir = join(cwd, '.omx');
+    const nudgeStatePath = join(stateDir, 'team-leader-nudge.json');
+    let nudgeState = await readJsonIfExists(nudgeStatePath, null);
+    if (!nudgeState || typeof nudgeState !== 'object') {
+        nudgeState = { last_nudged_by_team: {} };
+    }
+    if (!nudgeState.last_nudged_by_team || typeof nudgeState.last_nudged_by_team !== 'object') {
+        nudgeState.last_nudged_by_team = {};
+    }
+    if (!nudgeState.last_idle_nudged_by_team || typeof nudgeState.last_idle_nudged_by_team !== 'object') {
+        nudgeState.last_idle_nudged_by_team = {};
+    }
+    if (!nudgeState.progress_by_team || typeof nudgeState.progress_by_team !== 'object') {
+        nudgeState.progress_by_team = {};
+    }
+    const candidateTeamNames = new Set();
+    const currentSessionId = await resolveCurrentSessionId(stateDir);
+    const deepInterviewActive = currentSessionId
+        ? await isDeepInterviewStateActive(stateDir, currentSessionId).catch(() => false)
+        : await isDeepInterviewStateActive(stateDir, undefined).catch(() => false);
+    if (deepInterviewActive) {
+        return;
+    }
+    try {
+        const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir);
+        const candidateStateDirs = [...new Set([...scopedDirs, stateDir])];
+        for (const scopedDir of candidateStateDirs) {
+            const teamStatePath = join(scopedDir, 'team-state.json');
+            if (!existsSync(teamStatePath))
+                continue;
+            const parsed = JSON.parse(await readFile(teamStatePath, 'utf-8'));
+            if (!parsed)
+                continue;
+            const teamName = normalizeValidTeamName(parsed.team_name || '');
+            if (!teamName)
+                continue;
+            const phaseSnapshot = await readTeamPhaseSnapshot(stateDir, teamName, nowIso);
+            if (phaseSnapshot.terminal) {
+                await syncScopedTeamStateFromPhase(teamStatePath, teamName, phaseSnapshot, nowIso);
+                continue;
+            }
+            if (parsed.active === true) {
+                candidateTeamNames.add(teamName);
+            }
+        }
+    }
+    catch {
+        // Non-critical
+    }
+    const canonicalFallbackTeams = await listNotifyCanonicalActiveTeams(cwd, currentSessionId).catch(() => []);
+    for (const team of canonicalFallbackTeams) {
+        const teamName = normalizeValidTeamName(team.teamName);
+        if (!teamName)
+            continue;
+        candidateTeamNames.add(teamName);
+    }
+    // Use pre-computed staleness (captured before HUD state was updated this turn)
+    const leaderStale = typeof preComputedLeaderStale === 'boolean' ? preComputedLeaderStale : false;
+    for (const teamName of candidateTeamNames) {
+        let tmuxSession = '';
+        let leaderPaneId = '';
+        let ownerSessionId = '';
+        let workers = [];
+        try {
+            const manifestPath = join(omxDir, 'state', 'team', teamName, 'manifest.v2.json');
+            const configPath = join(omxDir, 'state', 'team', teamName, 'config.json');
+            const srcPath = existsSync(manifestPath) ? manifestPath : configPath;
+            if (existsSync(srcPath)) {
+                const raw = JSON.parse(await readFile(srcPath, 'utf-8'));
+                tmuxSession = safeString(raw && raw.tmux_session ? raw.tmux_session : '').trim();
+                leaderPaneId = safeString(raw && raw.leader_pane_id ? raw.leader_pane_id : '').trim();
+                ownerSessionId = safeString(raw && raw.leader && raw.leader.session_id ? raw.leader.session_id : '').trim();
+                if (Array.isArray(raw && raw.workers))
+                    workers = raw.workers;
+            }
+        }
+        catch {
+            // ignore
+        }
+        if (currentSessionId && ownerSessionId && ownerSessionId !== currentSessionId)
+            continue;
+        let mailbox = null;
+        try {
+            const mailboxPath = join(omxDir, 'state', 'team', teamName, 'mailbox', 'leader-fixed.json');
+            mailbox = await readJsonIfExists(mailboxPath, null);
+        }
+        catch {
+            mailbox = null;
+        }
+        const messages = normalizeMailboxMessages(mailbox);
+        const newest = messages.length > 0 ? messages[messages.length - 1] : null;
+        const newestId = normalizeMessageIdentity(newest);
+        const workerNames = Array.isArray(workers)
+            ? workers.map((w) => safeString(w && w.name ? w.name : '')).filter(Boolean)
+            : [];
+        const workerPaneIds = Array.isArray(workers)
+            ? workers.map((w) => safeString(w && w.pane_id ? w.pane_id : '')).filter(Boolean)
+            : [];
+        const canonicalLeaderPaneId = safeString(leaderPaneId).trim();
+        if (!tmuxSession && !canonicalLeaderPaneId)
+            continue;
+        let tmuxTarget = canonicalLeaderPaneId;
+        if (canonicalLeaderPaneId) {
+            const resolvedLeaderTarget = await resolvePaneTarget({ type: 'pane', value: canonicalLeaderPaneId }, '', canonicalLeaderPaneId, '', {}).catch(() => null);
+            if (resolvedLeaderTarget?.paneTarget) {
+                tmuxTarget = safeString(resolvedLeaderTarget.paneTarget).trim();
+            }
+            else if (resolvedLeaderTarget && ['target_is_hud_pane', 'pane_cwd_mismatch'].includes(safeString(resolvedLeaderTarget.reason).trim())) {
+                tmuxTarget = '';
+            }
+        }
+        const paneStatus = tmuxSession
+            ? await checkWorkerPanesAlive(tmuxSession, workerPaneIds)
+            : { alive: false, paneCount: 0 };
+        const workerStates = workerNames.length > 0
+            ? await Promise.all(workerNames.map((workerName) => readWorkerStatusState(stateDir, teamName, workerName)))
+            : [];
+        const allWorkersIdle = workerStates.length > 0 && workerStates.every((state) => state === 'idle' || state === 'done');
+        const progressSnapshot = await readTeamProgressSnapshot(stateDir, teamName, workerNames);
+        const prevProgress = nudgeState.progress_by_team[teamName] && typeof nudgeState.progress_by_team[teamName] === 'object'
+            ? nudgeState.progress_by_team[teamName]
+            : {};
+        const previousSignature = safeString(prevProgress.signature || '');
+        const previousProgressAtIso = safeString(prevProgress.last_progress_at || '');
+        const previousProgressAtMs = previousProgressAtIso ? Date.parse(previousProgressAtIso) : NaN;
+        const previousTurnCounts = readPreviousWorkerTurnCounts(previousSignature);
+        const workerTurnProgress = hasWorkerTurnProgress(progressSnapshot.workerSnapshot, previousTurnCounts);
+        const progressChanged = !previousSignature || previousSignature !== progressSnapshot.signature || workerTurnProgress;
+        const extraProgressEvidenceMs = await readLatestTeamProgressEvidenceMs(cwd, teamName).catch(() => Number.NaN);
+        const effectiveProgressAtMs = progressChanged || !Number.isFinite(previousProgressAtMs)
+            ? nowMs
+            : previousProgressAtMs;
+        const latestProgressEvidenceMs = Number.isFinite(extraProgressEvidenceMs)
+            ? Math.max(effectiveProgressAtMs, extraProgressEvidenceMs)
+            : effectiveProgressAtMs;
+        const effectiveProgressAtIso = new Date(latestProgressEvidenceMs).toISOString();
+        const hasFreshProgressEvidence = progressSnapshot.workRemaining
+            && (progressChanged
+                || (Number.isFinite(extraProgressEvidenceMs)
+                    && (nowMs - extraProgressEvidenceMs) < resolveLeaderStalenessThresholdMs()));
+        const leaderActionState = classifyLeaderActionState({
+            allWorkersIdle,
+            workerPanesAlive: paneStatus.alive,
+            taskCounts: progressSnapshot.taskCounts,
+        });
+        const leaderActionGuidance = buildLeaderActionGuidance(teamName, {
+            allWorkersIdle,
+            workerPanesAlive: paneStatus.alive,
+            taskCounts: progressSnapshot.taskCounts,
+            leaderActionState,
+        });
+        const prev = nudgeState.last_nudged_by_team[teamName] && typeof nudgeState.last_nudged_by_team[teamName] === 'object'
+            ? nudgeState.last_nudged_by_team[teamName]
+            : {};
+        const prevAtIso = safeString(prev.at || '');
+        const prevAtMs = prevAtIso ? Date.parse(prevAtIso) : NaN;
+        const prevMsgId = safeString(prev.last_message_id || '');
+        const prevReason = safeString(prev.reason || '');
+        const hasNewMessage = newestId && newestId !== prevMsgId;
+        const dueByTime = !Number.isFinite(prevAtMs) || (nowMs - prevAtMs >= intervalMs);
+        const ackWithoutStartEvidence = hasNewMessage
+            ? await getAckWithoutStartEvidence(stateDir, teamName, newest)
+            : null;
+        const prevIdle = nudgeState.last_idle_nudged_by_team[teamName] && typeof nudgeState.last_idle_nudged_by_team[teamName] === 'object'
+            ? nudgeState.last_idle_nudged_by_team[teamName]
+            : {};
+        const prevIdleAtIso = safeString(prevIdle.at || '');
+        const prevIdleAtMs = prevIdleAtIso ? Date.parse(prevIdleAtIso) : NaN;
+        const dueByIdleCooldown = !Number.isFinite(prevIdleAtMs) || (nowMs - prevIdleAtMs >= idleCooldownMs);
+        const shouldSendAllIdleNudge = allWorkersIdle && dueByIdleCooldown;
+        // Stale-leader follow-up is the only periodic visible nudge path.
+        // This keeps the leader pane quieter when the leader is not actually stale.
+        const stalePanesNudge = paneStatus.alive && leaderStale && !hasFreshProgressEvidence;
+        const staleFollowupDue = stalePanesNudge && dueByTime;
+        const hasActionableNewMessage = hasNewMessage && (allowFreshMailboxNudges || leaderStale);
+        let nudgeReason = '';
+        let text = '';
+        if (shouldSendAllIdleNudge) {
+            nudgeReason = leaderActionState === 'done_waiting_on_leader'
+                ? 'done_waiting_on_leader'
+                : leaderActionState === 'stuck_waiting_on_leader'
+                    ? 'stuck_waiting_on_leader'
+                    : 'all_workers_idle';
+            const N = workerNames.length;
+            const waitingText = buildIdleContextText(teamName, {
+                allWorkersIdle,
+                workerPanesAlive: paneStatus.alive,
+                taskCounts: progressSnapshot.taskCounts,
+                leaderActionState,
+            });
+            text = `[OMX] All ${N} worker${N === 1 ? '' : 's'} idle.${waitingText} ${leaderActionGuidance}`;
+        }
+        else if (ackWithoutStartEvidence) {
+            nudgeReason = ACK_WITHOUT_START_EVIDENCE_REASON;
+            text =
+                `Team ${teamName}: ${ackWithoutStartEvidence.worker} said "${ackWithoutStartEvidence.body}" `
+                    + `but has no start evidence (status: ${ackWithoutStartEvidence.statusState}). `
+                    + buildWorkerStartEvidenceReminder(teamName, ackWithoutStartEvidence.worker);
+        }
+        else if (stalePanesNudge && hasActionableNewMessage) {
+            nudgeReason = 'stale_leader_with_messages';
+            text =
+                `Team ${teamName}: leader stale, ${paneStatus.paneCount} pane(s) active, ${messages.length} msg(s) pending. `
+                    + buildMailboxCheckReminder(teamName);
+        }
+        else if (staleFollowupDue) {
+            nudgeReason = 'stale_leader_panes_alive';
+            text =
+                `Team ${teamName}: leader stale, ${paneStatus.paneCount} worker pane(s) still active. `
+                    + leaderActionGuidance;
+        }
+        else if (hasActionableNewMessage) {
+            nudgeReason = 'new_mailbox_message';
+            text = `Team ${teamName}: ${messages.length} msg(s) for leader. ${buildMailboxCheckReminder(teamName)}`;
+        }
+        const unreadLeaderMessageCount = messages.filter((message) => !safeString(message?.delivered_at).trim()).length;
+        nudgeState.progress_by_team[teamName] = {
+            signature: progressSnapshot.signature,
+            last_progress_at: effectiveProgressAtIso,
+            observed_at: nowIso,
+            missing_signal_workers: progressSnapshot.missingSignalWorkers,
+            work_remaining: progressSnapshot.workRemaining,
+            leader_action_state: leaderActionState,
+            leader_attention_pending: !!nudgeReason,
+            leader_attention_reason: nudgeReason || null,
+            leader_stale: leaderStale,
+            all_workers_idle: allWorkersIdle,
+            pending_task_count: (progressSnapshot.taskCounts.pending || 0)
+                + (progressSnapshot.taskCounts.blocked || 0)
+                + (progressSnapshot.taskCounts.in_progress || 0),
+            unread_leader_message_count: unreadLeaderMessageCount,
+            stalled_for_ms: null,
+            source: source === 'notify_fallback_watcher' ? 'notify_hook' : source,
+        };
+        await writeTeamLeaderAttention(teamName, {
+            team_name: teamName,
+            updated_at: nowIso,
+            source: 'notify_hook',
+            leader_decision_state: leaderActionState,
+            leader_attention_pending: !!nudgeReason,
+            leader_attention_reason: nudgeReason || null,
+            attention_reasons: nudgeReason ? [nudgeReason] : [],
+            leader_stale: leaderStale,
+            leader_session_active: true,
+            leader_session_id: currentSessionId || ownerSessionId || null,
+            leader_session_stopped_at: null,
+            unread_leader_message_count: unreadLeaderMessageCount,
+            work_remaining: progressSnapshot.workRemaining,
+            stalled_for_ms: null,
+        }, cwd).catch(() => { });
+        if (!nudgeReason)
+            continue;
+        const orchestrationIntent = resolveLeaderNudgeIntent({ nudgeReason, leaderActionState });
+        const capped = text.length > 180 ? `${text.slice(0, 177)}...` : text;
+        const markedText = `${capped} ${DEFAULT_MARKER}`;
+        if (!tmuxTarget) {
+            nudgeState.last_nudged_by_team[teamName] = {
+                at: nowIso,
+                last_message_id: newestId || prevMsgId || '',
+                reason: nudgeReason,
+                orchestration_intent: orchestrationIntent,
+            };
+            if (shouldSendAllIdleNudge) {
+                nudgeState.last_idle_nudged_by_team[teamName] = {
+                    at: nowIso,
+                    worker_count: workerNames.length,
+                    orchestration_intent: orchestrationIntent,
+                };
+            }
+            await emitLeaderNudgeDeferredEvent(cwd, teamName, LEADER_PANE_MISSING_NO_INJECTION_REASON, orchestrationIntent, nowIso, {
+                tmuxSession,
+                leaderPaneId,
+                sourceType: 'leader_nudge',
+            });
+            try {
+                await logTmuxHookEvent(logsDir, {
+                    timestamp: nowIso,
+                    type: LEADER_NOTIFICATION_DEFERRED_TYPE,
+                    team: teamName,
+                    worker: 'leader-fixed',
+                    to_worker: 'leader-fixed',
+                    reason: LEADER_PANE_MISSING_NO_INJECTION_REASON,
+                    leader_pane_id: leaderPaneId || null,
+                    tmux_session: tmuxSession || null,
+                    orchestration_intent: orchestrationIntent,
+                    tmux_injection_attempted: false,
+                    source_type: 'leader_nudge',
+                });
+            }
+            catch { /* ignore */ }
+            await appendTeamDeliveryLog(logsDir, {
+                event: 'nudge_triggered',
+                source,
+                team: teamName,
+                to_worker: 'leader-fixed',
+                transport: 'none',
+                result: 'deferred',
+                reason: LEADER_PANE_MISSING_NO_INJECTION_REASON,
+                orchestration_intent: orchestrationIntent,
+            }).catch(() => { });
+            continue;
+        }
+        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
+                : paneGuard.reason;
+            nudgeState.last_nudged_by_team[teamName] = {
+                at: nowIso,
+                last_message_id: newestId || prevMsgId || '',
+                reason: nudgeReason,
+                orchestration_intent: orchestrationIntent,
+            };
+            if (shouldSendAllIdleNudge) {
+                nudgeState.last_idle_nudged_by_team[teamName] = {
+                    at: nowIso,
+                    worker_count: workerNames.length,
+                    orchestration_intent: orchestrationIntent,
+                };
+            }
+            await emitLeaderNudgeDeferredEvent(cwd, teamName, deferredReason, orchestrationIntent, nowIso, {
+                tmuxSession,
+                leaderPaneId,
+                paneCurrentCommand: paneGuard.paneCurrentCommand,
+                sourceType: 'leader_nudge',
+            });
+            try {
+                await logTmuxHookEvent(logsDir, {
+                    timestamp: nowIso,
+                    type: LEADER_NOTIFICATION_DEFERRED_TYPE,
+                    team: teamName,
+                    worker: 'leader-fixed',
+                    to_worker: 'leader-fixed',
+                    reason: deferredReason,
+                    leader_pane_id: leaderPaneId || null,
+                    tmux_session: tmuxSession || null,
+                    tmux_injection_attempted: false,
+                    pane_target: tmuxTarget,
+                    orchestration_intent: orchestrationIntent,
+                    readiness_evidence: paneGuard.readinessEvidence || null,
+                    pane_current_command: paneGuard.paneCurrentCommand || null,
+                    injection_skip_reason: paneGuard.reason,
+                    source_type: 'leader_nudge',
+                });
+            }
+            catch { /* ignore */ }
+            await appendTeamDeliveryLog(logsDir, {
+                event: 'nudge_triggered',
+                source,
+                team: teamName,
+                to_worker: 'leader-fixed',
+                transport: 'none',
+                result: 'deferred',
+                reason: deferredReason,
+                orchestration_intent: orchestrationIntent,
+            }).catch(() => { });
+            continue;
+        }
+        if (paneAlreadyShowsVisibleLeaderState(paneGuard.paneCapture, capped)) {
+            nudgeState.last_nudged_by_team[teamName] = {
+                at: nowIso,
+                last_message_id: newestId || prevMsgId || '',
+                reason: nudgeReason,
+                orchestration_intent: orchestrationIntent,
+            };
+            if (shouldSendAllIdleNudge) {
+                nudgeState.last_idle_nudged_by_team[teamName] = {
+                    at: nowIso,
+                    worker_count: workerNames.length,
+                    orchestration_intent: orchestrationIntent,
+                };
+            }
+            await emitTeamNudgeEvent(cwd, teamName, nudgeReason, orchestrationIntent, nowIso);
+            try {
+                await logTmuxHookEvent(logsDir, {
+                    timestamp: nowIso,
+                    type: 'team_leader_nudge',
+                    team: teamName,
+                    tmux_target: tmuxTarget,
+                    reason: nudgeReason,
+                    orchestration_intent: orchestrationIntent,
+                    pane_count: paneStatus.paneCount,
+                    leader_stale: leaderStale,
+                    message_count: messages.length,
+                    stalled_for_ms: undefined,
+                    missing_signal_workers: progressSnapshot.missingSignalWorkers,
+                    visible_injection_suppressed: true,
+                    suppression_reason: LEADER_PANE_SAME_CLASSIFIED_STATE_SUPPRESSED_REASON,
+                });
+            }
+            catch { /* ignore */ }
+            await appendTeamDeliveryLog(logsDir, {
+                event: 'nudge_triggered',
+                source,
+                team: teamName,
+                to_worker: 'leader-fixed',
+                transport: 'send-keys',
+                result: 'suppressed',
+                reason: nudgeReason,
+                orchestration_intent: orchestrationIntent,
+                visible_injection_suppressed: true,
+                suppression_reason: LEADER_PANE_SAME_CLASSIFIED_STATE_SUPPRESSED_REASON,
+            }).catch(() => { });
+            continue;
+        }
+        try {
+            const leaderHasActiveTask = paneHasActiveTask(paneGuard.paneCapture);
+            let deliveryMode = 'sent';
+            if (leaderHasActiveTask) {
+                const sendResult = await queuePaneInput({
+                    paneTarget: tmuxTarget,
+                    prompt: markedText,
+                });
+                if (!sendResult.ok) {
+                    throw new Error(sendResult.error || sendResult.reason);
+                }
+                deliveryMode = 'queued';
+            }
+            else {
+                const sendResult = await sendPaneInput({
+                    paneTarget: tmuxTarget,
+                    prompt: markedText,
+                    submitKeyPresses: 2,
+                    submitDelayMs: 100,
+                });
+                if (!sendResult.ok) {
+                    throw new Error(sendResult.error || sendResult.reason);
+                }
+            }
+            nudgeState.last_nudged_by_team[teamName] = {
+                at: nowIso,
+                last_message_id: newestId || prevMsgId || '',
+                reason: nudgeReason,
+                orchestration_intent: orchestrationIntent,
+            };
+            if (shouldSendAllIdleNudge) {
+                nudgeState.last_idle_nudged_by_team[teamName] = {
+                    at: nowIso,
+                    worker_count: workerNames.length,
+                    orchestration_intent: orchestrationIntent,
+                };
+            }
+            await emitTeamNudgeEvent(cwd, teamName, nudgeReason, orchestrationIntent, nowIso);
+            try {
+                await logTmuxHookEvent(logsDir, {
+                    timestamp: nowIso,
+                    type: 'team_leader_nudge',
+                    team: teamName,
+                    tmux_target: tmuxTarget,
+                    reason: nudgeReason,
+                    orchestration_intent: orchestrationIntent,
+                    pane_count: paneStatus.paneCount,
+                    leader_stale: leaderStale,
+                    message_count: messages.length,
+                    stalled_for_ms: undefined,
+                    missing_signal_workers: progressSnapshot.missingSignalWorkers,
+                    delivery: deliveryMode,
+                });
+            }
+            catch { /* ignore */ }
+            await appendTeamDeliveryLog(logsDir, {
+                event: 'nudge_triggered',
+                source,
+                team: teamName,
+                to_worker: 'leader-fixed',
+                transport: 'send-keys',
+                result: deliveryMode,
+                reason: nudgeReason,
+                orchestration_intent: orchestrationIntent,
+            }).catch(() => { });
+        }
+        catch (err) {
+            try {
+                await logTmuxHookEvent(logsDir, {
+                    timestamp: nowIso,
+                    type: 'team_leader_nudge',
+                    team: teamName,
+                    tmux_target: tmuxTarget,
+                    reason: nudgeReason,
+                    orchestration_intent: orchestrationIntent,
+                    error: safeString(err && err.message ? err.message : err),
+                });
+            }
+            catch { /* ignore */ }
+            await appendTeamDeliveryLog(logsDir, {
+                event: 'nudge_triggered',
+                source,
+                team: teamName,
+                to_worker: 'leader-fixed',
+                transport: 'send-keys',
+                result: 'failed',
+                reason: nudgeReason,
+                orchestration_intent: orchestrationIntent,
+                error: safeString(err && err.message ? err.message : err),
+            }).catch(() => { });
+        }
+    }
+    await writeFile(nudgeStatePath, JSON.stringify(nudgeState, null, 2)).catch(() => { });
+}
+//# sourceMappingURL=team-leader-nudge.js.map