aicodeman 1.43.0 → 1.45.0

package/dist/web/server.js

@@ -44,6 +44,7 @@ import { looksLikeHostReboot, newestPersistedActivity, planRebootRestore } from
 import { rebootRestoreRegistry } from './reboot-restore-registry.js';
 import { dataPath, getDataDir, CODEMAN_INSTANCE } from '../config/instance.js';
 import { WebhookNotifier, readWebhookConfig } from '../webhook-notify.js';
+import { stopHostSensors } from '../host-sensors.js';
 import { webviewFetch } from './webview-egress.js';
 import { readRemoteHosts, rehydrateRemoteHostFields } from '../remote-hosts.js';
 import { normalizeBasePath, stripBasePath, joinBasePath } from '../config/base-path.js';
@@ -77,7 +78,7 @@ import { createRequire } from 'node:module';
 import { RunSummaryTracker } from '../run-summary.js';
 import { OrchestratorLoop } from '../orchestrator-loop.js';
 import { getLifecycleLog } from '../session-lifecycle-log.js';
-import { applyWorkspaceHooks, pruneAgentSessionPreambles, removeAgentSessionPreamble } from '../hooks-config.js';
+import { applyWorkspaceHooks, pruneAgentSessionPreambles, readKeepWarmSettingsOrThrow, readPlanUsageTelemetryEnabled, removeAgentSessionPreamble, } from '../hooks-config.js';
 import { PushSubscriptionStore } from '../push-store.js';
 import webpush from 'web-push';
 import { SseStreamManager } from './sse-stream-manager.js';
@@ -86,9 +87,14 @@ import { deriveWebviewSseHint } from './webview-sse.js';
 import { createSessionListeners, attachSessionListeners, detachSessionListeners, } from './session-listener-wiring.js';
 import { sessionWaits } from './session-wait-registry.js';
 import { intentStore } from '../intent-store.js';
+import { agentInbox } from './agent-inbox.js';
+import { agentInboxPersistence } from './agent-inbox-persistence.js';
 import { AI_CHECK_MODEL } from '../config/ai-defaults.js';
 import { approvalInbox } from './approval-inbox.js';
 import { SCREEN_BLOCKED_SOURCE } from './screen-blocked.js';
+import { PromptCacheKeepWarmService } from '../prompt-cache-keepwarm.js';
+import { composerIsEmpty, plainFrame } from '../session-submit-verifier.js';
+import { detectUsageLimitPause } from '../usage-limit-patterns.js';
 import { stopDeepSeekWeb } from '../deepseek-web-server.js';
 import { wireRespawnListeners, setupTimedRespawn, restoreRespawnController, saveRespawnConfig, } from './respawn-event-wiring.js';
 import { reconcileUpdateOnBoot } from './self-update.js';
@@ -114,23 +120,31 @@ import { MAX_PASTE_IMAGE_BYTES } from '../config/buffer-limits.js';
 import { resolveTerminalHistoryConfig } from '../config/terminal-history.js';
 import { SseEvent } from './sse-events.js';
 import { MAX_ROUTE_PARAM_LENGTH } from './route-helpers.js';
-import { getLatestPlanUsage, setLatestCodexPlanUsage } from './plan-usage-latest.js';
+import { getLatestPlanUsage, setLatestCodexPlanUsage, setLatestCopilotPlanUsage } from './plan-usage-latest.js';
 import { telemetrySignature } from '../usage-telemetry.js';
 import { readCodexPlanUsage, resolveCodexBinaryPath } from '../utils/codex-cli-resolver.js';
+import { isCopilotAvailable } from '../utils/copilot-cli-resolver.js';
+import { readCopilotPlanUsage, readCopilotPlanUsageIfEnabled, resolveCopilotToken, } from '../utils/copilot-plan-usage.js';
 import { registerAuthMiddleware, registerSecurityHeaders, registerHostGuard, isLostWebviewRootFrame, sendLostWebviewFramePage, } from './middleware/auth.js';
 import { isMultiUserMode } from '../config/multiuser.js';
 import { bootstrapInitialAdmin, hasUsers, resolveClaudeModeForUsername } from '../user-store.js';
 import { installRouteErrorHandler } from './route-error-handler.js';
 import { isExplicitlyEnabled, isLoopbackBindHost, buildHostPolicy } from './network-auth-policy.js';
