fix(gateway): continuously drain retention cleanup

apps/platform-node/entry.ts

@@ -25,12 +25,12 @@ setGlobalDispatcher(new Agent({
 
 import { bootstrapNodePlatform } from './src/bootstrap.ts';
 import { applyMigrations } from './src/migrate.ts';
+import { startScheduledMaintenance } from './src/scheduled-maintenance.ts';
 import {
   app,
   initBackgroundSchedulerResolver,
   initRepo,
   initResponsesWebSocketUpgradeResolver,
-  runScheduledMaintenance,
   SqlRepo,
 } from '@floway-dev/gateway';
 import { getEnvOptional } from '@floway-dev/platform';
@@ -59,25 +59,10 @@ if (process.env.NODE_ENV === 'production' && !process.env.ADMIN_KEY) {
   process.exit(1);
 }
 
-const SCHEDULED_INTERVAL_MS = 60 * 60 * 1000;
-
 await applyMigrations(db);
 initRepo(new SqlRepo(db));
 
-// Run the scheduled maintenance job once after a short startup delay and
-// then every hour. Without the startup run, a process that restarts more
-// often than the interval (crash loop, frequent deploys) would never run
-// maintenance and the responses-items expiry sweep would silently lag. The
-// 30s delay keeps the very first request after boot from racing the sweep.
-// unref() on both timers lets the process exit cleanly on SIGINT.
-const STARTUP_DELAY_MS = 30 * 1000;
-const sweep = (): void => {
-  runScheduledMaintenance().catch(err => {
-    console.error('[scheduled-maintenance] sweep failed:', err);
-  });
-};
-setTimeout(sweep, STARTUP_DELAY_MS).unref();
-setInterval(sweep, SCHEDULED_INTERVAL_MS).unref();
+startScheduledMaintenance();
 
 serve({
   fetch: app.fetch,

apps/platform-node/src/scheduled-maintenance.ts

@@ -0,0 +1,30 @@
+import { runScheduledMaintenance } from '@floway-dev/gateway';
+
+interface TimerHandle {
+  unref(): void;
+}
+
+interface MaintenanceTimers {
+  setTimeout(callback: () => void, delayMs: number): TimerHandle;
+  setInterval(callback: () => void, delayMs: number): TimerHandle;
+}
+
+// The startup tick avoids waiting the full interval when a process stays alive
+// for at least 30 seconds. Minute cadence increases bounded cleanup throughput
+// and spreads its writes across the hour. Both timers are unreferenced so
+// maintenance never keeps the Node process alive by itself.
+const STARTUP_DELAY_MS = 30 * 1000;
+const MAINTENANCE_INTERVAL_MS = 60 * 1000;
+
+export const startScheduledMaintenance = (
+  runMaintenance: () => Promise<void> = runScheduledMaintenance,
+  timers: MaintenanceTimers = { setTimeout, setInterval },
+): void => {
+  const sweep = (): void => {
+    runMaintenance().catch(err => {
+      console.error('[scheduled-maintenance] sweep failed:', err);
+    });
+  };
+  timers.setTimeout(sweep, STARTUP_DELAY_MS).unref();
+  timers.setInterval(sweep, MAINTENANCE_INTERVAL_MS).unref();
+};