mixdog 0.9.16 → 0.9.17

package/src/tui/engine/tui-steering-persist.mjs

@@ -3,12 +3,25 @@
 import { randomBytes } from 'crypto';
 import { join } from 'path';
 import { resolvePluginData } from '../../runtime/shared/plugin-paths.mjs';
-import { updateJsonAtomicSync } from '../../runtime/shared/atomic-file.mjs';
+import { updateJsonAtomic } from '../../runtime/shared/atomic-file.mjs';
 import { promptContentText } from './queue-helpers.mjs';
 
 const PENDING_MESSAGES_FILE = 'session-pending-messages.json';
 const PENDING_MESSAGES_MODE = 0o600;
 
+// Serialize this UI process's own steering writes so append→drop→drain keep
+// their issue order even though each now waits on the lock asynchronously.
+// Cross-process mutual exclusion still comes from the shared lock protocol;
+// this chain only orders same-process operations that were previously
+// naturally ordered by the synchronous call site.
+let _persistChain = Promise.resolve();
+function _serialize(task) {
+  const run = _persistChain.then(task, task);
+  // Never let a rejection poison the chain; each op logs its own error.
+  _persistChain = run.catch(() => {});
+  return run;
+}
+
 function pendingMessagesPath() {
   return join(resolvePluginData(), PENDING_MESSAGES_FILE);
 }
@@ -93,15 +106,20 @@ function removePersistRow(q, entry) {
   if (idx >= 0) q.splice(idx, 1);
 }
 