-import { registerPushRoutes, registerTeamRoutes, registerMuxRoutes, registerFileRoutes, registerHtmlViewRoutes, registerScheduledRoutes, registerHookEventRoutes, registerApprovalRoutes, registerRebootRestoreRoutes, registerReadMyMindRoutes, registerGitStatusRoutes, registerStatusTelemetryRoutes, registerSystemRoutes, registerCaseRoutes, registerWorktreeRoutes, registerSessionRoutes, registerRespawnRoutes, registerRalphRoutes, registerPlanRoutes, registerClipboardRoutes, registerSearchRoutes, registerOrchestratorRoutes, registerCronRoutes, registerMeRoutes, registerAdminRoutes, registerWsRoutes, registerVoiceRoutes, registerWebviewRoutes, registerTabLayoutRoutes, registerMcpSyncRoutes, registerWebhookRoutes, registerDoctorRoutes, registerCustomModelRoutes, refreshAllCustomModelHosts, readCustomModelEndpointsEnabled, closeAllLlamaSwapLogTails, detectCustomModelSwapDisplacements, pruneIdleLlamaSwapLogTails, tryWebviewRefererFallback, registerCliRegistryRoutes, } from './routes/index.js';
+import { registerPushRoutes, registerTeamRoutes, registerMuxRoutes, registerFileRoutes, registerHtmlViewRoutes, registerScheduledRoutes, registerHookEventRoutes, registerApprovalRoutes, registerInboxRoutes, registerRebootRestoreRoutes, registerReadMyMindRoutes, registerGitStatusRoutes, registerStatusTelemetryRoutes, registerSystemRoutes, registerCaseRoutes, registerWorktreeRoutes, registerSessionRoutes, registerRespawnRoutes, registerRalphRoutes, registerPlanRoutes, registerClipboardRoutes, registerSearchRoutes, registerOrchestratorRoutes, registerCronRoutes, registerMeRoutes, registerAdminRoutes, registerWsRoutes, registerVoiceRoutes, registerWebviewRoutes, registerTabLayoutRoutes, registerMcpSyncRoutes, registerConfigBackupRoutes, runConfigBackup, registerWebhookRoutes, registerDoctorRoutes, registerCustomModelRoutes, refreshAllCustomModelHosts, readCustomModelEndpointsEnabled, closeAllLlamaSwapLogTails, detectCustomModelSwapDisplacements, pruneIdleLlamaSwapLogTails, tryWebviewRefererFallback, registerCliRegistryRoutes, } from './routes/index.js';
 import { isLostWebviewFrameNavigation } from './webview-proxy.js';
 import { CronService } from '../cron/cron-service.js';
+import { caseSessionSettled } from '../case-rename.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Bounded, predictable shape for SSE client identifiers: alphanumerics, `_`, `-`.
 // Length range covers crypto.randomUUID() (36 chars) plus any short stable IDs,
 // while capping growth of `sseClientsById` and blocking pathological inputs.
 const SSE_CLIENT_ID_RE = /^[A-Za-z0-9_-]{8,64}$/;
 const CODEX_USAGE_POLL_INTERVAL_MS = 5 * 60_000;
+// Copilot's quota is read over the network from GitHub, and a monthly figure moves slowly.
+const COPILOT_USAGE_POLL_INTERVAL_MS = 10 * 60_000;
+// Config backups: one cheap read-and-hash of a handful of small files; a snapshot is written only when
+// their content changed since the latest one, so this is one entry per real change, not per tick.
+const CONFIG_BACKUP_INTERVAL_MS = 5 * 60_000;
 const CUSTOM_MODEL_REDISCOVER_INTERVAL_MS = 5 * 60_000;
 // Much shorter than the model-LIST refresh above on purpose: this catches an actual
 // eviction (a session's model no longer loaded, silently swapped out by another
