oh-my-codex 0.18.13 → 0.18.15

package/dist/scripts/notify-hook/team-leader-nudge.d.ts

@@ -1,6 +1,7 @@
 /**
  * Team leader nudge: remind the leader to check teammate/mailbox state.
  */
+export declare function setLeaderNudgeTestHooksForTests(hooks?: {}): void;
 export declare function resolveLeaderNudgeIntervalMs(): number;
 export declare function resolveLeaderAllIdleNudgeCooldownMs(): number;
 export declare function resolveLeaderStalenessThresholdMs(): number;

package/dist/scripts/notify-hook/team-leader-nudge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"team-leader-nudge.d.ts","sourceRoot":"","sources":["../../../src/scripts/notify-hook/team-leader-nudge.ts"],"names":[],"mappings":"AACA;;GAEG;AAmDH,wBAAgB,4BAA4B,WAM3C;AAED,wBAAgB,mCAAmC,WAMlD;AAED,wBAAgB,iCAAiC,WAMhD;AAgED,wBAAsB,qBAAqB,CAAC,UAAU,KAAA,EAAE,aAAa,UAAK;;;GAoBzE;AAED,wBAAsB,aAAa,CAAC,QAAQ,KAAA,EAAE,WAAW,KAAA,EAAE,KAAK,KAAA,oBAE/D;AA6UD,wBAAsB,kBAAkB,CAAC,GAAG,KAAA,EAAE,QAAQ,KAAA,EAAE,MAAM,KAAA,EAAE,mBAAmB,KAAA,EAAE,MAAM,KAAA,iBAkB1F;AA4BD,wBAAsB,oBAAoB,CAAC,EACzC,GAAG,EACH,QAAQ,EACR,OAAO,EACP,sBAAsB,EACtB,uBAA8B,EAC9B,MAAsB,GACvB;;;;;;;CAAA,iBAqgBA"}
+{"version":3,"file":"team-leader-nudge.d.ts","sourceRoot":"","sources":["../../../src/scripts/notify-hook/team-leader-nudge.ts"],"names":[],"mappings":"AACA;;GAEG;AA+CH,wBAAgB,+BAA+B,CAAC,KAAK,KAAK,QAazD;AA8FD,wBAAgB,4BAA4B,WAM3C;AAED,wBAAgB,mCAAmC,WAMlD;AAED,wBAAgB,iCAAiC,WAMhD;AAgED,wBAAsB,qBAAqB,CAAC,UAAU,KAAA,EAAE,aAAa,UAAK;;;GAoBzE;AAED,wBAAsB,aAAa,CAAC,QAAQ,KAAA,EAAE,WAAW,KAAA,EAAE,KAAK,KAAA,oBAE/D;AA6UD,wBAAsB,kBAAkB,CAAC,GAAG,KAAA,EAAE,QAAQ,KAAA,EAAE,MAAM,KAAA,EAAE,mBAAmB,KAAA,EAAE,MAAM,KAAA,iBAkB1F;AA4BD,wBAAsB,oBAAoB,CAAC,EACzC,GAAG,EACH,QAAQ,EACR,OAAO,EACP,sBAAsB,EACtB,uBAA8B,EAC9B,MAAsB,GACvB;;;;;;;CAAA,iBA6mBA"}

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

@@ -2,7 +2,7 @@
 /**
  * Team leader nudge: remind the leader to check teammate/mailbox state.
  */
-import { readFile, writeFile, mkdir, appendFile, readdir } from 'fs/promises';
+import { readFile, writeFile, mkdir, appendFile, readdir, rename, unlink } from 'fs/promises';
 import { existsSync } from 'fs';
 import { join, resolve } from 'path';
 import { readUsableSessionState } from '../../hooks/session.js';
@@ -17,13 +17,13 @@ import { classifyLeaderActionState, resolveLeaderNudgeIntent, } from './orchestr
 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 TEAM_SHUTDOWN_NO_INJECTION_REASON = 'team_state_gone_or_shutdown';
 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';
@@ -32,6 +32,99 @@ const ACK_LIKE_PATTERNS = [
     /^(?:ok|okay|k|roger|copy|received|got it|understood|sounds good)[.!]*$/i,
     /^(?:on it|will do|i(?:'|')ll do it|working on it)[.!]*$/i,
 ];
