oh-my-codex 0.11.13 → 0.12.1

package/dist/scripts/notify-fallback-watcher.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { existsSync } from 'fs';
-import { appendFile, mkdir, open, readFile, readdir, rename, stat, unlink, writeFile } from 'fs/promises';
+import { appendFile, mkdir, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from 'fs/promises';
 import { spawnSync } from 'child_process';
 import { dirname, join, resolve } from 'path';
 import { homedir } from 'os';
@@ -12,6 +12,7 @@ import { checkWorkerPanesAlive, isLeaderStale, maybeNudgeTeamLeader, resolveLead
 import { DEFAULT_MARKER } from './tmux-hook-engine.js';
 import { isTerminalPhase } from './notify-hook/utils.js';
 import { isSessionStale, readSessionState } from '../hooks/session.js';
+import { DEFAULT_SUBAGENT_ACTIVE_WINDOW_MS, readSubagentSessionSummary, } from '../subagents/tracker.js';
 function argValue(name, fallback = '') {
     const idx = process.argv.indexOf(name);
     if (idx < 0 || idx + 1 >= process.argv.length)
@@ -64,6 +65,7 @@ const authorityOnly = process.argv.includes('--authority-only');
 // ack budget so leaderless team dispatch + stale-alert recovery do not feel
 // laggy between native notify-hook turns.
 const pollMs = Math.max(50, asNumber(argValue('--poll-ms', '250'), 250));
+const idleMaxPollMs = Math.max(pollMs, asNumber(argValue('--idle-max-poll-ms', process.env.OMX_NOTIFY_FALLBACK_IDLE_MAX_POLL_MS || '1000'), 1000));
 const parentPid = Math.trunc(asNumber(argValue('--parent-pid', String(process.ppid || 0)), process.ppid || 0));
 const startedAt = Date.now();
 const fileWindowMs = runOnce ? 15000 : 30000;
@@ -77,6 +79,10 @@ const stateDir = join(omxDir, 'state');
 const statePath = join(stateDir, 'notify-fallback-state.json');
 const pidFilePath = resolve(argValue('--pid-file', join(stateDir, 'notify-fallback.pid')));
 const logPath = join(logsDir, `notify-fallback-${new Date().toISOString().split('T')[0]}.jsonl`);
+const logRotatePath = `${logPath}.1`;
+const logLockPath = `${logPath}.lock`;
+const defaultMaxLogBytes = 10 * 1024 * 1024;
+const maxLogBytes = Math.max(0, asNumber(argValue('--log-max-bytes', process.env.OMX_NOTIFY_FALLBACK_LOG_MAX_BYTES || String(defaultMaxLogBytes)), defaultMaxLogBytes));
 const ralphSteerTimestampPath = join(stateDir, 'ralph-last-steer-at');
 const ralphSteerLockPath = join(stateDir, 'ralph-continue-steer.lock');
 const watcherOwnerToken = `${process.pid}-${startedAt}-${Math.random().toString(36).slice(2, 10)}`;
@@ -84,6 +90,7 @@ const RALPH_CONTINUE_TEXT = 'Ralph loop active continue';
 const RALPH_CONTINUE_CADENCE_MS = 60_000;
 const RALPH_STEER_LOCK_STALE_MS = 30_000;
 const RALPH_TERMINAL_PHASES = new Set(['complete', 'failed', 'cancelled']);
+const QUIET_ONCE_EVENT_TYPES = new Set(['watcher_start', 'watcher_once_complete']);
 const fileState = new Map();
 const seenTurnKeys = new Set();
 let stopping = false;
@@ -119,6 +126,8 @@ let lastRalphContinueSteer = {
     pane_id: '',
     pane_current_command: '',
     current_phase: '',
+    subagent_session_id: '',
+    active_subagent_thread_ids: [],
     shared_timestamp_path: ralphSteerTimestampPath,
     shared_last_sent_at: '',
     singleton_lock_path: ralphSteerLockPath,
@@ -128,6 +137,14 @@ let lastParentGuard = {
     state_path: '',
     current_phase: '',
 };
+let lastAuthorityBackoff = {
+    active: false,
+    reason: '',
+    primary_pid: null,
+    primary_last_tick_at: '',
+    freshness_ms: null,
+    threshold_ms: null,
+};
 const AUTO_NUDGE_STALL_MS = Math.max(pollMs, asNumber(process.env.OMX_NOTIFY_FALLBACK_AUTO_NUDGE_STALL_MS || '5000', 5000));
 let lastFallbackAutoNudge = {
     enabled: true,
@@ -141,12 +158,106 @@ let lastFallbackAutoNudge = {
     last_nudged_signature: '',
     last_nudged_at: '',
 };
-function eventLog(event) {
-    return appendFile(logPath, `${JSON.stringify({ timestamp: new Date().toISOString(), ...event })}\n`).catch(() => { });
+let adaptivePollState = {
+    enabled: true,
+    base_ms: pollMs,
+    max_ms: idleMaxPollMs,
+    current_ms: pollMs,
+    idle_streak: 0,
+    last_tick_at: null,
+    last_activity_at: null,
+    last_activity_reason: 'init',
+};
+function shouldSuppressEventLog(event) {
+    const eventType = safeString(event.type).trim();
+    return runOnce && QUIET_ONCE_EVENT_TYPES.has(eventType);
+}
+async function acquireLogLock(timeoutMs = 1000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            await mkdir(logLockPath, { recursive: false });
+            return true;
+        }
+        catch (error) {
+            if (error?.code !== 'EEXIST')
+                return false;
+            const lockStat = await stat(logLockPath).catch(() => null);
+            if (lockStat && Date.now() - lockStat.mtimeMs > 5000) {
+                await rm(logLockPath, { recursive: true, force: true }).catch(() => { });
+                continue;
+            }
+            await sleep(10);
+        }
+    }
+    return false;
+}
+async function releaseLogLock() {
+    await rm(logLockPath, { recursive: true, force: true }).catch(() => { });
+}
+async function rotateLogIfNeeded(nextEntryBytes) {
+    if (maxLogBytes <= 0)
+        return;
+    const currentStat = await stat(logPath).catch(() => null);
+    if (!currentStat || currentStat.size + nextEntryBytes <= maxLogBytes)
+        return;
+    await unlink(logRotatePath).catch(() => { });
+    await rename(logPath, logRotatePath).catch(() => { });
+}
+async function eventLog(event) {
+    if (shouldSuppressEventLog(event))
+        return;
+    const line = `${JSON.stringify({ timestamp: new Date().toISOString(), ...event })}\n`;
+    await mkdir(dirname(logPath), { recursive: true }).catch(() => { });
+    const locked = await acquireLogLock();
+    if (!locked)
+        return;
+    try {
+        await rotateLogIfNeeded(Buffer.byteLength(line));
+        await appendFile(logPath, line);
+    }
+    catch {
+        // best effort only
+    }
+    finally {
+        await releaseLogLock();
+    }
 }
 function shouldLogLeaderNudgeTick(reason) {
     return reason === 'leader_nudge_checked' || reason === 'leader_nudge_failed';
 }
+function nextIdlePollMs(currentMs) {
+    return Math.min(idleMaxPollMs, Math.max(pollMs, currentMs * 2));
+}
+function updateAdaptivePollState(summary) {
+    const nowIso = new Date().toISOString();
+    if (summary.active) {
+        adaptivePollState = {
+            ...adaptivePollState,
+            enabled: true,
+            base_ms: pollMs,
+            max_ms: idleMaxPollMs,
+            current_ms: pollMs,
+            idle_streak: 0,
+            last_tick_at: nowIso,
+            last_activity_at: nowIso,
+            last_activity_reason: summary.reason,
+        };
+        return adaptivePollState.current_ms;
+    }
+    const nextMs = nextIdlePollMs(adaptivePollState.current_ms);
+    adaptivePollState = {
+        ...adaptivePollState,
+        enabled: true,
+        base_ms: pollMs,
+        max_ms: idleMaxPollMs,
+        current_ms: nextMs,
+        idle_streak: adaptivePollState.idle_streak + 1,
+        last_tick_at: nowIso,
+        last_activity_reason: summary.reason,
+    };
+    return adaptivePollState.current_ms;
+}
 function shouldLogDispatchDrainTick(result) {
     if (!result || typeof result !== 'object')
         return false;
@@ -176,6 +287,10 @@ function normalizeRalphContinueSteerState(raw) {
         pane_id: safeString(raw.pane_id),
         pane_current_command: safeString(raw.pane_current_command),
         current_phase: safeString(raw.current_phase),
+        subagent_session_id: safeString(raw.subagent_session_id),
+        active_subagent_thread_ids: Array.isArray(raw.active_subagent_thread_ids)
+            ? raw.active_subagent_thread_ids.map((value) => safeString(value).trim()).filter(Boolean)
+            : [],
         shared_timestamp_path: safeString(raw.shared_timestamp_path) || ralphSteerTimestampPath,
         shared_last_sent_at: safeString(raw.shared_last_sent_at),
         singleton_lock_path: safeString(raw.singleton_lock_path) || ralphSteerLockPath,
@@ -215,6 +330,19 @@ async function loadPersistedWatcherState() {
             last_nudged_at: safeString(persistedAutoNudge.last_nudged_at),
         };
     }
+    const persistedAdaptivePoll = persisted?.adaptive_poll;
+    if (persistedAdaptivePoll && typeof persistedAdaptivePoll === 'object') {
+        adaptivePollState = {
+            enabled: persistedAdaptivePoll.enabled !== false,
+            base_ms: pollMs,
+            max_ms: idleMaxPollMs,
+            current_ms: Math.min(idleMaxPollMs, Math.max(pollMs, asNumber(persistedAdaptivePoll.current_ms, pollMs))),
+            idle_streak: Math.max(0, Math.trunc(asNumber(persistedAdaptivePoll.idle_streak, 0))),
+            last_tick_at: safeString(persistedAdaptivePoll.last_tick_at) || null,
+            last_activity_at: safeString(persistedAdaptivePoll.last_activity_at) || null,
+            last_activity_reason: safeString(persistedAdaptivePoll.last_activity_reason) || 'init',
+        };
+    }
 }
 async function resolveActiveModeState(mode) {
     const candidateDirs = [];
@@ -416,7 +544,8 @@ async function withRalphSteerLock(task) {
                 throw error;
             const existing = await readRalphSteerLock(ralphSteerLockPath);
             const lockAgeMs = parseIsoMillis(existing?.acquired_at) ?? 0;
-            const stale = !existing || !isPidAlive(existing.pid) || (lockAgeMs > 0 && Date.now() - lockAgeMs > RALPH_STEER_LOCK_STALE_MS);
+            const stale = existing !== null
+                && (!isPidAlive(existing.pid) || (lockAgeMs > 0 && Date.now() - lockAgeMs > RALPH_STEER_LOCK_STALE_MS));
             if (stale) {
                 await unlink(ralphSteerLockPath).catch(() => { });
                 continue;
@@ -438,23 +567,39 @@ async function withRalphSteerLock(task) {
         }
     }
 }
-async function readRalphProgressGate(now) {
+async function readRalphProgressGate(activeRalphState, now) {
+    const subagentSessionId = safeString(activeRalphState?.owner_codex_session_id).trim();
+    if (subagentSessionId) {
+        const summary = await readSubagentSessionSummary(cwd, subagentSessionId, {
+            now: new Date(now),
+            activeWindowMs: DEFAULT_SUBAGENT_ACTIVE_WINDOW_MS,
+        });
+        if ((summary?.activeSubagentThreadIds.length ?? 0) > 0) {
+            return {
+                allow: false,
+                reason: 'subagents_active',
+                progress_at: '',
+                subagent_session_id: subagentSessionId,
+                active_subagent_thread_ids: summary?.activeSubagentThreadIds ?? [],
+            };
+        }
+    }
     const hudState = await readJsonObject(join(stateDir, 'hud-state.json'));
     if (!hudState || typeof hudState !== 'object') {
-        return { allow: false, reason: 'progress_missing', progress_at: '' };
+        return { allow: false, reason: 'progress_missing', progress_at: '', subagent_session_id: subagentSessionId };
     }
     const progressAt = safeString(hudState.last_progress_at).trim();
     if (!progressAt) {
-        return { allow: false, reason: 'progress_missing', progress_at: '' };
+        return { allow: false, reason: 'progress_missing', progress_at: '', subagent_session_id: subagentSessionId };
     }
     const progressMs = parseIsoMillis(progressAt);
     if (progressMs === null) {
-        return { allow: false, reason: 'progress_invalid', progress_at: progressAt };
+        return { allow: false, reason: 'progress_invalid', progress_at: progressAt, subagent_session_id: subagentSessionId };
     }
     if (now - progressMs < RALPH_CONTINUE_CADENCE_MS) {
-        return { allow: false, reason: 'progress_fresh', progress_at: progressAt };
+        return { allow: false, reason: 'progress_fresh', progress_at: progressAt, subagent_session_id: subagentSessionId };
     }
-    return { allow: true, reason: 'progress_stale', progress_at: progressAt };
+    return { allow: true, reason: 'progress_stale', progress_at: progressAt, subagent_session_id: subagentSessionId };
 }
 function shouldSkipRalphContinue(now, candidateIso, startupIso) {
     const sharedMs = parseIsoMillis(candidateIso);
@@ -497,6 +642,100 @@ async function readPidFileRecord(path) {
         return pid === null ? null : { pid };
     }
 }
+function createAuthorityBackoffState(reason, overrides = {}) {
+    return {
+        active: false,
+        reason,
+        primary_pid: null,
+        primary_last_tick_at: '',
+        freshness_ms: null,
+        threshold_ms: null,
+        ...overrides,
+    };
+}
+function latestWatcherTickIso(state) {
+    if (!state || typeof state !== 'object')
+        return '';
+    const candidates = [
+        safeString(state.dispatch_drain?.last_tick_at),
+        safeString(state.leader_nudge?.last_tick_at),
+        safeString(state.fallback_auto_nudge?.last_tick_at),
+        safeString(state.ralph_continue_steer?.last_state_check_at),
+    ]
+        .map((value) => value.trim())
+        .filter(Boolean);
+    let latestIso = '';
+    let latestMs = -1;
+    for (const candidate of candidates) {
+        const parsed = parseIsoMillis(candidate);
+        if (parsed === null || parsed <= latestMs)
+            continue;
+        latestMs = parsed;
+        latestIso = candidate;
+    }
+    return latestIso;
+}
+async function resolveAuthorityPrimaryWatcherHealth(now = Date.now()) {
+    if (!authorityOnly)
+        return createAuthorityBackoffState('not_authority');
+    const existingRecord = await readPidFileRecord(pidFilePath).catch(() => null);
+    if (!existingRecord)
+        return createAuthorityBackoffState('pid_missing');
+    if (existingRecord.cwd && resolve(existingRecord.cwd) !== cwd)
+        return createAuthorityBackoffState('cwd_mismatch');
+    if (!isPidAlive(existingRecord.pid)) {
+        return createAuthorityBackoffState('pid_stale', {
+            primary_pid: existingRecord.pid,
+        });
+    }
+    const persistedState = await readJsonObject(statePath);
+    if (!persistedState) {
+        return createAuthorityBackoffState('state_missing', {
+            primary_pid: existingRecord.pid,
+        });
+    }
+    const persistedPid = Math.trunc(asNumber(persistedState.pid, 0));
+    if (persistedPid > 0 && persistedPid !== existingRecord.pid) {
+        return createAuthorityBackoffState('state_pid_mismatch', {
+            primary_pid: existingRecord.pid,
+        });
+    }
+    const lastTickAt = latestWatcherTickIso(persistedState);
+    if (!lastTickAt) {
+        return createAuthorityBackoffState('tick_missing', {
+            primary_pid: existingRecord.pid,
+        });
+    }
+    const lastTickMs = parseIsoMillis(lastTickAt);
+    const primaryPollMs = Math.max(50, asNumber(persistedState.poll_ms, 250));
+    const thresholdMs = Math.max(1_000, primaryPollMs * 4);
+    if (lastTickMs === null) {
+        return createAuthorityBackoffState('tick_invalid', {
+            primary_pid: existingRecord.pid,
+            primary_last_tick_at: lastTickAt,
+            threshold_ms: thresholdMs,
+        });
+    }
+    const freshnessMs = now - lastTickMs;
+    if (freshnessMs > thresholdMs) {
+        return {
+            active: false,
+            reason: 'tick_stale',
+            primary_pid: existingRecord.pid,
+            primary_last_tick_at: lastTickAt,
+            freshness_ms: freshnessMs,
+            threshold_ms: thresholdMs,
+        };
+    }
+    return {
+        active: true,
+        reason: 'primary_watcher_healthy',
+        primary_pid: existingRecord.pid,
+        primary_last_tick_at: lastTickAt,
+        freshness_ms: freshnessMs,
+        threshold_ms: thresholdMs,
+    };
+}
 async function writePidFileRecord() {
     const nextRecord = {
         pid: process.pid,
@@ -524,6 +763,8 @@ async function runRalphContinueSteerTick() {
         state_path: activeRalph.path,
         pane_id: activePaneId,
         pane_current_command: '',
+        subagent_session_id: safeString(activeRalph.state?.owner_codex_session_id).trim(),
+        active_subagent_thread_ids: [],
         shared_timestamp_path: ralphSteerTimestampPath,
         singleton_lock_path: ralphSteerLockPath,
     };
@@ -553,9 +794,11 @@ async function runRalphContinueSteerTick() {
             }
             return { sent: false, skipped: true };
         }
-        const progressGate = await readRalphProgressGate(Date.now());
+        const progressGate = await readRalphProgressGate(activeRalph.state, Date.now());
         if (!progressGate.allow) {
             lastRalphContinueSteer.last_reason = progressGate.reason;
+            lastRalphContinueSteer.subagent_session_id = progressGate.subagent_session_id ?? lastRalphContinueSteer.subagent_session_id;
+            lastRalphContinueSteer.active_subagent_thread_ids = progressGate.active_subagent_thread_ids ?? [];
             return { sent: false, skipped: true };
         }
         const paneId = safeString(activeRalph.state?.tmux_pane_id).trim();
@@ -675,6 +918,8 @@ async function writeState(extra = {}) {
         notify_script: notifyScript,
         authority_only: authorityOnly,
         poll_ms: pollMs,
+        effective_poll_ms: adaptivePollState.current_ms,
+        idle_max_poll_ms: idleMaxPollMs,
         pid_file: runOnce ? null : pidFilePath,
         max_lifetime_ms: maxLifetimeMs,
         tracked_files: fileState.size,
@@ -701,10 +946,25 @@ async function writeState(extra = {}) {
             enabled: true,
             stall_ms: AUTO_NUDGE_STALL_MS,
         },
+        authority_backoff: lastAuthorityBackoff,
+        adaptive_poll: {
+            ...adaptivePollState,
+            enabled: true,
+            base_ms: pollMs,
+            max_ms: idleMaxPollMs,
+        },
         ...extra,
     };
     await writeFile(statePath, JSON.stringify(state, null, 2)).catch(() => { });
 }
+async function writeAuthorityBackoffState() {
+    await mkdir(stateDir, { recursive: true }).catch(() => { });
+    const existing = await readJsonObject(statePath);
+    const state = existing && typeof existing === 'object'
+        ? { ...existing, authority_backoff: lastAuthorityBackoff }
+        : { authority_backoff: lastAuthorityBackoff };
+    await writeFile(statePath, JSON.stringify(state, null, 2)).catch(() => { });
+}
 async function readJsonObject(path) {
     return readFile(path, 'utf-8')
         .then((content) => JSON.parse(content))
@@ -1020,6 +1280,7 @@ function splitBufferedLines(partial, delta) {
     };
 }
 async function pollFiles() {
+    let processedCount = 0;
     for (const [path, meta] of fileState.entries()) {
         const currentSize = (await stat(path).catch(() => ({ size: 0 }))).size || 0;
         if (currentSize <= meta.offset)
@@ -1036,8 +1297,10 @@ async function pollFiles() {
             if (!line.trim())
                 continue;
             await processLine(meta, line, path);
+            processedCount += 1;
         }
     }
+    return processedCount;
 }
 async function runLeaderNudgeTick() {
     const startedIso = new Date().toISOString();
@@ -1053,7 +1316,7 @@ async function runLeaderNudgeTick() {
             last_tick_at: startedIso,
             last_error: 'worker_context',
         };
-        return;
+        return false;
     }
     try {
         const preComputedLeaderStale = await isLeaderStale(stateDir, staleThresholdMs, Date.now());
@@ -1063,6 +1326,7 @@ async function runLeaderNudgeTick() {
             logsDir,
             preComputedLeaderStale,
             allowFreshMailboxNudges: false,
+            source: 'notify_fallback_watcher',
         });
         leaderNudgeRuns += 1;
         lastLeaderNudge = {
@@ -1084,6 +1348,7 @@ async function runLeaderNudgeTick() {
                 reason,
             });
         }
+        return preComputedLeaderStale;
     }
     catch (err) {
         leaderNudgeRuns += 1;
@@ -1103,6 +1368,7 @@ async function runLeaderNudgeTick() {
             reason: 'leader_nudge_failed',
             error: lastLeaderNudge.last_error,
         });
+        return true;
     }
 }
 async function runDispatchDrainTick() {
@@ -1125,6 +1391,7 @@ async function runDispatchDrainTick() {
                 ...(result && typeof result === 'object' ? result : {}),
             });
         }
+        return shouldLogDispatchDrainTick(result);
     }
     catch (err) {
         dispatchDrainRuns += 1;
@@ -1142,6 +1409,7 @@ async function runDispatchDrainTick() {
             reason: 'dispatch_drain_failed',
             error: lastDispatchDrain.last_error,
         });