@@ -196,6 +210,50 @@ export class WebServer extends EventEmitter {
     _customModelDisplacedNotified = new Set();
     /** Cron service (assigned in setupRoutes). */
     cronService;
+    // Prompt-cache keep-warm (prompt-cache-keepwarm.ts): the rulebook and timers live in the
+    // service; the server only lends it the facts a decision needs. A field initializer, not a
+    // setupRoutes() step: cleanup and listener wiring reach it on servers that never set up routes
+    // (the pane-exit and discard tests build a bare WebServer), and every port reads `this.*` lazily.
+    keepWarmService = new PromptCacheKeepWarmService({
+        getSession: (id) => this.sessions.get(id),
+        sessionIds: () => this.sessions.keys(),
+        readSettings: readKeepWarmSettingsOrThrow,
+        isAutomationActive: (id) => {
+            const session = this.sessions.get(id);
+            if (!session)
+                return true;
+            return ((this.respawnControllers.get(id)?.isRunning ?? false) ||
+                session.ralphTracker.loopState.active ||
+                session.currentTaskId !== null ||
+                sessionWaits.signalWaiterCount(id) > 0);
+        },
+        hasPendingApproval: (id) => approvalInbox.listPending().some((item) => item.sessionId === id && item.kind !== 'idle'),
+        readPane: (view) => {
+            const session = view;
+            const muxName = session.muxName;
+            // `capture-pane -p -e`: the visible frame with its styles, which is how `composerIsEmpty()`
+            // tells Claude Code's faint prompt suggestion from a typed draft.
+            const text = muxName ? (this.mux.capturePaneText?.(muxName, undefined, { styles: true }) ?? null) : null;
+            if (!text)
+                return { composerEmpty: null, limitShown: false };
+            const limit = detectUsageLimitPause(plainFrame(text));
+            return {
+                composerEmpty: composerIsEmpty(text, getCli(session.mode)?.capabilities.workDetect?.promptGlyph ?? '') ?? null,
+                limitShown: limit !== null && limit.resetAt > Date.now(),
+            };
+        },
+        publish: (id, status) => {
+            const session = this.sessions.get(id);
+            if (!session?.setKeepWarmStatus(status))
+                return;
+            this.broadcast(SseEvent.SessionKeepWarm, { sessionId: id, ...status });
+            // Change-only, so one line per transition names whichever guard holds it now.
+            if (status.state !== 'off' || status.reason !== 'off') {
+                console.log(`[KeepWarm] ${id.slice(0, 8)}: ${status.state}${status.reason ? ` (${status.reason})` : ''}`);
+            }
+        },
+        log: (message) => console.log(message),
+    });
     /**
      * Wake-on-LAN registry, returned by `registerSessionRoutes`. Held for its LIFETIME
      * only — `drop()` on session cleanup, `stop()` on shutdown. Waking from here would
@@ -232,6 +290,8 @@ export class WebServer extends EventEmitter {
     lastRecordedTokens = new Map();
     codexUsageRefreshInFlight = false;
     lastCodexUsageSignature = null;
+    copilotUsageRefreshInFlight = false;
+    lastCopilotUsageSignature = null;
     // Server startup time for respawn grace period calculation
     serverStartTime = Date.now();
     // Pending respawn start timers (for cleanup on shutdown)
@@ -249,6 +309,7 @@ export class WebServer extends EventEmitter {
     qrAuthFailures = null;
     hookSecretFailures = null;
     userFailures = null;
+    userIpFailures = null;
     pushStore = new PushSubscriptionStore();
     /** ntfy / Slack / Discord / generic webhook for the push events; config in webhook.json (0600). */
     webhookNotifier = new WebhookNotifier(() => readWebhookConfig(getDataDir()), webviewFetch);
@@ -315,6 +376,7 @@ export class WebServer extends EventEmitter {
             // Fresh, not the 2s cache: the settings PUT does not invalidate it, and a
             // flip must apply to the very next spawn.
             childrenFollowParent: async () => (await this.readSettings(true)).spawnedTabsFollowParent === true,
+            caseDefaults: this.store,
         });
         if (this.testMode)
             this.tabLayouts.markRestorationSkipped();