+let atomicJsonWriteCounter = 0;
+// Synchronous test-only callbacks let regression tests emulate filesystem races
+// without shipping env-gated destructive fault injection in the notify hook.
+const leaderNudgeTestHooks = {
+    beforeLeaderAttentionRename: null,
+    afterLeaderAttentionRename: null,
+    beforeGlobalNudgeStateRename: null,
+    afterGlobalNudgeStateRename: null,
+};
+export function setLeaderNudgeTestHooksForTests(hooks = {}) {
+    leaderNudgeTestHooks.beforeLeaderAttentionRename = typeof hooks.beforeLeaderAttentionRename === 'function'
+        ? hooks.beforeLeaderAttentionRename
+        : null;
+    leaderNudgeTestHooks.afterLeaderAttentionRename = typeof hooks.afterLeaderAttentionRename === 'function'
+        ? hooks.afterLeaderAttentionRename
+        : null;
+    leaderNudgeTestHooks.beforeGlobalNudgeStateRename = typeof hooks.beforeGlobalNudgeStateRename === 'function'
+        ? hooks.beforeGlobalNudgeStateRename
+        : null;
+    leaderNudgeTestHooks.afterGlobalNudgeStateRename = typeof hooks.afterGlobalNudgeStateRename === 'function'
+        ? hooks.afterGlobalNudgeStateRename
+        : null;
+}
+async function atomicWriteJsonNoParentCreate(path, value, { beforeRename = null, afterRename = null } = {}) {
+    const tempPath = `${path}.${process.pid}.${Date.now()}.${++atomicJsonWriteCounter}.tmp`;
+    try {
+        await writeFile(tempPath, JSON.stringify(value, null, 2));
+        if (beforeRename)
+            await beforeRename(tempPath);
+        await rename(tempPath, path);
+        if (afterRename)
+            await afterRename(path);
+    }
+    catch (error) {
+        await unlink(tempPath).catch(() => { });
+        throw error;
+    }
+}
+function cloneLeaderNudgeState(state) {
+    return {
+        ...(state && typeof state === 'object' ? state : {}),
+        last_nudged_by_team: { ...(state?.last_nudged_by_team || {}) },
+        last_idle_nudged_by_team: { ...(state?.last_idle_nudged_by_team || {}) },
+        progress_by_team: { ...(state?.progress_by_team || {}) },
+    };
+}
+function removeTeamFromLeaderNudgeState(state, teamName) {
+    if (state?.progress_by_team && typeof state.progress_by_team === 'object') {
+        delete state.progress_by_team[teamName];
+    }
+    if (state?.last_nudged_by_team && typeof state.last_nudged_by_team === 'object') {
+        delete state.last_nudged_by_team[teamName];
+    }
+    if (state?.last_idle_nudged_by_team && typeof state.last_idle_nudged_by_team === 'object') {
+        delete state.last_idle_nudged_by_team[teamName];
+    }
+}
+async function teamStateAllowsLeaderNudge(stateDir, teamName) {
+    const teamDir = join(stateDir, 'team', teamName);
+    if (!existsSync(teamDir))
+        return false;
+    if (existsSync(join(teamDir, 'shutdown.json')))
+        return false;
+    const phase = await readJsonIfExists(join(teamDir, 'phase.json'), null);
+    const currentPhase = safeString(phase?.current_phase || phase?.phase || '').trim();
+    if (currentPhase && isTerminalPhase(currentPhase))
+        return false;
+    return true;
+}
+async function recordSuppressedLeaderNudge({ logsDir, source, teamName, reason, orchestrationIntent = null, }) {
+    const nowIso = new Date().toISOString();
+    await logTmuxHookEvent(logsDir, {
+        timestamp: nowIso,
+        type: 'team_leader_nudge_suppressed',
+        team: teamName,
+        worker: 'leader-fixed',
+        to_worker: 'leader-fixed',
+        reason,
+        orchestration_intent: orchestrationIntent,
+        tmux_injection_attempted: false,
+        source_type: 'leader_nudge',
+    }).catch(() => { });
+    await appendTeamDeliveryLog(logsDir, {
+        event: 'nudge_triggered',
+        source,
+        team: teamName,
+        to_worker: 'leader-fixed',
+        transport: 'none',
+        result: 'suppressed',
+        reason,
+        orchestration_intent: orchestrationIntent,
+    }).catch(() => { });
+}
 function normalizeValidSessionId(value) {
     const trimmed = safeString(value).trim();
     if (!trimmed)
@@ -579,6 +672,15 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
     // Use pre-computed staleness (captured before HUD state was updated this turn)
     const leaderStale = typeof preComputedLeaderStale === 'boolean' ? preComputedLeaderStale : false;
     for (const teamName of candidateTeamNames) {
+        if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+            await recordSuppressedLeaderNudge({
+                logsDir,
+                source,
+                teamName,
+                reason: TEAM_SHUTDOWN_NO_INJECTION_REASON,
+            });
+            continue;
+        }
         let tmuxSession = '';
         let leaderPaneId = '';
         let ownerSessionId = '';
@@ -736,58 +838,158 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
             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,
+        const recordShutdownSuppression = async (orchestrationIntent = null) => {
+            await recordSuppressedLeaderNudge({
+                logsDir,
+                source,
+                teamName,
+                reason: TEAM_SHUTDOWN_NO_INJECTION_REASON,
+                orchestrationIntent,
+            });
         };
-        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)
+        const cleanupTeamPersistence = async () => {
+            await unlink(join(stateDir, 'team', teamName, 'leader-attention.json')).catch(() => { });
+            const latestState = await readJsonIfExists(nudgeStatePath, nudgeState);
+            const cleanedState = cloneLeaderNudgeState(latestState);
+            removeTeamFromLeaderNudgeState(cleanedState, teamName);
+            nudgeState = cleanedState;
+            await atomicWriteJsonNoParentCreate(nudgeStatePath, cleanedState).catch(() => { });
+        };
+        const persistLeaderNudgeBookkeeping = async ({ orchestrationIntent = null, recordLastNudged = false } = {}) => {
+            if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+                await recordShutdownSuppression(orchestrationIntent);
+                return false;
+            }
+            const leaderAttention = {
+                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,
+            };
+            const leaderAttentionPath = join(stateDir, 'team', teamName, 'leader-attention.json');
+            try {
+                await atomicWriteJsonNoParentCreate(leaderAttentionPath, leaderAttention, {
+                    beforeRename: async (tempPath) => {
+                        if (leaderNudgeTestHooks.beforeLeaderAttentionRename) {
+                            await leaderNudgeTestHooks.beforeLeaderAttentionRename({ stateDir, teamName, tempPath });
+                        }
+                        if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+                            throw new Error('team_state_gone_or_shutdown_before_leader_attention_rename');
+                        }
+                    },
+                    afterRename: async () => {
+                        if (leaderNudgeTestHooks.afterLeaderAttentionRename) {
+                            await leaderNudgeTestHooks.afterLeaderAttentionRename({ stateDir, teamName, path: leaderAttentionPath });
+                        }
+                    },
+                });
+            }
+            catch {
+                await unlink(leaderAttentionPath).catch(() => { });
+                await recordShutdownSuppression(orchestrationIntent);
+                return false;
+            }
+            if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+                await cleanupTeamPersistence();
+                await recordShutdownSuppression(orchestrationIntent);
+                return false;
+            }
+            const nextNudgeState = cloneLeaderNudgeState(nudgeState);
+            nextNudgeState.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,
+            };
+            if (recordLastNudged) {
+                nextNudgeState.last_nudged_by_team[teamName] = {
+                    at: nowIso,
+                    last_message_id: newestId || prevMsgId || '',
+                    reason: nudgeReason,
+                    orchestration_intent: orchestrationIntent,
+                };
+                if (shouldSendAllIdleNudge) {
+                    nextNudgeState.last_idle_nudged_by_team[teamName] = {
+                        at: nowIso,
+                        worker_count: workerNames.length,
+                        orchestration_intent: orchestrationIntent,
+                    };
+                }
+            }
+            try {
+                await atomicWriteJsonNoParentCreate(nudgeStatePath, nextNudgeState, {
+                    beforeRename: async (tempPath) => {
+                        if (leaderNudgeTestHooks.beforeGlobalNudgeStateRename) {
+                            await leaderNudgeTestHooks.beforeGlobalNudgeStateRename({ stateDir, teamName, tempPath });
+                        }
+                        if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+                            throw new Error('team_state_gone_or_shutdown_before_nudge_state_rename');
+                        }
+                    },
+                    afterRename: async () => {
+                        if (leaderNudgeTestHooks.afterGlobalNudgeStateRename) {
+                            await leaderNudgeTestHooks.afterGlobalNudgeStateRename({ stateDir, teamName, path: nudgeStatePath });
+                        }
+                    },
+                });
+            }
+            catch {
+                await cleanupTeamPersistence();
+                await recordShutdownSuppression(orchestrationIntent);
+                return false;
+            }
+            if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+                await cleanupTeamPersistence();
+                await recordShutdownSuppression(orchestrationIntent);
+                return false;
+            }
+            nudgeState = nextNudgeState;
+            return true;
+        };
+        if (!nudgeReason) {
+            if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+                await recordShutdownSuppression();
+                continue;
+            }
+            await persistLeaderNudgeBookkeeping();
             continue;