+// Consistency-required: a dropped append loses a user's queued steering
+// message, so we async-wait for the lock (never try-once). Returns a promise;
+// fire-and-forget at call sites is fine — _serialize keeps append/drop/drain
+// in issue order and the write never blocks the render loop.
 export function appendTuiSteeringPersist(leadSessionId, entry) {
   const text = entryPersistText(entry);
-  if (!text) return;
+  if (!text) return Promise.resolve();
   const key = tuiSteeringSessionKey(leadSessionId);
-  if (!key) return;
+  if (!key) return Promise.resolve();
   if (!entry.steeringPersistId) entry.steeringPersistId = newSteeringPersistId();
   const record = { id: entry.steeringPersistId, text };
-  try {
-    updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
+  return _serialize(async () => {
+    try {
+      await updateJsonAtomic(pendingMessagesPath(), (raw) => {
       const next = normalizePendingStore(raw);
       const q = Array.isArray(next.sessions[key]) ? next.sessions[key] : [];
       q.push(record);
@@ -110,19 +128,21 @@ export function appendTuiSteeringPersist(leadSessionId, entry) {
       next.updatedAt = now;
       touchPendingSessionEntry(next, key, now);
       return next;
-    }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
-  } catch (err) {
-    try { process.stderr.write(`[tui] steering-queue append failed sessionId=${leadSessionId}: ${err?.message || err}\n`); } catch {}
-  }
+      }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
+    } catch (err) {
+      try { process.stderr.write(`[tui] steering-queue append failed sessionId=${leadSessionId}: ${err?.message || err}\n`); } catch {}
+    }
+  });
 }
 
 export function dropTuiSteeringPersist(leadSessionId, entries) {
   const key = tuiSteeringSessionKey(leadSessionId);
-  if (!key) return;
+  if (!key) return Promise.resolve();
   const batch = Array.isArray(entries) ? entries : [];
-  if (batch.length === 0) return;
-  try {
-    updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
+  if (batch.length === 0) return Promise.resolve();
+  return _serialize(async () => {
+    try {
+      await updateJsonAtomic(pendingMessagesPath(), (raw) => {
       const next = normalizePendingStore(raw);
       const q = Array.isArray(next.sessions[key]) ? next.sessions[key].slice() : [];
       if (q.length === 0) return undefined;
@@ -137,10 +157,15 @@ export function dropTuiSteeringPersist(leadSessionId, entries) {
       }
       next.updatedAt = Date.now();
       return next;
-    }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
-  } catch (err) {
-    try { process.stderr.write(`[tui] steering-queue drop failed sessionId=${leadSessionId}: ${err?.message || err}\n`); } catch {}
-  }
+      }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
+    } catch (err) {
+      try { process.stderr.write(`[tui] steering-queue drop failed sessionId=${leadSessionId}: ${err?.message || err}\n`); } catch {}
+    }
+  });
+}
+
+export function flushTuiSteeringPersist() {
+  return _persistChain.catch(() => {});
 }
 
 function drainedRowToRestore(row) {
@@ -153,23 +178,29 @@ function drainedRowToRestore(row) {
   return null;
 }
 
+// Consistency-required (restores queued messages after boot/command). Async
+// lock wait, serialized on _persistChain so it never reorders against a
+// pending append/drop and never blocks the render loop. Returns a promise of
+// the drained rows; call sites await it.
 export function drainTuiSteeringPersist(leadSessionId) {
   const key = tuiSteeringSessionKey(leadSessionId);
-  if (!key) return [];
-  let drained = [];
-  try {
-    updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
-      const next = normalizePendingStore(raw);
-      const q = Array.isArray(next.sessions[key]) ? next.sessions[key] : [];
-      drained = q.map(drainedRowToRestore).filter(Boolean);
-      if (drained.length === 0) return undefined;
-      delete next.sessions[key];
-      if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
-      next.updatedAt = Date.now();
-      return next;
-    }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
-  } catch (err) {
-    try { process.stderr.write(`[tui] steering-queue drain failed sessionId=${leadSessionId}: ${err?.message || err}\n`); } catch {}
-  }
-  return drained;
-}
+  if (!key) return Promise.resolve([]);
+  return _serialize(async () => {
+    let drained = [];
+    try {
+      await updateJsonAtomic(pendingMessagesPath(), (raw) => {
+        const next = normalizePendingStore(raw);
+        const q = Array.isArray(next.sessions[key]) ? next.sessions[key] : [];
+        drained = q.map(drainedRowToRestore).filter(Boolean);
+        if (drained.length === 0) return undefined;
+        delete next.sessions[key];
+        if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
+        next.updatedAt = Date.now();
+        return next;
+      }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
+    } catch (err) {
+      try { process.stderr.write(`[tui] steering-queue drain failed sessionId=${leadSessionId}: ${err?.message || err}\n`); } catch {}
+    }
+    return drained;
+  });
+}

package/src/tui/engine.mjs

@@ -84,6 +84,7 @@ import {
   appendTuiSteeringPersist,
   dropTuiSteeringPersist,
   drainTuiSteeringPersist,
+  flushTuiSteeringPersist,
 } from './engine/tui-steering-persist.mjs';
 
 // Source tests resolve from src/tui/engine.mjs; the built bundle resolves from
@@ -1814,8 +1815,8 @@ export async function createEngineSession({
     return out;
   }
 
-  function restoreLeadSteeringFromDisk() {
-    const rows = drainTuiSteeringPersist(leadSessionId());
+  async function restoreLeadSteeringFromDisk() {
+    const rows = await drainTuiSteeringPersist(leadSessionId());
     if (!rows.length) return;
     const restored = [];
     for (const row of rows) {
@@ -2017,7 +2018,7 @@ export async function createEngineSession({
     return state.stats;
   };
 
-  restoreLeadSteeringFromDisk();
+  void restoreLeadSteeringFromDisk();
 
   return {
     getState: () => state,
@@ -2987,7 +2988,7 @@ export async function createEngineSession({
           ...routeState(),
           stats: { ...state.stats },
         });
-        restoreLeadSteeringFromDisk();
+        void restoreLeadSteeringFromDisk();
         return true;
       } finally {
         set({ commandBusy: false, commandStatus: null });
@@ -3004,6 +3005,7 @@ export async function createEngineSession({
       try { unsubscribeRemoteState?.(); } catch {}
       unsubscribeRemoteState = null;
       denyAllToolApprovals('runtime closing');
+      await flushTuiSteeringPersist();
       await runtime.close(reason, options);
       listeners.clear();
     },

package/src/tui/index.jsx

@@ -32,38 +32,123 @@ const EXIT_HARD_DELAY_MS = positiveIntEnv('MIXDOG_TUI_HARD_EXIT_DELAY_MS', 500);
 const EXIT_HARD_ENABLED = !/^(0|false|no|off)$/i.test(String(process.env.MIXDOG_TUI_HARD_EXIT || '1'));
 const EXIT_DEBUG_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_TUI_EXIT_DEBUG || ''));
 const PERF_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_TUI_PERF || ''));
+const LOOP_PROBE_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_TUI_LOOP_PROBE || ''));
+const LOOP_PROBE_INTERVAL_MS = 1000;
+const LOOP_PROBE_DRIFT_THRESHOLD_MS = 200;
 
 function positiveIntEnv(name, fallback) {
   const value = Number(process.env[name]);
   return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
 }
 
+// Opt-in event-loop stall probe (MIXDOG_TUI_LOOP_PROBE=1). A setInterval that
+// measures its own scheduling drift: if the loop is blocked (sync file lock,
+// heavy render, GC), the callback fires late and drift = actual - expected.
+// Logs `[mixdog-loop] stall=NNNms` via the same stderr surface the TUI guard
+// captures. unref'd so it never keeps the process alive.
+function installTuiLoopProbe() {
+  if (!LOOP_PROBE_ENABLED) return () => {};
+  let last = performance.now();
+  const timer = setInterval(() => {
+    const now = performance.now();
+    const drift = (now - last) - LOOP_PROBE_INTERVAL_MS;
+    last = now;
+    if (drift > LOOP_PROBE_DRIFT_THRESHOLD_MS) {
+      try { process.stderr.write(`[mixdog-loop] stall=${drift.toFixed(0)}ms\n`); } catch { /* ignore */ }
+    }
+  }, LOOP_PROBE_INTERVAL_MS);
+  timer.unref?.();
+  return () => { try { clearInterval(timer); } catch { /* ignore */ } };
+}
+
 // Lightweight render-frame profiler. Forked ink calls options.onRender with the
 // per-frame render() wall time (renderNodeToOutput serialization). We aggregate
 // and emit a rolling summary every PERF_REPORT_EVERY frames so typing latency
 // can be measured without flooding output. Entirely no-op unless
 // MIXDOG_TUI_PERF=1, so it costs nothing in normal runs.
 const PERF_REPORT_EVERY = positiveIntEnv('MIXDOG_TUI_PERF_EVERY', 60);
+const PERF_STALL_INTERVAL_MS = positiveIntEnv('MIXDOG_TUI_PERF_STALL_INTERVAL_MS', 100);
+const PERF_STALL_THRESHOLD_MS = positiveIntEnv('MIXDOG_TUI_PERF_STALL_MS', 80);
+const PERF_RENDER_GAP_MS = positiveIntEnv('MIXDOG_TUI_PERF_RENDER_GAP_MS', 120);
+
+function perfLog(event, fields = {}) {
+  if (!PERF_ENABLED) return;
+  const elapsedMs = performance.now() - BOOT_PROFILE_START;
+  const parts = [`[mixdog-perf] +${elapsedMs.toFixed(1)}ms`, event];
+  for (const [key, value] of Object.entries(fields || {})) {
+    if (value === undefined || value === null || value === '') continue;
+    parts.push(`${key}=${String(value).replace(/\s+/g, '_')}`);
+  }
+  try { process.stderr.write(`${parts.join(' ')}\n`); } catch { /* ignore */ }
+}
+
+function installTuiPerfProbe() {
+  if (!PERF_ENABLED) return () => {};
+  let last = performance.now();
+  let lastCpu = process.cpuUsage();
+  perfLog('probe:start', {
+    intervalMs: PERF_STALL_INTERVAL_MS,
+    stallMs: PERF_STALL_THRESHOLD_MS,
+    renderGapMs: PERF_RENDER_GAP_MS,
+  });
+  const timer = setInterval(() => {
+    const now = performance.now();
+    const elapsed = now - last;
+    const lagMs = elapsed - PERF_STALL_INTERVAL_MS;
+    const cpu = process.cpuUsage(lastCpu);
+    last = now;
+    lastCpu = process.cpuUsage();
+    if (lagMs < PERF_STALL_THRESHOLD_MS) return;
+    const mem = process.memoryUsage();
+    perfLog('event-loop-stall', {
+      lagMs: lagMs.toFixed(1),
+      elapsedMs: elapsed.toFixed(1),
+      cpuUserMs: (cpu.user / 1000).toFixed(1),
+      cpuSystemMs: (cpu.system / 1000).toFixed(1),
+      rssMb: (mem.rss / 1048576).toFixed(1),
+      heapMb: (mem.heapUsed / 1048576).toFixed(1),
+    });
+  }, PERF_STALL_INTERVAL_MS);
+  timer.unref?.();
+  return () => {
+    try { clearInterval(timer); } catch { /* ignore */ }
+  };
+}
+
 function makeRenderProfiler() {
   if (!PERF_ENABLED) return undefined;
   let count = 0;
   let sum = 0;
   let max = 0;
   let slow = 0;
+  let maxGap = 0;
+  let lastFrameAt = 0;
   return ({ renderTime } = {}) => {
+    const now = performance.now();
     const ms = Number(renderTime) || 0;
+    const gap = lastFrameAt ? now - lastFrameAt : 0;
+    lastFrameAt = now;
     count += 1;
     sum += ms;
     if (ms > max) max = ms;
+    if (gap > maxGap) maxGap = gap;
     if (ms >= 16) slow += 1;
+    if (gap >= PERF_RENDER_GAP_MS) {
+      perfLog('render-gap', {
+        gapMs: gap.toFixed(1),
+        renderMs: ms.toFixed(2),
+      });
+    }
     if (count >= PERF_REPORT_EVERY) {
       const avg = sum / count;
-      try {
-        process.stderr.write(
-          `[mixdog-perf] frames=${count} avg=${avg.toFixed(2)}ms max=${max.toFixed(2)}ms slow16+=${slow}\n`,
-        );
-      } catch { /* ignore */ }
-      count = 0; sum = 0; max = 0; slow = 0;
+      perfLog('render-summary', {
+        frames: count,
+        avgMs: avg.toFixed(2),
+        maxMs: max.toFixed(2),
+        maxGapMs: maxGap.toFixed(1),
+        slow16: slow,
+      });
+      count = 0; sum = 0; max = 0; slow = 0; maxGap = 0;
     }
   };
 }
@@ -291,6 +376,8 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
   }
 
   const restoreStderr = installTuiStderrGuard();
+  const stopPerfProbe = installTuiPerfProbe();
+  const stopLoopProbe = installTuiLoopProbe();
   const restorePrimedInput = () => drainStdin(process.stdin);
   let restored = false;
   const restoreTerminal = () => {
@@ -343,6 +430,8 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     bootProfile('store:ready', { ms: (performance.now() - startedAt).toFixed(1) });
   } catch (error) {
     splash.stop();
+    stopPerfProbe();
+    stopLoopProbe();
     restoreTerminal();
     try { process.off('exit', restoreTerminal); } catch { /* ignore */ }
     restoreStderr();
@@ -456,6 +545,8 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     }
     await waitUntilExit();
   } finally {
+    stopPerfProbe();
+    stopLoopProbe();
     clearInterval(uiHeartbeatTimer);
     for (const [stream, event, handler] of stdioDeathListeners.splice(0)) {
       try { stream.off(event, handler); } catch { /* ignore */ }

package/src/ui/statusline-segments.mjs

@@ -1,11 +1,15 @@
 /**
  * src/ui/statusline-segments.mjs — filesystem-backed L2 segment sources.
  *
- * Extracted verbatim from statusline.mjs: the shell-jobs segment (owner-scoped
- * job scan + liveness) and the memory-cycle segment (daemon state file). Both
- * keep their own 1s process-local caches. No behavior change.
+ * The shell-jobs segment (owner-scoped job scan + liveness) and the
+ * memory-cycle segment (daemon state file) each keep a 1s process-local
+ * cache. Render calls (`shellJobsStatus`/`memoryCycleStatus`) are pure cache
+ * reads and NEVER touch the filesystem synchronously: on cache expiry they
+ * return the last known value immediately and kick a background
+ * fs/promises refresh (guarded against overlap) that updates the cache for
+ * the next render tick. This keeps the 500ms render tick off sync fs I/O.
  */
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { readdir, readFile, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { formatElapsed } from './statusline-format.mjs';
@@ -15,13 +19,25 @@ const DEFAULT_STANDALONE_DATA_DIR = join(DEFAULT_MIXDOG_HOME, 'data');
 const SHELL_JOBS_SEGMENT_CACHE_MS = 1000;
 
 let _shellJobsSegmentCache = { ownerPid: 0, at: 0, value: { count: 0, elapsedLabel: '' } };
+let _shellJobsRefreshInFlight = false;
 
 function dataDir() {
   return process.env.MIXDOG_DATA_DIR || DEFAULT_STANDALONE_DATA_DIR;
 }
 
+// Render-path entry point: synchronous, cache-only. Never blocks on fs.
 export function shellJobsStatus({ clientHostPid } = {}) {
-  return _shellJobsStatusImpl({ clientHostPid });
+  const ownerPid = positiveInt(clientHostPid);
+  const empty = { count: 0, elapsedLabel: '' };
+  if (!ownerPid) return empty;
+  const now = Date.now();
+  const sameOwner = _shellJobsSegmentCache.ownerPid === ownerPid;
+  const fresh = sameOwner && now - _shellJobsSegmentCache.at < SHELL_JOBS_SEGMENT_CACHE_MS;
+  if (!fresh && !_shellJobsRefreshInFlight) {
+    _shellJobsRefreshInFlight = true;
+    refreshShellJobsStatus(ownerPid).finally(() => { _shellJobsRefreshInFlight = false; });
+  }
+  return sameOwner ? (_shellJobsSegmentCache.value || empty) : empty;
 }
 
 // Memory cycle L2 segment source. The memory daemon writes
@@ -30,23 +46,32 @@ export function shellJobsStatus({ clientHostPid } = {}) {
 // the same 1s cadence as the shell segment. Shows a single unified "Memory"
 // segment: running (spinner + elapsed) or backlog warning (yellow count).
 let _memoryCycleSegmentCache = { at: 0, value: null };
+let _memoryCycleRefreshInFlight = false;
 const MEMORY_CYCLE_SEGMENT_CACHE_MS = 1000;
 const MEMORY_CYCLE_BACKLOG_WARN = 500;
+
+// Render-path entry point: synchronous, cache-only. Never blocks on fs.
 export function memoryCycleStatus() {
   const now = Date.now();
-  if (now - _memoryCycleSegmentCache.at < MEMORY_CYCLE_SEGMENT_CACHE_MS) {
-    return _memoryCycleSegmentCache.value;
+  if (now - _memoryCycleSegmentCache.at >= MEMORY_CYCLE_SEGMENT_CACHE_MS && !_memoryCycleRefreshInFlight) {
+    _memoryCycleRefreshInFlight = true;
+    refreshMemoryCycleStatus().finally(() => { _memoryCycleRefreshInFlight = false; });
   }
+  return _memoryCycleSegmentCache.value;
+}
+
+async function refreshMemoryCycleStatus() {
   let value = null;
   try {
     const p = join(dataDir(), 'memory-cycle-state.json');
-    if (existsSync(p)) {
-      const state = JSON.parse(readFileSync(p, 'utf-8'));
+    const raw = await readFile(p, 'utf-8').catch(() => null);
+    if (raw != null) {
+      const state = JSON.parse(raw);
       const running = state?.running || null;
       const backlog = state?.backlog || {};
       // Stale-file guard: a daemon that died mid-run leaves running set —
       // ignore anything not refreshed in the last 10 minutes.
-      const fresh = Number(state?.updatedAt) > now - 10 * 60_000;
+      const fresh = Number(state?.updatedAt) > Date.now() - 10 * 60_000;
       if (fresh && running?.cycle && Number(running.started_at) > 0) {
         value = { kind: 'running', startedAt: Number(running.started_at) };
       } else if (fresh) {
@@ -55,26 +80,21 @@ export function memoryCycleStatus() {
       }
     }
   } catch { value = null; }
-  _memoryCycleSegmentCache = { at: now, value };
-  return value;
+  _memoryCycleSegmentCache = { at: Date.now(), value };
 }
 
-function _shellJobsStatusImpl({ clientHostPid } = {}) {
-  const ownerPid = positiveInt(clientHostPid);
+async function refreshShellJobsStatus(ownerPid) {
   const empty = { count: 0, elapsedLabel: '' };
-  if (!ownerPid) return empty;
-  const now = Date.now();
-  if (_shellJobsSegmentCache.ownerPid === ownerPid && now - _shellJobsSegmentCache.at < SHELL_JOBS_SEGMENT_CACHE_MS) {
-    return _shellJobsSegmentCache.value || empty;
-  }
   let value = empty;
   try {
     const dir = join(dataDir(), 'shell-jobs');
-    if (!existsSync(dir)) {
-      _shellJobsSegmentCache = { ownerPid, at: now, value };
-      return value;
+    let names;
+    try {
+      names = await readdir(dir);
+    } catch {
+      _shellJobsSegmentCache = { ownerPid, at: Date.now(), value };
+      return;
     }
-    const names = readdirSync(dir);
     const done = new Set(names.filter((n) => n.endsWith('.done')).map((n) => n.slice(0, -5)));
     const ownerByJob = new Map();
     for (const n of names) {
@@ -95,34 +115,32 @@ function _shellJobsStatusImpl({ clientHostPid } = {}) {
     for (const id of ids) {
       const p = join(dir, `${id}.json`);
       let detail;
-      try { detail = JSON.parse(readFileSync(p, 'utf-8')); } catch { continue; }
-      if (!isShellJobAlive(detail, p, dir, id)) continue;
+      try { detail = JSON.parse(await readFile(p, 'utf-8')); } catch { continue; }
+      if (!(await isShellJobAlive(detail, p, dir, id))) continue;
       count++;
       try {
-        const st = statSync(p);
+        const st = await stat(p);
         if (st.mtimeMs < oldestMs) oldestMs = st.mtimeMs;
       } catch {}
     }
-    if (!count) {
-      _shellJobsSegmentCache = { ownerPid, at: now, value };
-      return value;
+    if (count) {
+      const elapsedLabel = Number.isFinite(oldestMs) ? formatElapsed(Date.now() - oldestMs) : '';
+      value = { count, elapsedLabel };
     }
-    const elapsedLabel = Number.isFinite(oldestMs) ? formatElapsed(Date.now() - oldestMs) : '';
-    value = { count, elapsedLabel };
   } catch {
     value = empty;
   }
-  _shellJobsSegmentCache = { ownerPid, at: now, value };
-  return value;
+  _shellJobsSegmentCache = { ownerPid, at: Date.now(), value };
 }
 
-function isShellJobAlive(detail, detailPath, dir, id) {
+async function isShellJobAlive(detail, detailPath, dir, id) {
   const pid = positiveInt(detail?.pid);
   if (!pid) return false;
   try {
-    const st = statSync(detailPath);
+    const st = await stat(detailPath);
     const timeoutMs = Number(detail?.timeoutMs);
-    const enforced = detail?.timeoutEnforced === true || existsSync(join(dir, `${id}.enforced`));
+    const enforced = detail?.timeoutEnforced === true
+      || await stat(join(dir, `${id}.enforced`)).then(() => true, () => false);
     if (enforced && Number.isFinite(timeoutMs) && timeoutMs > 0 && Date.now() - st.mtimeMs > timeoutMs + 30 * 60_000) {
       return false;
     }