+        return true;
     }
 }
 async function shouldSuppressInteractiveFallbackTicks() {
@@ -1152,34 +1420,65 @@ async function shouldSuppressInteractiveFallbackTicks() {
     return deepInterviewStateActive || deepInterviewInputLockActive;
 }
 async function pumpTeamControlPlaneTick() {
-    await runDispatchDrainTick();
-    if (await shouldSuppressInteractiveFallbackTicks())
-        return;
-    await runLeaderNudgeTick();
+    const dispatchActive = await runDispatchDrainTick();
+    if (await shouldSuppressInteractiveFallbackTicks()) {
+        return { active: dispatchActive, reason: dispatchActive ? 'dispatch_drain' : 'deep_interview_locked' };
+    }
+    const leaderActive = await runLeaderNudgeTick();
     await runFallbackAutoNudgeTick();
+    const autoNudgeActive = lastFallbackAutoNudge.last_reason === 'sent';
+    if (dispatchActive)
+        return { active: true, reason: 'dispatch_drain' };
+    if (leaderActive)
+        return { active: true, reason: 'leader_nudge' };
+    if (autoNudgeActive)
+        return { active: true, reason: 'fallback_auto_nudge' };
+    return { active: false, reason: lastFallbackAutoNudge.last_reason || 'control_plane_idle' };
 }
 async function runWatcherCycle() {
+    let processedRolloutCount = 0;
+    if (authorityOnly) {
+        const authorityBackoff = await resolveAuthorityPrimaryWatcherHealth();
+        lastAuthorityBackoff = authorityBackoff;
+        if (authorityBackoff.active) {
+            await writeAuthorityBackoffState();
+            return processedRolloutCount;
+        }
+    }
+    else {
+        lastAuthorityBackoff = createAuthorityBackoffState('');
+    }
     if (!authorityOnly) {
         await ensureTrackedFiles();
-        await pollFiles();
+        processedRolloutCount = await pollFiles();
     }
-    await pumpTeamControlPlaneTick();
+    const controlPlaneSummary = await pumpTeamControlPlaneTick();
     if (!authorityOnly && !(await shouldSuppressInteractiveFallbackTicks())) {
         await runRalphWatcherBehaviorTick();
     }
-    await writeState();
+    const ralphActive = lastRalphContinueSteer.last_reason === 'sent';
+    const summary = processedRolloutCount > 0
+        ? { active: true, reason: 'rollout_event' }
+        : controlPlaneSummary.active
+            ? controlPlaneSummary
+            : ralphActive
+                ? { active: true, reason: 'ralph_continue_steer' }
+                : { active: false, reason: controlPlaneSummary.reason || lastRalphContinueSteer.last_reason || 'idle' };
+    const nextDelayMs = updateAdaptivePollState(summary);
+    await writeState({ last_cycle_activity: summary.reason });
+    return nextDelayMs;
 }
 async function tick() {
     if (stopping)
         return;
     if (await enforceLifecycleGuards())
         return;
-    await runWatcherCycle();
+    const nextDelayMs = await runWatcherCycle();
     if (await enforceLifecycleGuards())
         return;
     setTimeout(() => {
         void tick();
-    }, pollMs);
+    }, nextDelayMs);
 }
 function shutdown(signal) {
     void requestShutdown('signal', signal);
@@ -1200,6 +1499,8 @@ async function main() {
             notify_script: notifyScript,
             authority_only: authorityOnly,
             poll_ms: pollMs,
+            effective_poll_ms: adaptivePollState.current_ms,
+            idle_max_poll_ms: idleMaxPollMs,
             once: runOnce,
             parent_pid: parentPid,
             pid_file: runOnce ? null : pidFilePath,