+        }
         const orchestrationIntent = resolveLeaderNudgeIntent({ nudgeReason, leaderActionState });
+        if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+            await recordShutdownSuppression(orchestrationIntent);
+            continue;
+        }
         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,
-                };
+            if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+                await recordShutdownSuppression(orchestrationIntent);
+                continue;
+            }
+            if (!(await persistLeaderNudgeBookkeeping({ orchestrationIntent, recordLastNudged: true }))) {
+                continue;
             }
             await emitLeaderNudgeDeferredEvent(cwd, teamName, LEADER_PANE_MISSING_NO_INJECTION_REASON, orchestrationIntent, nowIso, {
                 tmuxSession,
@@ -834,18 +1036,12 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
             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,
-                };
+            if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+                await recordShutdownSuppression(orchestrationIntent);
+                continue;
+            }
+            if (!(await persistLeaderNudgeBookkeeping({ orchestrationIntent, recordLastNudged: true }))) {
+                continue;
             }
             await emitLeaderNudgeDeferredEvent(cwd, teamName, deferredReason, orchestrationIntent, nowIso, {
                 tmuxSession,
@@ -886,18 +1082,12 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
             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,
-                };
+            if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+                await recordShutdownSuppression(orchestrationIntent);
+                continue;
+            }
+            if (!(await persistLeaderNudgeBookkeeping({ orchestrationIntent, recordLastNudged: true }))) {
+                continue;
             }
             await emitTeamNudgeEvent(cwd, teamName, nudgeReason, orchestrationIntent, nowIso);
             try {
@@ -932,6 +1122,10 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
             }).catch(() => { });
             continue;
         }
