@rubytech/create-maxy-code 0.1.475 → 0.1.477

package/payload/server/server.js

@@ -28,6 +28,7 @@ import {
   VNC_DISPLAY,
   WEBSOCKIFY_PORT,
   accessPasswordCollides,
+  armedCount,
   autoDeliverPremiumPlugins,
   canAccessAdmin,
   checkRateLimit,
@@ -71,6 +72,7 @@ import {
   isValidAccountId,
   linkConversationTranscript,
   listAdminSessions,
+  listLoops,
   listValidAccounts,
   loadAdminUserName,
   loadPersonNameByElementId,
@@ -81,6 +83,7 @@ import {
   projectAgent,
   reconcileEnabledPluginsForAccounts,
   recordFailedAttempt,
+  registerLoop,
   registerSession,
   renameConversation,
   renderLoginPage,
@@ -94,6 +97,8 @@ import {
   runAdminUserSelfHeal,
   runUserProfileReconcile,
   safeJson,
+  sampleCpu,
+  sampleProcessCpu,
   sanitizeClientCorrId,
   serve,
   setAccessPassword,
@@ -112,7 +117,7 @@ import {
   vncLog,
   walkPremiumBundles,
   writeAdminUserAndPerson
-} from "./chunk-Y6V45R6M.js";
+} from "./chunk-JECAP3Z2.js";
 import {
   D1_MAX_SQL_STATEMENT_BYTES,
   D1_QUERY_MAX_BODY_BYTES,
@@ -2391,12 +2396,12 @@ function startAuthHealthHeartbeat(intervalMs = 5 * 60 * 1e3) {
       ticking = false;
     }
   };
-  void tick();
-  const handle = setInterval(() => {
-    void tick();
-  }, intervalMs);
-  if (typeof handle.unref === "function") handle.unref();
-  return () => clearInterval(handle);
+  return registerLoop({
+    name: "auth-health",
+    intervalMs,
+    firstRunDelayMs: 0,
+    run: tick
+  });
 }
 async function ensureAuth() {
   const health = assessAuthHealth();
@@ -2809,12 +2814,12 @@ function createBaileysLogger(bindings = {}, authDir) {
 var credsSaveQueue = Promise.resolve();
 async function drainCredsSaveQueue(timeoutMs = 5e3) {
   console.error(`${TAG6} draining credential save queue\u2026`);
-  const timer2 = new Promise(
+  const timer = new Promise(
     (resolve37) => setTimeout(() => resolve37("timeout"), timeoutMs)
   );
   const result = await Promise.race([
     credsSaveQueue.then(() => "drained"),
-    timer2
+    timer
   ]);
   if (result === "timeout") {
     console.error(`${TAG6} credential save queue drain timed out after ${timeoutMs}ms`);
@@ -3100,19 +3105,19 @@ function isTimeoutError(err) {
 }
 function withTimeout(label, promise, timeoutMs) {
   return new Promise((resolve37, reject) => {
-    const timer2 = setTimeout(() => {
+    const timer = setTimeout(() => {
       const err = new Error(`${label} timed out after ${timeoutMs}ms`);
       err.__maxyTimeout = true;
       reject(err);
     }, timeoutMs);
-    timer2.unref?.();
+    timer.unref?.();
     promise.then(
       (value) => {
-        clearTimeout(timer2);
+        clearTimeout(timer);
         resolve37(value);
       },
       (err) => {
-        clearTimeout(timer2);
+        clearTimeout(timer);
         reject(err);
       }
     );
@@ -5197,10 +5202,10 @@ function createInboundDebouncer(opts) {
         flushKey(key).catch(onError);
       }, debounceMs);
     } else {
-      const timer2 = setTimeout(() => {
+      const timer = setTimeout(() => {
         flushKey(key).catch(onError);
       }, debounceMs);
-      pending.set(key, { entries: [msg], timer: timer2 });
+      pending.set(key, { entries: [msg], timer });
     }
   }
   function registerPending(key, promise) {
@@ -5855,9 +5860,9 @@ async function connectWithReconnect(conn) {
         `${TAG17} reconnecting account=${conn.accountId} in ${delay}ms (attempt ${decision.nextAttempts}/${maxAttempts})`
       );
       await new Promise((resolve37) => {
-        const timer2 = setTimeout(resolve37, delay);
+        const timer = setTimeout(resolve37, delay);
         conn.abortController.signal.addEventListener("abort", () => {
-          clearTimeout(timer2);
+          clearTimeout(timer);
           resolve37();
         }, { once: true });
       });
@@ -9633,36 +9638,43 @@ app3.post("/r2/object/delete", envelopeBodyLimit("write"), async (c) => {
 var storage_broker_default = app3;
 async function runStorageAudit(root) {
   const { reconcileStorage } = await import("./src-JYPKMWJR.js");
-  const session = getSession();
-  try {
-    const cf = await makeHouseCfExec(root);
-    const accountsDir = resolve11(root, "..", "data", "accounts");
-    const strays = (await reconcileStorage({
-      cfD1: async () => (await cf.d1List()).map((d) => d.name),
-      cfR2: async () => (await cf.r2List()).map((b) => b.name),
-      registeredNames: async (kind) => {
+  const cf = await makeHouseCfExec(root);
+  const accountsDir = resolve11(root, "..", "data", "accounts");
+  const strays = (await reconcileStorage({
+    cfD1: async () => (await cf.d1List()).map((d) => d.name),
+    cfR2: async () => (await cf.r2List()).map((b) => b.name),
+    // Its own session per invocation, never one captured from the enclosing
+    // scope. reconcileStorage issues the "d1" and "r2" reads through the same
+    // Promise.all, and a Neo4j session admits one query at a time — sharing one
+    // made the second reject, which left this audit reporting nothing for 802
+    // consecutive ticks on maxy-code and 295 on sitedesk-code. Sessions come
+    // from the driver pool, so one per read is cheap; the alternative,
+    // serialising the library's fan-out, would bend it around this caller.
+    registeredNames: async (kind) => {
+      const session = getSession();
+      try {
         const res = await session.run(
           "MATCH (r:StorageResource {kind: $kind}) RETURN r.name AS name",
           { kind }
         );
         return res.records.map((rec) => rec.get("name"));
-      },
-      accountSecretsFiles: async () => {
-        if (!existsSync9(accountsDir)) return [];
-        const files = [];
-        for (const accountId of readdirSync8(accountsDir)) {
-          const p = join13(accountsDir, accountId, "secrets", "cloudflare.env");
-          if (existsSync9(p)) files.push({ accountId, path: p, contents: readFileSync15(p, "utf8") });
-        }
-        return files;
+      } finally {
+        await session.close();
       }
-    })).strays;
-    console.error(
-      `[storage-audit] strays=${strays.length}${strays.map((s) => ` ${s.kind}:${s.detail}`).join("")}`
-    );
-  } finally {
-    await session.close();
-  }
+    },
+    accountSecretsFiles: async () => {
+      if (!existsSync9(accountsDir)) return [];
+      const files = [];
+      for (const accountId of readdirSync8(accountsDir)) {
+        const p = join13(accountsDir, accountId, "secrets", "cloudflare.env");
+        if (existsSync9(p)) files.push({ accountId, path: p, contents: readFileSync15(p, "utf8") });
+      }
+      return files;
+    }
+  })).strays;
+  console.error(
+    `[storage-audit] strays=${strays.length}${strays.map((s) => ` ${s.kind}:${s.detail}`).join("")}`
+  );
 }
 async function runPagesAudit(root) {
   const { reconcilePages } = await import("./src-JYPKMWJR.js");
@@ -10445,9 +10457,9 @@ function isModelGated(turns) {
   return turns.some((t) => t.kind === "agent-error" && t.code === "model_unavailable");
 }
 function renderOrSuppressChannelInbound(u, ts, out, queuedPendingSuppress) {
-  const armed = queuedPendingSuppress.get(u.text) ?? 0;
-  if (armed > 0) {
-    queuedPendingSuppress.set(u.text, armed - 1);
+  const armed2 = queuedPendingSuppress.get(u.text) ?? 0;
+  if (armed2 > 0) {
+    queuedPendingSuppress.set(u.text, armed2 - 1);
   } else {
     out.push(operatorInboundTurn(u, ts));
   }
@@ -10656,8 +10668,8 @@ function pickActivity(entries, grown, nowMs, concurrencyWindowMs) {
 
 // server/routes/stream-lifecycle.ts
 var GAUGE_INTERVAL_MS = 6e4;
-function isArmed(timer2) {
-  return timer2._destroyed !== true;
+function isArmed(timer) {
+  return timer._destroyed !== true;
 }
 var Registration = class {
   constructor(connId, channel, startedAt) {
@@ -10667,9 +10679,9 @@ var Registration = class {
   }
   timers = [];
   closed = false;
-  arm(timer2) {
-    this.timers.push(timer2);
-    return timer2;
+  arm(timer) {
+    this.timers.push(timer);
+    return timer;
   }
   teardown(reason) {
     if (this.closed) return false;
@@ -10703,11 +10715,11 @@ function emitGauge() {
     counts[reg.channel]++;
     oldestMs = Math.max(oldestMs, now - reg.startedAt);
   }
-  const armed = counts.reader + counts.store;
+  const armed2 = counts.reader + counts.store;
   console.log(
-    `[wa-stream] op=gauge armed=${armed} reader=${counts.reader} store=${counts.store} oldestSec=${Math.floor(oldestMs / 1e3)} stale=${stale}`
+    `[wa-stream] op=gauge armed=${armed2} reader=${counts.reader} store=${counts.store} oldestSec=${Math.floor(oldestMs / 1e3)} stale=${stale}`
   );
-  if (armed === 0) stopGauge();
+  if (armed2 === 0) stopGauge();
 }
 function startGauge() {
   if (gaugeTimer) return;
@@ -13902,12 +13914,21 @@ function checkRateLimit2(ip, cls) {
   }
   return { allow: true, blocked: 0, shouldLog: false };
 }
-setInterval(() => {
-  const now = Date.now();
-  for (const [ip, rec] of rateHits) {
-    if (now - rec.windowStart >= WINDOW_MS * 2) rateHits.delete(ip);
+registerLoop({
+  name: "client-error-rate-cleanup",
+  intervalMs: WINDOW_MS,
+  run: () => {
+    const now = Date.now();
+    let purged = 0;
+    for (const [key, rec] of rateHits) {
+      if (now - rec.windowStart >= WINDOW_MS * 2) {
+        rateHits.delete(key);
+        purged += 1;
+      }
+    }
+    return `purged ${purged}, ${rateHits.size} live`;
   }
-}, WINDOW_MS).unref();
+});
 function truncate(value, max) {
   if (typeof value !== "string") return "";
   return value.length > max ? value.slice(0, max) + "\u2026" : value;
@@ -20701,18 +20722,18 @@ async function probeConversationDb() {
   } catch (err) {
     return { state: "error", reason: err instanceof Error ? err.message : String(err) };
   }
-  let timer2;
+  let timer;
   try {
     const probe = session.run("RETURN 1");
     const timeout = new Promise((_, reject) => {
-      timer2 = setTimeout(() => reject(new Error("timeout")), PROBE_TIMEOUT_MS);
+      timer = setTimeout(() => reject(new Error("timeout")), PROBE_TIMEOUT_MS);
     });
     await Promise.race([probe, timeout]);
     return { state: "ok" };
   } catch (err) {
     return { state: "error", reason: err instanceof Error ? err.message : String(err) };
   } finally {
-    if (timer2) clearTimeout(timer2);
+    if (timer) clearTimeout(timer);
     session.close().catch(() => {
     });
   }
@@ -22383,10 +22404,32 @@ app52.get("/", requireAdminSession, async (c) => {
       if (name) names[a.accountId] = name;
     })
   );
+  const sampledAt = Date.now();
+  sampleCpu(sampledAt);
+  const cpu = sampleProcessCpu(sampledAt);
+  const loopRows = listLoops();
+  const armed2 = armedCount();
+  const byState = loopRows.reduce((acc, r) => {
+    acc[r.state] = (acc[r.state] ?? 0) + 1;
+    return acc;
+  }, {});
+  console.log(
+    `${TAG42} op=loops req=${req} armed=${armed2} rendered=${loopRows.length} procPct=${cpu.processPct?.toFixed(1) ?? "null"} attributedPct=${cpu.attributedPct?.toFixed(1) ?? "null"} ` + Object.entries(byState).map(([s, n]) => `${s}=${n}`).join(" ")
+  );
   return c.json({
     rows,
     census,
     censusAgeMs,
+    loops: {
+      armed: armed2,
+      rows: loopRows,
+      // The server's own CPU beside what the registry can explain. The GAP is
+      // the point: loops summing to 2% against a process at 60% says the cost
+      // is somewhere else, which small numbers alone would never tell you.
+      processPct: cpu.processPct,
+      attributedPct: cpu.attributedPct,
+      unattributedPct: cpu.unattributedPct
+    },
     accounts: {
       onDisk,
       valid: valid.length,
@@ -23130,12 +23173,21 @@ function rateLimit(ip, now = Date.now()) {
   if (b.count > RATE_LIMIT) return { ok: false, resetIn: b.resetAt - now };
   return { ok: true, resetIn: b.resetAt - now };
 }
-setInterval(() => {
-  const now = Date.now();
-  for (const [ip, b] of buckets) {
-    if (now >= b.resetAt) buckets.delete(ip);
+registerLoop({
+  name: "visitor-event-rate-cleanup",
+  intervalMs: 5 * RATE_WINDOW_MS,
+  run: () => {
+    const now = Date.now();
+    let purged = 0;
+    for (const [ip, b] of buckets) {
+      if (now >= b.resetAt) {
+        buckets.delete(ip);
+        purged += 1;
+      }
+    }
+    return `purged ${purged}, ${buckets.size} live`;
   }
-}, 5 * RATE_WINDOW_MS).unref?.();
+});
 var VALID_TYPES = /* @__PURE__ */ new Set(["pageview", "click", "scroll", "dwell"]);
 var ID_RE = /^[A-Za-z0-9_-]{6,128}$/;
 function parseEvent(body) {
@@ -23801,14 +23853,12 @@ function startTimeEntryCensus(openSession, opts = {}) {
       }
     }
   };
-  void tick();
-  const id = setInterval(() => {
-    void tick();
-  }, intervalMs);
-  if (typeof id.unref === "function") {
-    id.unref();
-  }
-  return () => clearInterval(id);
+  return registerLoop({
+    name: "timeentry-census",
+    intervalMs,
+    firstRunDelayMs: 0,
+    run: tick
+  });
 }
 
 // app/lib/ledger-census.ts
@@ -23962,15 +24012,12 @@ function startLedgerCensus(openSession, opts = {}) {
       }
     }
   };
-  void tick();
-  const id = setInterval(() => {
-    void tick();
-  }, intervalMs);
-  if (typeof id.unref === "function") {
-    ;
-    id.unref();
-  }
-  return () => clearInterval(id);
+  return registerLoop({
+    name: "ledger-census",
+    intervalMs,
+    firstRunDelayMs: 0,
+    run: tick
+  });
 }
 
 // app/lib/conversation-audit.ts
@@ -24022,7 +24069,7 @@ function renderLabelTop(rows) {
     return `${labels}:${c}`;
   }).join(",");
 }
-var timer = null;
+var armed = false;
 async function runGraphHealthTick() {
   const session = getSession();
   try {
@@ -24117,16 +24164,16 @@ async function verifyUserProfileConstraint() {
   }
 }
 function startGraphHealthTimer() {
-  if (timer) return;
+  if (armed) return;
   verifyUserProfileConstraint().catch(() => {
   });
-  runGraphHealthTick().catch(() => {
+  registerLoop({
+    name: "graph-health",
+    intervalMs: HOUR_MS,
+    firstRunDelayMs: 0,
+    run: () => runGraphHealthTick()
   });
-  timer = setInterval(() => {
-    runGraphHealthTick().catch(() => {
-    });
-  }, HOUR_MS);
-  if (typeof timer.unref === "function") timer.unref();
+  armed = true;
 }
 
 // app/lib/file-watcher.ts
@@ -24968,10 +25015,28 @@ var WaGateway = class {
     }
     return events;
   }
-  /** Start the periodic reconciliation sweep in the long-lived UI process.
-   *  Returns the interval handle. */
+  /** Arm the periodic reconciliation sweep in the long-lived UI process.
+   *
+   *  Task 1814 — armed through the registry, so it appears on /activity. This
+   *  gateway is constructed once at module scope in server/index.ts and reached
+   *  everywhere else through the singleton accessor in ./instance, so the sweep
+   *  is per-install, not per-instance. Returns the registry's disarm function
+   *  rather than the interval handle; no caller reads it.
+   *
+   *  Two semantics move with it. The timer is now unref'd, where the bare
+   *  setInterval was not: a loop is a passenger of the process, never what
+   *  keeps it alive. And a throwing sweep is recorded as lastError instead of
+   *  surfacing as an uncaught timer exception, so a sweep that fails every
+   *  tick now reads as a failing row on /activity rather than a crash. */
   startSweeper(intervalMs = SWEEP_INTERVAL_MS) {
-    return setInterval(() => this.reconcile(Date.now()), intervalMs);
+    return registerLoop({
+      name: "whatsapp-native-sweep",
+      intervalMs,
+      run: () => {
+        const events = this.reconcile(Date.now());
+        return events.length > 0 ? `${events.length} terminal events` : void 0;
+      }
+    });
   }
   /** Handle one inbound admin WhatsApp message. */
   async handleInbound(input) {
@@ -25446,13 +25511,13 @@ var WebchatGateway = class _WebchatGateway {
    *  response, preserving the pre-756 POST→single-blob browser contract. */
   awaitReply(key, timeoutMs) {
     return new Promise((resolve37) => {
-      const timer2 = setTimeout(() => {
+      const timer = setTimeout(() => {
         this.replyAwaiters.delete(key);
         resolve37({ timeout: true });
       }, timeoutMs);
-      if (timer2.unref) timer2.unref();
+      if (timer.unref) timer.unref();
       this.replyAwaiters.set(key, (r) => {
-        clearTimeout(timer2);
+        clearTimeout(timer);
         this.replyAwaiters.delete(key);
         resolve37(r);
       });
@@ -25467,16 +25532,16 @@ var WebchatGateway = class _WebchatGateway {
     const k = _WebchatGateway.promptKey(p.key, p.requestId);
     return new Promise((resolve37) => {
       this.pendingPrompts.get(k)?.resolve({ timeout: true });
-      const timer2 = setTimeout(() => {
+      const timer = setTimeout(() => {
         this.pendingPrompts.delete(k);
         resolve37({ timeout: true });
       }, timeoutMs);
-      if (timer2.unref) timer2.unref();
+      if (timer.unref) timer.unref();
       this.pendingPrompts.set(k, {
         ...p,
         at: Date.now(),
         resolve: (r) => {
-          clearTimeout(timer2);
+          clearTimeout(timer);
           this.pendingPrompts.delete(k);
           resolve37(r);
         }
@@ -25544,11 +25609,22 @@ var WebchatGateway = class _WebchatGateway {
       void this.deps.deleteSession?.(rec.sessionId);
     }
   }
-  /** Start the periodic public idle reaper in the long-lived UI process. */
+  /** Arm the periodic public idle reaper in the long-lived UI process.
+   *
+   *  Task 1814 — armed through the registry, so it appears on /activity. Like
+   *  the sweeper below, this is per-install: one gateway per server, reached
+   *  through the singleton accessor in ./instance. Returns the registry's
+   *  disarm function rather than the interval handle; no caller reads it.
+   *
+   *  This one already unref'd its handle, so only the error semantics move: a
+   *  throwing reap is recorded as lastError rather than surfacing as an
+   *  uncaught timer exception. */
   startPublicReaper(intervalMs = 6e4) {
-    const handle = setInterval(() => this.reapPublic(Date.now()), intervalMs);
-    if (handle.unref) handle.unref();
-    return handle;
+    return registerLoop({
+      name: "webchat-public-reaper",
+      intervalMs,
+      run: () => this.reapPublic(Date.now())
+    });
   }
   /** A gated public PTY exited explicitly on the manager side (operator stop,
    *  claude crash, manager DELETE), not via the idle reaper. The manager POSTs
@@ -25630,15 +25706,36 @@ var WebchatGateway = class _WebchatGateway {
     }
     return events;
   }
-  /** Start the periodic reconciliation sweep in the long-lived UI process. Each
+  /** Arm the periodic reconciliation sweep in the long-lived UI process. Each
    *  tick runs the sync sweep (drain-/inbound-undelivered) AND the async
-   *  recovery pass for queued-no-subscriber messages (Task-962). */
+   *  recovery pass for queued-no-subscriber messages (Task-962).
+   *
+   *  Task 1814 — armed through the registry, so it appears on /activity. This
+   *  gateway is constructed once at module scope in server/index.ts and reached
+   *  everywhere else through the singleton accessor in ./instance, so the sweep
+   *  is per-install, not per-instance. Returns the registry's disarm function
+   *  rather than the interval handle; no caller reads it.
+   *
+   *  Two semantics move with it. The timer is now unref'd, where the bare
+   *  setInterval was not: a loop is a passenger of the process, never what
+   *  keeps it alive. And a throwing sweep is recorded as lastError instead of
+   *  surfacing as an uncaught timer exception, so a sweep that fails every
+   *  tick now reads as a failing row on /activity rather than a crash.
+   *
+   *  recoverStalled stays fire-and-forget, exactly as it was: run() returns the
+   *  sync note, so the registry's duration covers the sweep and not the
+   *  recovery pass. */
   startSweeper(intervalMs = SWEEP_INTERVAL_MS2) {
-    return setInterval(() => {
-      const now = Date.now();
-      this.reconcile(now);
-      void this.recoverStalled(now);
-    }, intervalMs);
+    return registerLoop({
+      name: "webchat-inbound-sweep",
+      intervalMs,
+      run: () => {
+        const now = Date.now();
+        const events = this.reconcile(now);
+        void this.recoverStalled(now);
+        return events.length > 0 ? `${events.length} terminal events` : void 0;
+      }
+    });
   }
   /** Task-962 — the per-session delivery-failure marker for the /session pointer.
    *  Non-null only when redelivery was exhausted for `key`; cleared on the next
@@ -26576,9 +26673,28 @@ var TelegramGateway = class {
     }
     return events;
   }
-  /** Start the periodic reconciliation sweep in the long-lived UI process. */
+  /** Arm the periodic reconciliation sweep in the long-lived UI process.
+   *
+   *  Task 1814 — armed through the registry, so it appears on /activity. This
+   *  gateway is constructed once at module scope in server/index.ts and reached
+   *  everywhere else through the singleton accessor in ./instance, so the sweep
+   *  is per-install, not per-instance. Returns the registry's disarm function
+   *  rather than the interval handle; no caller reads it.
+   *
+   *  Two semantics move with it. The timer is now unref'd, where the bare
+   *  setInterval was not: a loop is a passenger of the process, never what
+   *  keeps it alive. And a throwing sweep is recorded as lastError instead of
+   *  surfacing as an uncaught timer exception, so a sweep that fails every
+   *  tick now reads as a failing row on /activity rather than a crash. */
   startSweeper(intervalMs = SWEEP_INTERVAL_MS3) {
-    return setInterval(() => this.reconcile(Date.now()), intervalMs);
+    return registerLoop({
+      name: "telegram-native-sweep",
+      intervalMs,
+      run: () => {
+        const events = this.reconcile(Date.now());
+        return events.length > 0 ? `${events.length} terminal events` : void 0;
+      }
+    });
   }
   /** Handle one inbound telegram message. */
   async handleInbound(input) {
@@ -27569,8 +27685,12 @@ function runDuplicateSenderAudit() {
     console.error(`[whatsapp-native] op=duplicate-sender-audit-error error=${err instanceof Error ? err.message : String(err)}`);
   }
 }
-setTimeout(runDuplicateSenderAudit, 0).unref();
-setInterval(runDuplicateSenderAudit, 15 * 6e4).unref();
+registerLoop({
+  name: "whatsapp-duplicate-sender-audit",
+  intervalMs: 15 * 6e4,
+  firstRunDelayMs: 0,
+  run: runDuplicateSenderAudit
+});
 var webchatGateway = new WebchatGateway({
   fetchStandingRules: fetchAccountStandingRules,
   gatewayUrl: webchatGatewayUrl(),
@@ -28499,7 +28619,7 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
   const reconcilePlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join42(__dirname, "..");
   const reconcileScript = resolve36(reconcilePlatformRoot, "plugins/scheduling/mcp/dist/scripts/reconcile-bookings.js");
   const RECONCILE_INTERVAL_MS = 12e4;
-  const runReconcile = () => {
+  const runReconcile = (ctx) => {
     if (!existsSync38(reconcileScript)) return;
     try {
       const child = spawn3(process.execPath, [reconcileScript], {
@@ -28507,21 +28627,25 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
         stdio: "inherit"
       });
       child.unref();
+      ctx.child(child.pid);
       child.on("error", (err) => console.error(`[calendar-reconcile] spawn-failed err="${err.message}"`));
     } catch (err) {
       console.error(`[calendar-reconcile] spawn-failed err="${err.message}"`);
     }
   };
-  const firstRun = setTimeout(runReconcile, 15e3);
-  firstRun.unref();
-  const loop = setInterval(runReconcile, RECONCILE_INTERVAL_MS);
-  loop.unref();
+  registerLoop({
+    name: "calendar-reconcile",
+    intervalMs: RECONCILE_INTERVAL_MS,
+    firstRunDelayMs: 15e3,
+    detached: true,
+    run: runReconcile
+  });
 }
 {
   const outlookPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join42(__dirname, "..");
   const outlookScript = resolve36(outlookPlatformRoot, "plugins/outlook/mcp/dist/scripts/complete-registration.js");
   const OUTLOOK_COMPLETE_INTERVAL_MS = 3e4;
-  const runOutlookComplete = () => {
+  const runOutlookComplete = (ctx) => {
     if (!existsSync38(outlookScript)) return;
     try {
       const child = spawn3(process.execPath, [outlookScript], {
@@ -28529,15 +28653,19 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
         stdio: "inherit"
       });
       child.unref();
+      ctx.child(child.pid);
       child.on("error", (err) => console.error(`[outlook-complete] spawn-failed err="${err.message}"`));
     } catch (err) {
       console.error(`[outlook-complete] spawn-failed err="${err.message}"`);
     }
   };
-  const outlookFirst = setTimeout(runOutlookComplete, 18e3);
-  outlookFirst.unref();
-  const outlookLoop = setInterval(runOutlookComplete, OUTLOOK_COMPLETE_INTERVAL_MS);
-  outlookLoop.unref();
+  registerLoop({
+    name: "outlook-devicecode-complete",
+    intervalMs: OUTLOOK_COMPLETE_INTERVAL_MS,
+    firstRunDelayMs: 18e3,
+    detached: true,
+    run: runOutlookComplete
+  });
 }
 {
   const auditRoot = process.env.MAXY_PLATFORM_ROOT ?? join42(__dirname, "..");
@@ -28562,10 +28690,12 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
       console.error(`[outlook-mcp] devicecode-stranded-audit error="${err.message}"`);
     }
   };
-  const strandedFirst = setTimeout(runStrandedAudit, 25e3);
-  strandedFirst.unref();
-  const strandedLoop = setInterval(runStrandedAudit, STRANDED_AUDIT_INTERVAL_MS);
-  strandedLoop.unref();
+  registerLoop({
+    name: "outlook-stranded-audit",
+    intervalMs: STRANDED_AUDIT_INTERVAL_MS,
+    firstRunDelayMs: 25e3,
+    run: runStrandedAudit
+  });
 }
 {
   const googleRoot = process.env.MAXY_PLATFORM_ROOT ?? join42(__dirname, "..");
@@ -28578,13 +28708,15 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
       console.error(`[google-oauth] op=pending-audit-error error="${err.message}"`);
     }
   };
-  const googlePendingFirst = setTimeout(runGooglePendingAuditSafe, 27e3);
-  googlePendingFirst.unref();
-  const googlePendingLoop = setInterval(runGooglePendingAuditSafe, GOOGLE_PENDING_AUDIT_INTERVAL_MS);
-  googlePendingLoop.unref();
+  registerLoop({
+    name: "google-pending-audit",
+    intervalMs: GOOGLE_PENDING_AUDIT_INTERVAL_MS,
+    firstRunDelayMs: 27e3,
+    run: runGooglePendingAuditSafe
+  });
   const googleAuditScript = resolve36(googleRoot, "plugins/google/mcp/dist/scripts/account-audit.js");
   const GOOGLE_ACCOUNT_AUDIT_INTERVAL_MS = 36e5;
-  const runGoogleAccountAudit = () => {
+  const runGoogleAccountAudit = (ctx) => {
     if (!existsSync38(googleAuditScript)) return;
     try {
       const child = spawn3(process.execPath, [googleAuditScript], {
@@ -28592,6 +28724,7 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
         stdio: "inherit"
       });
       child.unref();
+      ctx.child(child.pid);
       child.on(
         "error",
         (err) => console.error(`[google-account-audit] op=spawn-failed error="${err.message}"`)
@@ -28600,32 +28733,37 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
       console.error(`[google-account-audit] op=spawn-failed error="${err.message}"`);
     }
   };
-  const googleAuditFirst = setTimeout(runGoogleAccountAudit, 45e3);
-  googleAuditFirst.unref();
-  const googleAuditLoop = setInterval(runGoogleAccountAudit, GOOGLE_ACCOUNT_AUDIT_INTERVAL_MS);
-  googleAuditLoop.unref();
+  registerLoop({
+    name: "google-account-audit",
+    intervalMs: GOOGLE_ACCOUNT_AUDIT_INTERVAL_MS,
+    firstRunDelayMs: 45e3,
+    detached: true,
+    run: runGoogleAccountAudit
+  });
 }
 {
   const auditPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join42(__dirname, "..");
   const STORAGE_AUDIT_INTERVAL_MS = 3e5;
-  const runStorageAuditSafe = () => {
-    runStorageAudit(auditPlatformRoot).catch(
-      (err) => console.error(`[storage-audit] error="${err.message}"`)
-    );
-  };
-  const auditFirst = setTimeout(runStorageAuditSafe, 2e4);
-  auditFirst.unref();
-  const auditLoop = setInterval(runStorageAuditSafe, STORAGE_AUDIT_INTERVAL_MS);
-  auditLoop.unref();
-  const runPagesAuditSafe = () => {
-    runPagesAudit(auditPlatformRoot).catch(
-      (err) => console.error(`[pages-audit] error="${err.message}"`)
-    );
-  };
-  const pagesAuditFirst = setTimeout(runPagesAuditSafe, 35e3);
-  pagesAuditFirst.unref();
-  const pagesAuditLoop = setInterval(runPagesAuditSafe, STORAGE_AUDIT_INTERVAL_MS);
-  pagesAuditLoop.unref();
+  const runStorageAuditSafe = () => runStorageAudit(auditPlatformRoot).catch((err) => {
+    console.error(`[storage-audit] error="${err.message}"`);
+    throw err;
+  });
+  registerLoop({
+    name: "storage-audit",
+    intervalMs: STORAGE_AUDIT_INTERVAL_MS,
+    firstRunDelayMs: 2e4,
+    run: runStorageAuditSafe
+  });
+  const runPagesAuditSafe = () => runPagesAudit(auditPlatformRoot).catch((err) => {
+    console.error(`[pages-audit] error="${err.message}"`);
+    throw err;
+  });
+  registerLoop({
+    name: "pages-audit",
+    intervalMs: STORAGE_AUDIT_INTERVAL_MS,
+    firstRunDelayMs: 35e3,
+    run: runPagesAuditSafe
+  });
 }
 {
   const publishPlatformRoot = process.env.MAXY_PLATFORM_ROOT ?? join42(__dirname, "..");
@@ -28639,7 +28777,7 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
       return null;
     }
   };
-  const spawnPublish = (account) => {
+  const spawnPublish = (account, ctx) => {
     if (!existsSync38(publishScript)) return;
     try {
       const child = spawn3(process.execPath, [publishScript], {
@@ -28652,6 +28790,7 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
         stdio: "inherit"
       });
       child.unref();
+      ctx.child(child.pid);
       child.on("error", (err) => console.error(`[calendar-availability] op=publish result=error reason=spawn-failed err="${err.message}"`));
     } catch (err) {
       console.error(`[calendar-availability] op=publish result=error reason=spawn-failed err="${err.message}"`);
@@ -28683,16 +28822,19 @@ console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
     const ageMs = Number.isNaN(parsed) ? null : Date.now() - parsed;
     console.error(`[calendar-availability] op=audit accountId=${account.accountId} snapshotAgeMs=${ageMs ?? "na"}`);
   };
-  const publishTick = () => {
+  const publishTick = (ctx) => {
     const account = currentAccount();
     if (!account) return;
-    spawnPublish(account);
+    spawnPublish(account, ctx);
     auditSnapshotAge(account);
   };
-  const firstPublish = setTimeout(publishTick, 2e4);
-  firstPublish.unref();
-  const publishLoop = setInterval(publishTick, PUBLISH_INTERVAL_MS);
-  publishLoop.unref();
+  registerLoop({
+    name: "calendar-availability-publish",
+    intervalMs: PUBLISH_INTERVAL_MS,
+    firstRunDelayMs: 2e4,
+    detached: true,
+    run: publishTick
+  });
 }
 startTimeEntryCensus(() => getSession());
 startLedgerCensus(() => getSession());
@@ -28701,7 +28843,7 @@ startLedgerCensus(() => getSession());
   const auditScript = resolve36(auditPlatformRoot, "plugins/connector/mcp/dist/scripts/audit-connectors.js");
   const auditLogDir = process.env.LOG_DIR ?? LOG_DIR;
   const CONNECTOR_AUDIT_INTERVAL_MS = 3e5;
-  const runConnectorAudit = () => {
+  const runConnectorAudit = (ctx) => {
     if (!existsSync38(auditScript)) return;
     try {
       const child = spawn3(process.execPath, [auditScript], {
@@ -28709,15 +28851,19 @@ startLedgerCensus(() => getSession());
         stdio: "inherit"
       });
       child.unref();
+      ctx.child(child.pid);
       child.on("error", (err) => console.error(`[connector-audit] spawn-failed err="${err.message}"`));
     } catch (err) {
       console.error(`[connector-audit] spawn-failed err="${err.message}"`);
     }
   };
-  const firstAudit = setTimeout(runConnectorAudit, 3e4);
-  firstAudit.unref();
-  const auditLoop = setInterval(runConnectorAudit, CONNECTOR_AUDIT_INTERVAL_MS);
-  auditLoop.unref();
+  registerLoop({
+    name: "connector-audit",
+    intervalMs: CONNECTOR_AUDIT_INTERVAL_MS,
+    firstRunDelayMs: 3e4,
+    detached: true,
+    run: runConnectorAudit
+  });
 }
 {
   const census = pwaCensus({
@@ -28740,15 +28886,19 @@ startAuthHealthHeartbeat();
   loopHist.enable();
   const LOG_THRESHOLD_MS = 1e3;
   const WINDOW_MS2 = 3e4;
-  const lagTimer = setInterval(() => {
-    const maxMs = loopHist.max / 1e6;
-    const p99Ms = loopHist.percentile(99) / 1e6;
-    loopHist.reset();
-    if (maxMs >= LOG_THRESHOLD_MS) {
-      console.error(`[event-loop] lag p99=${Math.round(p99Ms)} max=${Math.round(maxMs)} window=${WINDOW_MS2 / 1e3}s`);
+  registerLoop({
+    name: "event-loop-lag",
+    intervalMs: WINDOW_MS2,
+    run: () => {
+      const maxMs = loopHist.max / 1e6;
+      const p99Ms = loopHist.percentile(99) / 1e6;
+      loopHist.reset();
+      if (maxMs >= LOG_THRESHOLD_MS) {
+        console.error(`[event-loop] lag p99=${Math.round(p99Ms)} max=${Math.round(maxMs)} window=${WINDOW_MS2 / 1e3}s`);
+      }
+      return `p99 ${Math.round(p99Ms)}ms, max ${Math.round(maxMs)}ms`;
     }
-  }, WINDOW_MS2);
-  lagTimer.unref();
+  });
 }
 var SUBAPP_MANIFEST = [
   { prefix: "/api/health", file: "server/routes/health.ts", subapp: health_default },
@@ -28840,11 +28990,14 @@ async function runAdminUserReconcileTick() {
     console.error(`[adminuser-self-heal] rejected: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-void runAdminUserReconcileTick();
-var adminUserReconcileTimer = setInterval(() => {
-  void runAdminUserReconcileTick();
-}, ADMINUSER_RECONCILE_INTERVAL_MS);
-if (typeof adminUserReconcileTimer.unref === "function") adminUserReconcileTimer.unref();
+registerLoop({
+  name: "adminuser-reconcile",
+  intervalMs: ADMINUSER_RECONCILE_INTERVAL_MS,
+  firstRunDelayMs: 0,
+  // Returned, not void-called: the registry awaits it, so the recorded
+  // duration and outcome describe the tick rather than the call that started it.
+  run: () => runAdminUserReconcileTick()
+});
 var INGEST_AUDIT_INTERVAL_MS = 15 * 60 * 1e3;
 var runIngestAuditTick = () => {
   try {
@@ -28853,9 +29006,12 @@ var runIngestAuditTick = () => {
     console.error(`[wa-ingest-audit] rejected: ${err instanceof Error ? err.message : String(err)}`);
   }
 };
-runIngestAuditTick();
-var ingestAuditTimer = setInterval(runIngestAuditTick, INGEST_AUDIT_INTERVAL_MS);
-if (typeof ingestAuditTimer.unref === "function") ingestAuditTimer.unref();
+registerLoop({
+  name: "wa-ingest-audit",
+  intervalMs: INGEST_AUDIT_INTERVAL_MS,
+  firstRunDelayMs: 0,
+  run: runIngestAuditTick
+});
 var USERS_RECONCILE_INTERVAL_MS = 60 * 60 * 1e3;
 function countUsersRows() {
   if (!existsSync38(USERS_FILE)) return 0;
@@ -28882,9 +29038,12 @@ function runUsersReconcileTick() {
     console.error(`[users-reconcile] op=error detail=${err instanceof Error ? err.message : String(err)}`);
   }
 }
-runUsersReconcileTick();
-var usersReconcileTimer = setInterval(runUsersReconcileTick, USERS_RECONCILE_INTERVAL_MS);
-if (typeof usersReconcileTimer.unref === "function") usersReconcileTimer.unref();
+registerLoop({
+  name: "users-reconcile",
+  intervalMs: USERS_RECONCILE_INTERVAL_MS,
+  firstRunDelayMs: 0,
+  run: runUsersReconcileTick
+});
 startGraphHealthTimer();
 void migrateUploads().catch((err) => console.error(`[uploads-migrate] failed err="${err instanceof Error ? err.message : String(err)}"`)).finally(() => {
   void startFileWatcher().catch((err) => {
@@ -28893,9 +29052,19 @@ void migrateUploads().catch((err) => console.error(`[uploads-migrate] failed err
 });
 void sweepStaleUploadTemps().catch((err) => console.error(`[data-upload] op=sweep-failed err="${err instanceof Error ? err.message : String(err)}"`));
 var CHUNK_IDLE_TTL_MS = 30 * 60 * 1e3;
-setInterval(() => {
-  void evictStaleChunkUploads(CHUNK_IDLE_TTL_MS).catch((err) => console.error(`[data-upload] op=evict-failed err="${err instanceof Error ? err.message : String(err)}"`));
-}, 10 * 60 * 1e3).unref();
+registerLoop({
+  name: "upload-chunk-evict",
+  intervalMs: 10 * 60 * 1e3,
+  // The domain-tagged line is kept and the rejection rethrown: existing
+  // `[data-upload]` greps keep working AND the registry records the failure,
+  // rather than swallowing it and reporting the run as healthy.
+  run: () => evictStaleChunkUploads(CHUNK_IDLE_TTL_MS).then((evicted) => `evicted ${evicted}`).catch((err) => {
+    console.error(
+      `[data-upload] op=evict-failed err="${err instanceof Error ? err.message : String(err)}"`
+    );
+    throw err;
+  })
+});
 void migrateAdminWebchatSidecars().catch((err) => console.error(`[sidecar-backfill] failed err="${err instanceof Error ? err.message : String(err)}"`));
 try {
   const accounts = enumerateValidAccountIds(getAccountsDirFromEnv());