@@ -551,12 +613,14 @@ export class WebServer extends EventEmitter {
     /**
      * Add a tentative session only after its owner layout accepts the creation.
      * The session enters the live map inside the layout service's owner lock, so
-     * the placement it asked for (`tabGroupId`) lands in the same versioned write
-     * that first records it.
+     * the placement it asked for (`tabGroupId`, else its case's default group)
+     * lands in the same versioned write that first records it.
      */
     async registerSessionWithLayout(session, placement) {
         return this.tabLayouts.sessionCreated(ownerLayoutKey(session.owner), session.id, placement, () => {
             this.sessions.set(session.id, session);
+            // In the map now, so a case rename lists (and on request stops) it instead of refusing the move.
+            caseSessionSettled(session);
             return () => {
                 if (this.sessions.get(session.id) === session)
                     this.sessions.delete(session.id);
@@ -573,6 +637,7 @@ export class WebServer extends EventEmitter {
         return {
             // SessionPort
             sessions: this.sessions,
+            keepWarm: this.keepWarmService,
             addSession: this.registerSessionWithLayout.bind(this),
             tabLayouts: this.tabLayouts,
             cleanupSession: this.cleanupSession.bind(this),
@@ -709,6 +774,7 @@ export class WebServer extends EventEmitter {
             this.qrAuthFailures = authState.qrAuthFailures;
             this.hookSecretFailures = authState.hookSecretFailures;
             this.userFailures = authState.userFailures;
+            this.userIpFailures = authState.userIpFailures;
         }
         // WebSocket support (terminal I/O — low-latency bidirectional channel)
         await this.app.register(fastifyWebsocket);
@@ -972,6 +1038,7 @@ export class WebServer extends EventEmitter {
         registerScheduledRoutes(this.app, ctx);
         registerHookEventRoutes(this.app, ctx);
         registerApprovalRoutes(this.app, ctx);
+        registerInboxRoutes(this.app, ctx);
         registerRebootRestoreRoutes(this.app, ctx);
         registerReadMyMindRoutes(this.app, ctx);
         registerGitStatusRoutes(this.app, ctx);
@@ -993,6 +1060,7 @@ export class WebServer extends EventEmitter {
         registerWebviewRoutes(this.app, ctx, this.basePath);
         registerTabLayoutRoutes(this.app, ctx);
         registerMcpSyncRoutes(this.app);
+        registerConfigBackupRoutes(this.app);
         registerWebhookRoutes(this.app, {
             notifier: this.webhookNotifier,
             configDir: getDataDir(),
@@ -1203,6 +1271,7 @@ export class WebServer extends EventEmitter {
     }
     async _doCleanupSession(sessionId, killMux, reason, coordinateLayout = true) {
         const session = this.sessions.get(sessionId);
+        this.keepWarmService.remove(sessionId);
         const pinned = session?.pinned === true || this.store.getSession(sessionId)?.pinned === true;
         if (coordinateLayout && session && killMux && !pinned) {
             return this.tabLayouts.runSessionDeletion([{ id: sessionId, owner: session.owner }], () => this._doCleanupSession(sessionId, killMux, reason, false));
@@ -1378,6 +1447,12 @@ export class WebServer extends EventEmitter {
         // The 'exit' here is NOT redundant with the PTY-exit listener: listeners are
         // detached a few lines above, before `session.stop()`, so on a delete the
         // session's own exit event never reaches the registry.
+        // The agent inbox goes with a DELETED session only. killMux=false is shutdown or
+        // detach: mail posted before that is still there when the session is re-attached
+        // (while detached, the routes answer 404, so nothing new arrives). Before
+        // cancelAll, so a reader released by it reads an empty inbox.
+        if (killMux)
+            agentInbox.drop(sessionId);
         sessionWaits.notifySignal(sessionId, 'exit');
         sessionWaits.cancelAll(sessionId);
         approvalInbox.resolveForSession(sessionId, 'session_ended');
@@ -1625,6 +1700,9 @@ export class WebServer extends EventEmitter {
         });
     }
     async setupSessionListeners(session) {
+        // First keep-warm evaluation: publishes the effective opt-in for the Session Options
+        // readout even before any cache report arrives.
+        void this.keepWarmService.schedule(session.id);
         // Idempotent: the wiring exit handler detaches ALL listeners on every PTY exit
         // (removeSessionListenerRefs), so the re-attach routes (/interactive,
         // /interactive-respawn, /shell) call this again to restore observability
@@ -1653,6 +1731,7 @@ export class WebServer extends EventEmitter {
     buildSessionListenerDeps() {
         return {
             broadcast: this.broadcast.bind(this),
+            keepWarmSchedule: (id) => void this.keepWarmService.schedule(id),
             batchTerminalData: this.batchTerminalData.bind(this),
             batchTaskUpdate: this.batchTaskUpdate.bind(this),
             broadcastSessionStateDebounced: this.broadcastSessionStateDebounced.bind(this),
@@ -1849,6 +1928,12 @@ export class WebServer extends EventEmitter {
         const settings = await this.readSettings();
         return settings.agentSkillEnabled === true;
     }
+    // Whether pending agent-inbox mail is snapshotted to disk (synced
+    // `agentInboxPersistEnabled` setting). Default OFF: an absent key writes nothing.
+    async getAgentInboxPersistEnabled() {
+        const settings = await this.readSettings();
+        return settings.agentInboxPersistEnabled === true;
+    }
     // Whether a Claude session installs Codeman's hooks block into its workspace
     // (synced `workspaceHooksEnabled` setting). Default ON — an absent key means a
     // user who has never seen this setting, and OFF for them would mean no tab
@@ -2552,6 +2637,36 @@ export class WebServer extends EventEmitter {
             this.codexUsageRefreshInFlight = false;
         }
     }
+    /**
+     * Copilot's monthly premium-request quota for the shared plan-usage chip. Host-scoped and read-only
+     * like the Codex poll, and additionally gated by `readCopilotPlanUsageIfEnabled()`: only while
+     * plan-usage display is on (so turning the chip off also stops the outbound request), only with a
+     * sign-in token and only with the Copilot CLI installed; nothing is sent to GitHub otherwise.
+     */
+    async refreshCopilotPlanUsage() {
+        if (this.copilotUsageRefreshInFlight)
+            return;
+        this.copilotUsageRefreshInFlight = true;
+        try {
+            // A null clears the row, so switching the chip off also takes the last quota off the page.
+            const usage = await readCopilotPlanUsageIfEnabled({
+                planUsageEnabled: readPlanUsageTelemetryEnabled,
+                resolveToken: () => resolveCopilotToken(),
+                copilotInstalled: isCopilotAvailable,
+                read: (token) => readCopilotPlanUsage({ token }),
+            });
+            const signature = usage ? telemetrySignature(usage) : '';
+            if (signature === this.lastCopilotUsageSignature)
+                return;
+            this.lastCopilotUsageSignature = signature;
+            const snapshot = setLatestCopilotPlanUsage(usage);
+            this.cachedLightState = null;
+            this.broadcast(SseEvent.SessionStatusTelemetry, snapshot);
+        }
+        finally {
+            this.copilotUsageRefreshInFlight = false;
+        }
+    }
     async start() {
         // Multi-user first boot: create the initial admin from CODEMAN_USERNAME/PASSWORD
         // if there are no users yet, else refuse to start (there would be no way in).
@@ -2580,6 +2695,11 @@ export class WebServer extends EventEmitter {
         // This prevents race conditions where clients connect before state is ready
         // CRITICAL: Skip in test mode to prevent tests from picking up user sessions
         if (!this.testMode) {
+            // Pending agent mail first (opt-in snapshot), so it is in place before any
+            // route can answer. Pruned against the restored sessions in finalizeRestoredState.
+            const restoredMail = agentInboxPersistence.load(await this.getAgentInboxPersistEnabled());
+            if (restoredMail > 0)
+                console.log(`[AgentInbox] restored ${restoredMail} pending message(s)`);
             const restored = await this.restoreMuxSessions();
             await this.finalizeRestoredState(restored);
             // Instance-scoped reaper: after restore, `docker rm -f` managed containers of
@@ -2683,6 +2803,14 @@ export class WebServer extends EventEmitter {
         // Ensure the COD-54 hook secret exists on disk before any session exports
         // $CODEMAN_HOOK_SECRET_FILE — hook curls cat that path at execution time.
         getHookSecret();
+        // Config backups: a snapshot at start (the state the process found) and then on change.
+        if (!this.testMode) {
+            const backup = (reason) => void runConfigBackup(reason).catch((err) => console.warn('[config-backup] snapshot failed:', err instanceof Error ? err.message : err));
+            backup('startup');
+            this.cleanup.setInterval(() => backup('auto'), CONFIG_BACKUP_INTERVAL_MS, {
+                description: 'Config backup',
+            });
+        }
         // Main Codex subscription limits come from the signed-in local CLI. Keep
         // this read-only and host-scoped; multi-user SSE routing makes it admin-only.
         if (!this.testMode) {
@@ -2690,6 +2818,10 @@ export class WebServer extends EventEmitter {
             this.cleanup.setInterval(() => void this.refreshCodexPlanUsage(), CODEX_USAGE_POLL_INTERVAL_MS, {
                 description: 'Codex plan-usage refresh',
             });
+            void this.refreshCopilotPlanUsage();
+            this.cleanup.setInterval(() => void this.refreshCopilotPlanUsage(), COPILOT_USAGE_POLL_INTERVAL_MS, {
+                description: 'Copilot plan-usage refresh',
+            });
         }
         // Custom Model Endpoint Profiles (docs/custom-model-endpoints-plan.md): keeps
         // each saved endpoint's discovered model list current with no manual
@@ -3182,6 +3314,10 @@ export class WebServer extends EventEmitter {
                             // the launch conversation until the user types again, even though
                             // the re-attached CLI is on a post-`/clear` one.
                             lastSubmitAt: savedState?.lastSubmitAt,
+                            // The keep-warm choice and its cap's clock; with the restored `promptCache`
+                            // below, a future `expiresAt` re-arms the timer once the pane is attached.
+                            lastRealPromptAt: savedState?.lastRealPromptAt,
+                            keepWarmEnabled: savedState?.keepWarmEnabled,
                             // Conversations this pane provably owned, oldest first. Its tail is
                             // the conversation the CLI was on when the server stopped, which is
                             // what a re-attach must point the viewer at instead of the launch id.
@@ -3356,6 +3492,7 @@ export class WebServer extends EventEmitter {
                             }
                         }
                         this.sessions.set(session.id, session);
+                        caseSessionSettled(session);
                         await this.setupSessionListeners(session);
                         // Auto-attach PTY to the surviving tmux session immediately.
                         // This ensures ALL sessions resume capturing output right away,
@@ -3428,6 +3565,21 @@ export class WebServer extends EventEmitter {
         this.tabLayouts.markRestorationComplete();
         await this.cleanupStaleSessions();
         await this.tabLayouts.reconcileAfterRestoration();
+        // Same gate as the tab layouts: only a restore that succeeded may decide which
+        // inboxes are orphans. A failed one returns above and leaves every message alone.
+        // Kept: live sessions plus every record state.json still holds (a session that
+        // was not re-adopted this boot but is kept for recovery keeps its mail), plus the
+        // sessions on the reboot-restore offer. `cleanupStaleSessions()` above has already
+        // pruned their records, and a rebuild reuses the old id, so without them a restored
+        // session would come back to an empty inbox. The 12 h TTL bounds what is never rebuilt.
+        const keep = new Set([
+            ...this.sessions.keys(),
+            ...Object.keys(this.store.getSessions()),
+            ...rebootRestoreRegistry.list(() => true).map((entry) => entry.sessionId),
+        ]);
+        const pruned = agentInbox.pruneExcept(keep);
+        if (pruned > 0)
+            console.log(`[AgentInbox] dropped ${pruned} inbox(es) of sessions that did not come back`);
     }
     /**
      * Install Codeman's hooks into the workspaces of the sessions just recovered.
@@ -3582,6 +3734,8 @@ export class WebServer extends EventEmitter {
         // port against the next start — the exact EADDRINUSE this feature already
         // got wrong once.
         void stopDeepSeekWeb();
+        // The header's GPU / CPU clock sampler is a Windows child process under WSL, and its idle sweep a timer.
+        stopHostSensors();
         // Same teardown rule: the per-endpoint llama-swap log tails are otherwise closed
         // only by the periodic idle sweep, whose interval is disposed just below.
         closeAllLlamaSwapLogTails();
@@ -3594,8 +3748,12 @@ export class WebServer extends EventEmitter {
         // response), so without this a 10-minute wait holds shutdown open.
         sessionWaits.cancelEverything();
         approvalInbox.stop();
+        this.keepWarmService.stop();
+        // A post within the debounce window before shutdown would otherwise not reach disk.
+        // Flushed again after `app.close()` below, for a post that lands in between.
+        agentInboxPersistence.flush();
         // Same reason as `cancelEverything` above: an in-flight wake is awaited by a request,
-        // and `app.close()` (the last line of this method) does not abort in-flight requests —
+        // and `app.close()` (at the end of this method) does not abort in-flight requests,
         // so without this a restart during a wake waits out the readiness poll.
         this.remoteWake?.stop();
         this.lastRecordedTokens.clear();
@@ -3710,12 +3868,23 @@ export class WebServer extends EventEmitter {
             this.userFailures.dispose();
             this.userFailures = null;
         }
+        if (this.userIpFailures) {
+            this.userIpFailures.dispose();
+            this.userIpFailures = null;
+        }
         this.activePlanOrchestrators.clear();
         this.cleaningUp.clear();
         this.killingSessions.clear();
         // Dispose push store (flush pending saves)
         this.pushStore.dispose();
-        await this.app.close();
+        try {
+            await this.app.close();
+        }
+        finally {
+            // The routes answer until `app.close()` returns, so a post after the flush above
+            // would otherwise sit in an unref'd debounce timer and never reach disk.
+            agentInboxPersistence.flush();
+        }
     }
 }
 export async function startWebServer(port = 3000, https = false, testMode = false, host = '127.0.0.1', titleHostname, allowUnauthenticatedNetwork = false, basePath = '') {