+        if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+            await recordShutdownSuppression(orchestrationIntent);
+            continue;
+        }
         try {
             const leaderHasActiveTask = paneHasActiveTask(paneGuard.paneCapture);
             let deliveryMode = 'sent';
@@ -956,20 +1150,16 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
                     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,
-                };
+            if (await teamStateAllowsLeaderNudge(stateDir, teamName)) {
+                if (!(await persistLeaderNudgeBookkeeping({ orchestrationIntent, recordLastNudged: true }))) {
+                    continue;
+                }
+                await emitTeamNudgeEvent(cwd, teamName, nudgeReason, orchestrationIntent, nowIso);
+            }
+            else {
+                await recordShutdownSuppression(orchestrationIntent);
+                continue;
             }
-            await emitTeamNudgeEvent(cwd, teamName, nudgeReason, orchestrationIntent, nowIso);
             try {
                 await logTmuxHookEvent(logsDir, {
                     timestamp: nowIso,
@@ -999,6 +1189,10 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
             }).catch(() => { });
         }
         catch (err) {
+            if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+                await recordShutdownSuppression(orchestrationIntent);
+                continue;
+            }
             try {
                 await logTmuxHookEvent(logsDir, {
                     timestamp: nowIso,
@@ -1024,6 +1218,5 @@ export async function maybeNudgeTeamLeader({ cwd, stateDir, logsDir, preComputed
             }).catch(() => { });
         }
     }
-    await writeFile(nudgeStatePath, JSON.stringify(nudgeState, null, 2)).catch(() => { });
 }
 //# sourceMappingURL=team-leader-nudge.js.map