onbuzz 5.4.0 → 5.4.3

package/src/core/__tests__/stateManager.snippetCache.test.js

@@ -20,6 +20,8 @@ const mockReadFile = jest.fn().mockResolvedValue('{}');
 const mockWriteFile = jest.fn().mockResolvedValue(undefined);
 const mockUnlink = jest.fn().mockResolvedValue(undefined);
 const mockReaddir = jest.fn().mockResolvedValue([]);
+// saveJSON now writes atomically: writeFile(<path>.tmp) then rename(tmp -> path).
+const mockRename = jest.fn().mockResolvedValue(undefined);
 
 jest.unstable_mockModule('fs', () => ({
   promises: {
@@ -28,6 +30,7 @@ jest.unstable_mockModule('fs', () => ({
     writeFile: mockWriteFile,
     unlink: mockUnlink,
     readdir: mockReaddir,
+    rename: mockRename,
   },
 }));
 
@@ -136,6 +139,7 @@ describe('StateManager — snippet caching', () => {
     mockReadFile.mockResolvedValue('{}');
     mockWriteFile.mockResolvedValue(undefined);
     mockReaddir.mockResolvedValue([]);
+    mockRename.mockResolvedValue(undefined);
     ({ sm, logger } = makeSM());
   });
 
@@ -195,14 +199,31 @@ describe('StateManager — snippet caching', () => {
     expect(written['a1'].firstUserMessage).toBe('from disk');
   });
 
-  test('archived cache MISS with missing conv file -> snippet stays undefined, no persist', async () => {
-    mockReadFile.mockRejectedValueOnce(new Error('ENOENT'));
+  test('archived cache MISS with MISSING conv file (ENOENT) -> snippet stays undefined, no persist (retry next time)', async () => {
+    const enoent = Object.assign(new Error('no such file'), { code: 'ENOENT' });
+    mockReadFile.mockRejectedValueOnce(enoent);
     const agents = [{ agentId: 'a1', isLoaded: false, conversationsFile: 'agents/a1-conv.json' }];
     await sm._enrichAgentsWithSnippets(agents, null, '/p');
     expect(agents[0].firstUserMessage).toBeUndefined();
     expect(mockWriteFile).not.toHaveBeenCalled();
   });
 
+  // The perf bug: a conversations file that EXISTS but can't be parsed (corrupt
+  // JSON, or too large to parse) used to be left undefined = a permanent cache
+  // miss, re-read (tens of MB) on EVERY list call forever. It must now be cached
+  // as null so the file is touched once and skipped thereafter.
+  test('archived cache MISS with CORRUPT conv file -> caches null + persists (read once, never again)', async () => {
+    const parseErr = new SyntaxError('Unexpected end of JSON input'); // no .code, like a real JSON.parse throw
+    mockReadFile
+      .mockRejectedValueOnce(parseErr)                              // the corrupt conversations read
+      .mockResolvedValueOnce(JSON.stringify({ a1: { name: 'A' } })); // index load inside _persistAgentSnippets
+    const agents = [{ agentId: 'a1', isLoaded: false, conversationsFile: 'agents/a1-conv.json' }];
+    await sm._enrichAgentsWithSnippets(agents, null, '/p');
+    expect(agents[0].firstUserMessage).toBe(null);
+    const written = JSON.parse(mockWriteFile.mock.calls[0][1]);
+    expect(written['a1'].firstUserMessage).toBe(null); // cached — next list is a hit, no re-read
+  });
+
   test('loaded agent but pool returns null -> falls through to disk', async () => {
     const agentPool = { getAgent: jest.fn().mockResolvedValue(null) };
     mockReadFile
@@ -383,8 +404,10 @@ describe('StateManager — snippet caching', () => {
       return '{}';
     });
     // Capture the backfill write so the 2nd call "sees" the warmed index.
+    // saveJSON writes to "<...>agent-index.json.<pid>.<n>.tmp", so match a
+    // substring rather than the exact suffix.
     mockWriteFile.mockImplementation(async (p, body) => {
-      if (String(p).endsWith('agent-index.json')) persisted = JSON.parse(body);
+      if (String(p).includes('agent-index.json')) persisted = JSON.parse(body);
     });
     mockReaddir.mockResolvedValue(['agent-a1-state.json']);
     const agentPool = { getAllAgents: jest.fn().mockResolvedValue([]) };

package/src/core/__tests__/stateManager.test.js

@@ -12,6 +12,8 @@ const mockReadFile = jest.fn().mockResolvedValue('{}');
 const mockWriteFile = jest.fn().mockResolvedValue(undefined);
 const mockUnlink = jest.fn().mockResolvedValue(undefined);
 const mockReaddir = jest.fn().mockResolvedValue([]);
+// saveJSON now writes atomically: writeFile(<path>.tmp) then rename(tmp -> path).
+const mockRename = jest.fn().mockResolvedValue(undefined);
 
 jest.unstable_mockModule('fs', () => ({
   promises: {
@@ -19,7 +21,8 @@ jest.unstable_mockModule('fs', () => ({
     readFile: mockReadFile,
     writeFile: mockWriteFile,
     unlink: mockUnlink,
-    readdir: mockReaddir
+    readdir: mockReaddir,
+    rename: mockRename
   }
 }));
 
@@ -57,6 +60,7 @@ describe('StateManager', () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    mockRename.mockResolvedValue(undefined);
     ({ sm, logger } = makeSM());
   });
 
@@ -278,14 +282,18 @@ describe('StateManager', () => {
 
   // ─── saveJSON / loadJSON ───────────────────────────────────────────────
   describe('saveJSON (private)', () => {
-    test('creates directory and writes JSON', async () => {
+    test('creates directory and writes JSON atomically (temp + rename)', async () => {
       await sm.saveJSON('/path/to/file.json', { key: 'value' });
       expect(mockMkdir).toHaveBeenCalledWith(expect.any(String), { recursive: true });
-      expect(mockWriteFile).toHaveBeenCalledWith(
-        '/path/to/file.json',
-        expect.any(String),
-        'utf8'
-      );
+      // Atomic write: the payload goes to a unique temp beside the target...
+      const [tmpPath, contents, enc] = mockWriteFile.mock.calls[0];
+      expect(tmpPath).toMatch(/^\/path\/to\/file\.json\.\d+\.\d+\.tmp$/);
+      expect(JSON.parse(contents)).toEqual({ key: 'value' });
+      expect(enc).toBe('utf8');
+      // ...then it's renamed over the live file.
+      expect(mockRename).toHaveBeenCalledWith(tmpPath, '/path/to/file.json');
+      // The live path is never written directly.
+      expect(mockWriteFile).not.toHaveBeenCalledWith('/path/to/file.json', expect.anything(), expect.anything());
     });
   });
 

package/src/core/agentPool.js

@@ -20,6 +20,7 @@ import {
 } from '../utilities/constants.js';
 import DirectoryAccessManager from '../utilities/directoryAccessManager.js';
 import { getVisualEditorBridge } from '../services/visualEditorBridge.js';
+import { getPromptService } from '../services/promptService.js';
 
 /**
  * Capabilities that were once granted but whose backing tool has since been
@@ -1469,9 +1470,35 @@ class AgentPool {
    * @private
    */
   async _wakeAgentForMessage(agent, reason) {
-    const info = { wasPaused: false, hadDelay: false, hadPausedUntil: false };
+    const info = { wasPaused: false, hadDelay: false, hadPausedUntil: false, wasAwaitingInput: false };
     if (!agent) return info;
 
+    // A real inbound message (from the user or another agent) SUPERSEDES a
+    // pending awaiting-user-input wait. Without this, an agent whose prompt
+    // was orphaned — the modal is gone, the in-memory prompt promise died in a
+    // restart, or the user simply chose to reply in chat instead of the modal —
+    // stays permanently skipped by the scheduler (shouldAgentBeActive bails on
+    // awaitingUserInput before it ever looks at the queue), so every message the
+    // user sends just piles up unprocessed. Clear the flag so the message gets
+    // handled, and cancel the live prompt request (user_prompt only) so the
+    // tool's promise rejects cleanly instead of leaking. Tool-result wakes are
+    // internal and don't count — the prompt's own completion path clears the
+    // flag there.
+    const isInboundMessage = reason === 'user-message' || reason === 'inter-agent-message';
+    if (isInboundMessage && agent.awaitingUserInput) {
+      info.wasAwaitingInput = true;
+      const { type, requestId } = agent.awaitingUserInput;
+      delete agent.awaitingUserInput;
+      if (type === 'user_prompt' && requestId) {
+        try {
+          getPromptService(this.logger).cancelRequest(requestId, `superseded by ${reason}`);
+        } catch (err) {
+          this.logger?.warn?.(`Failed to cancel superseded prompt ${requestId}: ${err.message}`);
+        }
+      }
+      this.logger.info(`Agent ${agent.id} awaitingUserInput (${type}) cleared — ${reason} supersedes the pending prompt`);
+    }
+
     // Auto-resume explicitly paused agent.
     if (agent.status === AGENT_STATUS.PAUSED) {
       info.wasPaused = true;

package/src/core/agentScheduler.js

@@ -27,6 +27,7 @@ import {
 import ContextInjectionService from '../services/contextInjectionService.js';
 import FlowContextService from '../services/flowContextService.js';
 import TokenCountingService from '../services/tokenCountingService.js';
+import { getEventLoopMonitor } from '../services/eventLoopMonitor.js';
 import { render as renderModeTransitionReason } from '../utilities/modeTransitionReasons.js';
 import ConversationCompactionService from '../services/conversationCompactionService.js';
 import { getToolSchemasForAgent } from '../tools/openaiFunctionSchemas.js';
@@ -109,6 +110,13 @@ class AgentScheduler {
     // base prompt or capabilities (see `_invalidateNativePromptCache`).
     this._nativePromptCache = new Map();   // `${agentId}|${modelName}` → string
 
+    // Per-MODEL rate-limit strike registry. Rate limits are enforced per
+    // provider+model (shared by every agent using that model), so strikes are
+    // counted per model, not per agent. Entry: { strikes, lastStrikeAt }.
+    // Strikes decay when no new 429 lands within RATE_LIMIT_STRIKE_WINDOW_MS.
+    // In-memory only — a process restart forgiving old strikes is fine.
+    this._modelRateLimits = new Map();     // modelName → { strikes, lastStrikeAt }
+
     // Initialize FlowContextService for flow execution context
     this.flowContextService = new FlowContextService({}, logger);
 
@@ -930,6 +938,16 @@ class AgentScheduler {
    * @param {string} agentId - Agent ID to process
    * @private
    */
+  /**
+   * Yield one macrotask so the event loop can service pending I/O (HTTP /
+   * WebSocket) between chunks of agent work. `setImmediate` runs after the poll
+   * phase, so queued request callbacks get a turn.
+   * @private
+   */
+  _yieldToLoop() {
+    return new Promise((resolve) => setImmediate(resolve));
+  }
+
   async processAgent(agentId) {
     // Check if this agent is already being processed
     if (this.agentProcessingLocks.get(agentId)) {
@@ -946,6 +964,15 @@ class AgentScheduler {
     this.agentProcessingLocks.set(agentId, true);
     this._lockAcquiredAt.set(agentId, new Date());
 
+    // Yield to the event loop before doing this agent's (partly synchronous)
+    // work — hashing, token counting, JSON (de)serialization. Agents run
+    // concurrently via Promise.all, so without this a burst of agents can
+    // monopolize the loop and starve HTTP/WebSocket, making the UI feel frozen
+    // "when agents are active". A single macrotask hop lets pending requests
+    // interleave. Cheap: ~0 added latency per agent.
+    await this._yieldToLoop();
+
+    const _procStart = Date.now();
     try {
       // Use centralized service to check if we should skip this iteration
       const skipCheck = shouldSkipIteration(agent);
@@ -1097,6 +1124,10 @@ class AgentScheduler {
       // Always clear processing lock, even on errors
       this.agentProcessingLocks.delete(agentId);
       this._lockAcquiredAt.delete(agentId);
+      // Record how long this agent's turn held the thread, so /api/system/event-loop
+      // shows the agent-processing p99 next to the loop-delay p99 — i.e. WHICH
+      // work to offload next, if any.
+      try { getEventLoopMonitor().recordPhase('agentProcessing', Date.now() - _procStart); } catch { /* never break the tick */ }
     }
   }
 
@@ -2943,18 +2974,26 @@ class AgentScheduler {
             this._broadcastStreamEvent(sessionId, streamCompleteEvent);
           },
           onError: (error) => {
-            // Check if this is a model-related error that should show suggestions
+            // PERSISTENT model errors (model not found / invalid model) show
+            // the switch-model modal immediately — they never self-heal.
+            // TRANSIENT ones (rate limit / overload / 5xx) go through the
+            // scheduler's quiet cooldown ladder instead; handleAIServiceFailure
+            // escalates them to the modal only after repeated strikes. The
+            // `transient` flag lets the UI clear the stream without raising an
+            // alarming red toast (the info toast rides agent_state_updated).
             const isModelError = this.aiService?.isModelRelatedError?.(error);
-            const modelSuggestions = isModelError && this.aiService?.getModelSuggestions?.(targetModel, error);
+            const isTransient = this.aiService?.isTransientModelError?.(error);
+            const showModal = isModelError && !isTransient;
+            const modelSuggestions = showModal && this.aiService?.getModelSuggestions?.(targetModel, error);
 
-            // Broadcast stream error with model suggestions if applicable
             this._broadcastStreamEvent(sessionId, {
-              type: isModelError ? 'model_error' : 'stream_error',
+              type: showModal ? 'model_error' : 'stream_error',
               agentId,
               messageId: streamMessageId,
               error: error.message,
               model: targetModel,
               timestamp: new Date().toISOString(),
+              ...(isTransient && { transient: true }),
               // Include model suggestions for model-related errors
               ...(modelSuggestions && { modelSuggestions }),
               // Include flow context if present
@@ -2985,18 +3024,23 @@ class AgentScheduler {
       // failure. Either way we don't want a zombie timer.
       clearPrestreamTimer();
 
-      // Check if this is a model-related error that should show suggestions
+      // Same transient/persistent gating as the streaming onError above:
+      // persistent model errors escalate to the modal immediately, transient
+      // ones stay quiet here and are escalated by handleAIServiceFailure
+      // only after repeated strikes.
       const isModelError = this.aiService?.isModelRelatedError?.(error);
-      const modelSuggestions = isModelError && this.aiService?.getModelSuggestions?.(targetModel, error);
+      const isTransient = this.aiService?.isTransientModelError?.(error);
+      const showModal = isModelError && !isTransient;
+      const modelSuggestions = showModal && this.aiService?.getModelSuggestions?.(targetModel, error);
 
-      // Broadcast error event with model suggestions if applicable
       this._broadcastStreamEvent(sessionId, {
-        type: isModelError ? 'model_error' : 'stream_error',
+        type: showModal ? 'model_error' : 'stream_error',
         agentId,
         messageId: streamMessageId,
         error: error.message,
         model: targetModel,
         timestamp: new Date().toISOString(),
+        ...(isTransient && { transient: true }),
         // Include model suggestions for model-related errors
         ...(modelSuggestions && { modelSuggestions }),
         // Include flow context if present
@@ -3213,22 +3257,50 @@ class AgentScheduler {
       this._broadcastAgentError(agent, 'API key issue — check Settings → API Keys.', error);
 
     } else if (isRateLimit) {
-      // TRANSIENT — provider asked us to back off. No broadcast.
-      this.logger.warn(`Agent ${agentId} delayed due to rate limiting`);
+      // TRANSIENT — provider asked us to back off. Escalation ladder:
+      // rate limits are minute-window (RPM/TPM), so strikes 1..N-1 take a
+      // QUIET 60s cooldown (info-level state update, no alarm). Strike N
+      // (= after N-1 failed cooldowns) means this isn't one unlucky window —
+      // broadcast model_error so the UI offers the switch-model modal, and
+      // back off longer. Strikes are counted PER MODEL (the limit is shared
+      // by every agent on that model) and decay after a quiet window.
+      const modelName = agent.currentModel || 'unknown-model';
+      const strikes = this._recordRateLimitStrike(modelName);
+      const escalated = strikes >= SCHEDULER_CONFIG.RATE_LIMIT_ESCALATION_STRIKES;
+      const delayMs = escalated
+        ? SCHEDULER_CONFIG.RATE_LIMIT_ESCALATED_DELAY_MS
+        : SCHEDULER_CONFIG.RATE_LIMIT_DELAY_MS;
+
+      // WARN so the Monitor App's live log push picks it up (warn/error only).
+      this.logger.warn(
+        `Model ${modelName} rate-limited (strike ${strikes}) — agent ${agent.name || agentId} cooling down ${Math.round(delayMs / 1000)}s${escalated ? '; suggesting model switch' : ''}`,
+        { agentId, model: modelName, strikes, delayMs, escalated }
+      );
 
-      agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.RATE_LIMIT_DELAY_MS).toISOString();
+      agent.delayEndTime = new Date(Date.now() + delayMs).toISOString();
       await this._recordAgentFailure(agent, error, 'rate-limit');
       await this.agentPool.persistAgentState(agentId);
       await this.broadcastAgentStateUpdate(agentId, 'rate-limit');
 
+      // The limit is per-model and SHARED: cool down the other agents on this
+      // model too (staggered), instead of letting each burn a request to
+      // discover the same wall and then re-stampede it in unison.
+      await this._applyModelCooldown(modelName, agentId, delayMs);
+
+      if (escalated) {
+        // Offer the switch-model modal. This also covers the non-streaming
+        // path, which previously never surfaced model suggestions at all.
+        this._broadcastModelErrorSuggestions(agent, sessionId, error);
+      }
+
     } else if (isProviderOverload) {
       // TRANSIENT — provider is over capacity (e.g. Anthropic 529). No
-      // broadcast: there's nothing actionable on the user's side. Reuse
-      // rate-limit's 2-min delay since the upstream advice is identical:
-      // "back off and try again."
+      // broadcast: there's nothing actionable on the user's side. Unlike a
+      // rate limit this is NOT a minute-window reset — capacity problems
+      // last longer, so it keeps its own 2-minute lane.
       this.logger.warn(`Agent ${agentId} delayed due to provider overload`);
 
-      agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.RATE_LIMIT_DELAY_MS).toISOString();
+      agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.PROVIDER_OVERLOAD_DELAY_MS).toISOString();
       await this._recordAgentFailure(agent, error, 'provider-overload');
       await this.agentPool.persistAgentState(agentId);
       await this.broadcastAgentStateUpdate(agentId, 'provider-overload');
@@ -3283,6 +3355,92 @@ class AgentScheduler {
     }
   }
 
+  /**
+   * Record a rate-limit strike against a MODEL and return the running count.
+   * Strikes decay: if no strike landed within RATE_LIMIT_STRIKE_WINDOW_MS,
+   * the count restarts at 1 (an old bad minute shouldn't haunt a model).
+   * @param {string} modelName
+   * @returns {number} strike count including this one
+   * @private
+   */
+  _recordRateLimitStrike(modelName) {
+    const now = Date.now();
+    const entry = this._modelRateLimits.get(modelName);
+    if (!entry || (now - entry.lastStrikeAt) > SCHEDULER_CONFIG.RATE_LIMIT_STRIKE_WINDOW_MS) {
+      this._modelRateLimits.set(modelName, { strikes: 1, lastStrikeAt: now });
+      return 1;
+    }
+    entry.strikes += 1;
+    entry.lastStrikeAt = now;
+    return entry.strikes;
+  }
+
+  /**
+   * Cool down every OTHER active agent currently using `modelName`.
+   *
+   * Rate limits are per provider+model and shared across agents, so when one
+   * agent hits the wall the others are about to. Each gets a delayEndTime of
+   * (cooldown end + i * MODEL_COOLDOWN_STAGGER_MS) so wake-ups are spread out
+   * instead of stampeding the freshly reset window in unison. Never SHORTENS
+   * an existing longer delay. Routing through delayEndTime (rather than a
+   * separate gate) keeps the existing behavior where an inbound user message
+   * can still wake a delayed agent early.
+   *
+   * Best-effort: failures only log. @private
+   */
+  async _applyModelCooldown(modelName, sourceAgentId, delayMs) {
+    try {
+      const all = await this.agentPool.getAllAgents();
+      let staggerIndex = 0;
+      for (const other of all || []) {
+        if (!other || other.id === sourceAgentId) continue;
+        if (other.currentModel !== modelName) continue;
+
+        const staggeredEnd = Date.now() + delayMs + (++staggerIndex * SCHEDULER_CONFIG.MODEL_COOLDOWN_STAGGER_MS);
+        const existingEnd = other.delayEndTime ? new Date(other.delayEndTime).getTime() : 0;
+        if (staggeredEnd <= existingEnd) continue; // already delayed longer
+
+        other.delayEndTime = new Date(staggeredEnd).toISOString();
+        await this.agentPool.persistAgentState(other.id);
+        await this.broadcastAgentStateUpdate(other.id, 'rate-limit-cooldown');
+      }
+      if (staggerIndex > 0) {
+        this.logger.warn(
+          `Model ${modelName} rate-limited — cooled down ${staggerIndex} other agent(s) using it, staggered ${SCHEDULER_CONFIG.MODEL_COOLDOWN_STAGGER_MS / 1000}s apart`,
+          { model: modelName, cooledAgents: staggerIndex }
+        );
+      }
+    } catch (err) {
+      this.logger.warn(`Failed to apply model cooldown for ${modelName}: ${err.message}`);
+    }
+  }
+
+  /**
+   * Broadcast a `model_error` (switch-model modal) with suggestions for the
+   * agent's current model. Used by the rate-limit ESCALATION step — after
+   * repeated failed cooldowns — for both streaming and non-streaming paths.
+   * Payload shape matches _broadcastStreamEvent's model_error so the web-UI
+   * handler (pendingModelError → ModelErrorModal) works unchanged.
+   * Best-effort: never throws. @private
+   */
+  _broadcastModelErrorSuggestions(agent, sessionId, error) {
+    try {
+      const modelSuggestions = this.aiService?.getModelSuggestions?.(agent.currentModel, error);
+      if (!modelSuggestions) return;
+      this._broadcastStreamEvent(sessionId, {
+        type: 'model_error',
+        agentId: agent.id,
+        error: error.message,
+        model: agent.currentModel,
+        modelSuggestions,
+        escalatedFromRateLimit: true,
+        timestamp: new Date().toISOString(),
+      });
+    } catch (err) {
+      this.logger?.warn?.(`model_error escalation broadcast failed: ${err.message}`, { agentId: agent?.id });
+    }
+  }
+
   /**
    * Push a visible error turn into the agent's conversation log and
    * snapshot `agent.lastError` so REST polling (get_agent_conversations

package/src/core/stateManager.js

@@ -82,6 +82,15 @@ class StateManager {
     // Legacy: Keep for backwards compatibility detection
     this.legacyStateDirectory = config.system?.stateDirectory || '.loxia-state';
     this.stateVersion = '1.0.0';
+
+    // Per-file write serialization. saveJSON writes are chained per target path
+    // so two concurrent saves of the SAME file can never interleave. ~30 code
+    // paths (every AI turn, the scheduler, agent-to-agent messages, tools) call
+    // persistAgentState on their own schedule; without this, two overlapping
+    // saves of one agent's (tens-of-MB) conversations file could leave a shorter
+    // new write sitting on top of a longer old one — real corruption we've seen.
+    this._writeChains = new Map();
+    this._tmpWriteSeq = 0;
     
     // State file paths
     this.stateFiles = {
@@ -948,6 +957,20 @@ class StateManager {
         _restoreRecoveries: recoveries,
       };
 
+      // RECOVERY: an agent persisted mid-prompt is reborn with awaitingUserInput
+      // set, but the in-memory prompt promise died with the old process — the
+      // requestId now points at nothing, and the scheduler would skip this agent
+      // forever (queued messages included). Clear the stale flag so it can be
+      // driven again; any queued/new message picks it right back up. Mirrors
+      // agentPool.rehydrateFromState's recovery.
+      if (restoredAgent.awaitingUserInput) {
+        this.logger.warn(`Restored agent ${agentId} was awaiting user input (${restoredAgent.awaitingUserInput.type}) — clearing stale flag`, {
+          inputType: restoredAgent.awaitingUserInput.type,
+          startedAt: restoredAgent.awaitingUserInput.startedAt,
+        });
+        delete restoredAgent.awaitingUserInput;
+      }
+
       // CRITICAL: Restore interAgentTracking as a Map (it comes as plain object from JSON)
       if (!restoredAgent.interAgentTracking || typeof restoredAgent.interAgentTracking !== 'object') {
         restoredAgent.interAgentTracking = new Map();
@@ -1212,11 +1235,71 @@ class StateManager {
    * @private
    */
   async saveJSON(filePath, data) {
+    // Serialize writes per target path (see this._writeChains) AND write
+    // atomically (see _atomicWriteFile). Together these close the two ways state
+    // files got corrupted: a save interrupted mid-write (process killed / update
+    // restart) now only ever damages a throwaway temp file — the live file is
+    // swapped in by an atomic rename or not at all; and two concurrent saves of
+    // the same file can no longer interleave into a half-old/half-new mess.
+    const jsonData = JSON.stringify(data, null, 2);
+    const key = path.resolve(filePath);
+
+    const prior = this._writeChains.get(key) || Promise.resolve();
+    // The next write waits for the prior one to SETTLE (success or failure)
+    // before starting — a failed prior write must not block the queue.
+    const run = prior.catch(() => {}).then(() => this._atomicWriteFile(filePath, jsonData));
+    this._writeChains.set(key, run);
+    // Drop the chain entry once this write is the tail and has settled, so the
+    // map doesn't grow unbounded across the app's lifetime.
+    run.catch(() => {}).finally(() => {
+      if (this._writeChains.get(key) === run) this._writeChains.delete(key);
+    });
+    return run;
+  }
+
+  /**
+   * Write a file atomically: write to a unique temp file in the SAME directory,
+   * then rename it over the target. rename() on the same volume is atomic — a
+   * reader/observer sees either the complete old file or the complete new one,
+   * never a partial write. The temp lives beside the target (not in the OS temp
+   * dir) so the rename stays within one filesystem.
+   *
+   * On Windows, replacing a file that another handle has open (e.g. a concurrent
+   * reader in the agent-list scan) can transiently fail with EPERM/EACCES/EBUSY;
+   * we retry a few times with a short backoff before giving up.
+   * @private
+   */
+  async _atomicWriteFile(filePath, contents) {
     const dir = path.dirname(filePath);
     await fs.mkdir(dir, { recursive: true });
-    
-    const jsonData = JSON.stringify(data, null, 2);
-    await fs.writeFile(filePath, jsonData, 'utf8');
+
+    const tmpPath = `${filePath}.${process.pid}.${++this._tmpWriteSeq}.tmp`;
+    try {
+      await fs.writeFile(tmpPath, contents, 'utf8');
+      await this._renameWithRetry(tmpPath, filePath);
+    } catch (err) {
+      // Best-effort cleanup of the temp file; never mask the original error.
+      try { await fs.unlink(tmpPath); } catch { /* already gone */ }
+      throw err;
+    }
+  }
+
+  /**
+   * fs.rename with a small retry for the transient Windows sharing-violation
+   * errors that occur when a replace races an open read handle.
+   * @private
+   */
+  async _renameWithRetry(from, to, attempts = 5) {
+    for (let i = 0; i < attempts; i++) {
+      try {
+        await fs.rename(from, to);
+        return;
+      } catch (err) {
+        const transient = err && (err.code === 'EPERM' || err.code === 'EACCES' || err.code === 'EBUSY');
+        if (!transient || i === attempts - 1) throw err;
+        await new Promise((r) => setTimeout(r, 15 * (i + 1)));
+      }
+    }
   }
 
   /**
@@ -1701,8 +1784,20 @@ class StateManager {
             const messages = convData?.conversations?.full?.messages || convData?.full?.messages;
             agent.firstUserMessage = extractFirstUserMessageSnippet(messages);
             backfilled.push(agent);
-          } catch {
-            // File may not exist — leave snippet undefined, don't cache.
+          } catch (err) {
+            // A MISSING file (ENOENT) may legitimately reappear later (e.g. an
+            // agent still being written), so leave its snippet undefined and
+            // retry on the next list. But a file that EXISTS and can't be
+            // read/parsed — corrupt JSON, or simply too large to parse — would
+            // otherwise be re-read (potentially tens of MB) on EVERY list call
+            // forever, since undefined is treated as a cache miss. That is the
+            // single worst offender behind slow agent-list loads. Cache the
+            // failure as null so the file is touched once and skipped from then
+            // on; a later successful write refreshes it via updateAgentIndex.
+            if (err?.code !== 'ENOENT') {
+              agent.firstUserMessage = null;
+              backfilled.push(agent);
+            }
           }
         }
       } catch {

package/src/index.js

@@ -29,6 +29,7 @@ import ModelRouterService from './services/modelRouterService.js';
 import ModelsService from './services/modelsService.js';
 import ApiKeyManager, { registerApiKeyManager } from './services/apiKeyManager.js';
 import { getCredentialVault } from './services/credentialVault.js';
+import { getEventLoopMonitor } from './services/eventLoopMonitor.js';
 import FileAttachmentService from './services/fileAttachmentService.js';
 import { ToolsRegistry } from './tools/baseTool.js';
 import AgentDelayTool from './tools/agentDelayTool.js';
@@ -190,6 +191,10 @@ class LoxiaApplication {
     });
 
     await this.logger.initialize();
+
+    // Start measuring event-loop delay from process start so /api/system/event-loop
+    // reflects real load (the honest "are routes competing for CPU?" signal).
+    getEventLoopMonitor().start();
   }
 
   /**