@openagents-org/agent-launcher 0.2.192 → 0.2.193

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.192",
+  "version": "0.2.193",
   "description": "OpenAgents Launcher \u2014 install, configure, and run AI coding agents from your terminal",
   "main": "src/index.js",
   "bin": {

package/src/adapters/base.js

@@ -35,6 +35,7 @@ const {
   classifyHeartbeatError,
   httpStatusOf,
 } = require('./health-status');
+const { FailureStreak, isTransientNetworkError, formatDuration } = require('./failure-streak');
 
 const DEFAULT_ENDPOINT = 'https://workspace-endpoint.openagents.org';
 
@@ -104,7 +105,7 @@ class BaseAdapter {
    * @param {string} opts.agentName
    * @param {string} [opts.endpoint]
    */
-  constructor({ workspaceId, channelName, token, agentName, endpoint, agentEnv, agentType, workingDir, onStatus }) {
+  constructor({ workspaceId, channelName, token, agentName, endpoint, agentEnv, agentType, workingDir, onStatus, logSink }) {
     this.workspaceId = workspaceId;
     this.channelName = channelName;
     this.token = token;
@@ -198,10 +199,17 @@ class BaseAdapter {
     // (e.g. after a `restart` IPC bounce) so uptime tracks "time since last
     // restart" rather than the long-running daemon's process uptime.
     this._startedAt = Date.now();
-    this._log = (msg) => {
+    // Inside the daemon, `logSink` routes lines through its daemon.log writer
+    // (batching, repeat suppression, rotation). Standalone, they go to stdout.
+    const sink = typeof logSink === 'function' ? logSink : null;
+    this._log = (msg, level = 'info') => {
+      if (sink) return sink(level, msg);
       const ts = new Date().toISOString();
-      console.log(`${ts} INFO adapter [${this.agentName}]: ${msg}`);
+      console.log(`${ts} ${String(level).toUpperCase()} adapter [${this.agentName}]: ${msg}`);
     };
+    // Runs of identical background failures (see failure-streak.js).
+    this._pollFailures = new FailureStreak();
+    this._heartbeatFailures = new FailureStreak();
   }
 
   // ------------------------------------------------------------------
@@ -337,7 +345,7 @@ class BaseAdapter {
         this._log(`Synced model from workspace: ${this.workspaceModel}`);
       }
     } catch (e) {
-      this._log(`Warning: skill sync failed (non-fatal): ${e.message}`);
+      this._log(`Warning: skill sync failed (non-fatal): ${e.message}`, 'warn');
     }
 
     // Fast-path operations (control-event cursor + heartbeat + control poll)
@@ -352,7 +360,7 @@ class BaseAdapter {
     try {
       // Send initial heartbeat
       try { await this._heartbeat(); } catch (e) {
-        this._log(`Heartbeat failed (non-fatal): ${e.message}`);
+        this._log(`Heartbeat failed (non-fatal): ${e.message}`, 'warn');
       }
       // Slow path: only the message-poll loop waits for this.
       await this._skipExistingEvents();
@@ -412,7 +420,7 @@ class BaseAdapter {
     } catch (e) {
       if (!this._warnedCursorPersist) {
         this._warnedCursorPersist = true;
-        this._log(`Could not persist poll cursor (${e.message}) — a restart will skip messages that arrive while offline`);
+        this._log(`Could not persist poll cursor (${e.message}) — a restart will skip messages that arrive while offline`, 'warn');
       }
     }
   }
@@ -457,10 +465,14 @@ class BaseAdapter {
     try {
       await this.client.heartbeat(this.workspaceId, this.agentName, this.token, this._sessionId);
       this._heartbeatFailStreak = 0;
+      const recovered = this._heartbeatFailures.succeed();
+      if (recovered) {
+        this._log(`Workspace heartbeat recovered after ${recovered.count} unsuccessful attempt(s) over ${formatDuration(recovered.ms)}`);
+      }
       this._reportStatus(null); // alive → clear any prior connectivity error
     } catch (e) {
       if (e instanceof SessionRevokedError) {
-        this._log(`SESSION REVOKED: another client joined as '${this.agentName}'. Stopping adapter.`);
+        this._log(`SESSION REVOKED: another client joined as '${this.agentName}'. Stopping adapter.`, 'warn');
         // Terminal (not a user stop): record so the daemon can show why it ended.
         this._setExitInfo(REASON.SESSION_REVOKED, 'Workspace session revoked — another client joined with the same agent name');
         this._reportStatus(REASON.SESSION_REVOKED, 'Workspace session revoked');
@@ -471,7 +483,9 @@ class BaseAdapter {
       // single transient blip (or an expected brief reconnect) isn't mislabeled.
       this._heartbeatFailStreak++;
       const { reason, message } = classifyHeartbeatError(e);
-      this._log(`${message} (consecutive failures: ${this._heartbeatFailStreak})`);
+      if (this._heartbeatFailures.fail()) {
+        this._log(`${message} (consecutive failures: ${this._heartbeatFailStreak})`, 'warn');
+      }
       if (this._heartbeatFailStreak >= HEARTBEAT_ERROR_THRESHOLD) {
         this._reportStatus(reason, message);
       }
@@ -593,7 +607,7 @@ class BaseAdapter {
     }
     if (!channel) {
       try { await this._stopSharedWork(); } catch (e) {
-        this._log(`Stop: shared work did not stop cleanly: ${e && e.message ? e.message : e}`);
+        this._log(`Stop: shared work did not stop cleanly: ${e && e.message ? e.message : e}`, 'warn');
       }
     }
     for (const ch of channels) {
@@ -601,7 +615,7 @@ class BaseAdapter {
       try {
         outcome = await this._stopChannelWork(ch);
       } catch (e) {
-        this._log(`Stop: ${ch} did not stop cleanly: ${e && e.message ? e.message : e}`);
+        this._log(`Stop: ${ch} did not stop cleanly: ${e && e.message ? e.message : e}`, 'warn');
         outcome = 'failed';
       }
       // The pressed channel is always answered, so its UI settles even when
@@ -788,7 +802,7 @@ class BaseAdapter {
         skillId, state: 'installing',
       });
     } catch (e) {
-      this._log(`skill.install: could not report 'installing' (non-fatal): ${e && e.message ? e.message : e}`);
+      this._log(`skill.install: could not report 'installing' (non-fatal): ${e && e.message ? e.message : e}`, 'warn');
     }
 
     try {
@@ -822,19 +836,19 @@ class BaseAdapter {
           skillId, state: 'installed', path: result.path, partial: result.partial === true,
         });
       } catch (e) {
-        this._log(`skill.install: installed on disk but failed to report 'installed': ${e && e.message ? e.message : e}`);
+        this._log(`skill.install: installed on disk but failed to report 'installed': ${e && e.message ? e.message : e}`, 'warn');
       }
       this._log(`skill.install: SUCCESS "${skillId}" → ${result.path}${result.partial ? ' (partial)' : ''}`);
       await this._onSkillsChanged();
     } catch (e) {
       const msg = e && e.message ? e.message : String(e);
-      this._log(`skill.install: FAILED "${skillId}": ${msg}`);
+      this._log(`skill.install: FAILED "${skillId}": ${msg}`, 'error');
       try {
         await this.client.reportSkillStatus(this.workspaceId, this.agentName, this.token, {
           skillId, state: 'failed', error: msg,
         });
       } catch (e2) {
-        this._log(`skill.install: also failed to report 'failed': ${e2 && e2.message ? e2.message : e2}`);
+        this._log(`skill.install: also failed to report 'failed': ${e2 && e2.message ? e2.message : e2}`, 'warn');
       }
     }
   }
@@ -863,12 +877,12 @@ class BaseAdapter {
           skillId, state: 'uninstalled',
         });
       } catch (e) {
-        this._log(`skill.uninstall: failed to report status: ${e && e.message ? e.message : e}`);
+        this._log(`skill.uninstall: failed to report status: ${e && e.message ? e.message : e}`, 'warn');
       }
       await this._onSkillsChanged();
     } catch (e) {
       const msg = e && e.message ? e.message : String(e);
-      this._log(`skill.uninstall: FAILED "${skillId}": ${msg}`);
+      this._log(`skill.uninstall: FAILED "${skillId}": ${msg}`, 'error');
     }
   }
 
@@ -923,7 +937,7 @@ class BaseAdapter {
         sessionId: this._sessionId,
       });
     } catch (e) {
-      this._log(`Status: failed to post: ${e && e.message ? e.message : e}`);
+      this._log(`Status: failed to post: ${e && e.message ? e.message : e}`, 'warn');
     }
   }
 
@@ -950,7 +964,7 @@ class BaseAdapter {
         (r) => r.created_by === prefixed || r.created_by === this.agentName,
       );
     } catch (e) {
-      this._log(`Routines: failed to list: ${e && e.message ? e.message : e}`);
+      this._log(`Routines: failed to list: ${e && e.message ? e.message : e}`, 'warn');
       try {
         await this.client.sendMessage(
           this.workspaceId, channel, this.token,
@@ -991,7 +1005,7 @@ class BaseAdapter {
         sessionId: this._sessionId,
       });
     } catch (e) {
-      this._log(`Routines: failed to post: ${e && e.message ? e.message : e}`);
+      this._log(`Routines: failed to post: ${e && e.message ? e.message : e}`, 'warn');
     }
   }
 
@@ -1049,11 +1063,26 @@ class BaseAdapter {
         rawCursor = result.cursor;
         composingActive = !!result.composing;
         this._pollAuthFailStreak = 0;
+        const recovered = this._pollFailures.succeed();
+        if (recovered) {
+          this._log(`Poll recovered after ${recovered.count} unsuccessful attempt(s) over ${formatDuration(recovered.ms)}`);
+        }
         if (pollCount <= 3 || pollCount % 20 === 0) {
           this._log(`Poll #${pollCount}: ${messages.length} messages, cursor=${rawCursor || 'none'}${composingActive ? ' composing' : ''}`);
         }
       } catch (e) {
-        this._log(`Poll #${pollCount} failed: ${e.message} \nStack: ${e.stack}`);
+        // A workspace that is down or slow fails every poll until it is back;
+        // log the streak, not every attempt (see failure-streak.js).
+        if (this._pollFailures.fail()) {
+          const count = this._pollFailures.count;
+          const streak = count > 1 ? ` (consecutive failures: ${count})` : '';
+          if (isTransientNetworkError(e)) {
+            this._log(`Poll #${pollCount} failed: ${e.message}${streak} — retrying every 5s`, 'warn');
+          } else {
+            const stack = count === 1 && e && e.stack ? `\nStack: ${e.stack}` : '';
+            this._log(`Poll #${pollCount} failed: ${e && e.message}${streak}${stack}`, 'error');
+          }
+        }
         // A rejected credential never heals by retrying with the same token —
         // it means the device was re-paired/unpaired and this adapter is
         // running on a revoked one. After a few consecutive rejections (not
@@ -1249,7 +1278,7 @@ class BaseAdapter {
           await this._handleMessage(current);
         }
       } catch (e) {
-        this._log(`Error ${first ? 'in channel worker' : 'processing queued message'} for ${channel}: ${e.message}`);
+        this._log(`Error ${first ? 'in channel worker' : 'processing queued message'} for ${channel}: ${e.message}`, 'error');
         try { await this.sendError(channel, `Agent error: ${e.message}`); } catch {}
       }
       delete this._channelRunGeneration[channel];
@@ -1333,7 +1362,7 @@ class BaseAdapter {
           delete cache[channel];
           // Entry is gone — fall through to list+match below.
         } else {
-          this._log(`${label} read failed (${e.message}) — reusing last known state`);
+          this._log(`${label} read failed (${e.message}) — reusing last known state`, 'warn');
           return { available: true, state: 'found', entryId: cachedId, title: titles[0], content: null, error: true };
         }
       }
@@ -1369,7 +1398,7 @@ class BaseAdapter {
       }
       return { available: true, state: 'found', entryId: entry.id, title: matchedTitle, content: (full && full.content) || '', error: false };
     } catch (e) {
-      this._log(`${label} fetch failed (${e.message}) — reusing last known state`);
+      this._log(`${label} fetch failed (${e.message}) — reusing last known state`, 'warn');
       const knownId = cache[channel] || null;
       return { available: true, state: knownId ? 'found' : 'unknown', entryId: knownId, title: knownId ? titles[0] : null, content: null, error: true };
     }
@@ -1427,7 +1456,7 @@ class BaseAdapter {
       }
       this._pinnedContext[channel] = fresh;
     } catch (e) {
-      this._log(`Pinned-context fetch failed (${e && e.message ? e.message : e}) — reusing the last pinned context`);
+      this._log(`Pinned-context fetch failed (${e && e.message ? e.message : e}) — reusing the last pinned context`, 'warn');
     }
   }
 
@@ -1475,7 +1504,7 @@ class BaseAdapter {
         this._log(`Auto-titled channel: ${title}`);
       }
     } catch (e) {
-      this._log(`Failed to auto-title channel: ${e.message}`);
+      this._log(`Failed to auto-title channel: ${e.message}`, 'warn');
     }
   }
 
@@ -1625,7 +1654,7 @@ class BaseAdapter {
   }
 
   _onSessionRevoked() {
-    this._log(`SESSION REVOKED: another client joined as '${this.agentName}'. Stopping adapter.`);
+    this._log(`SESSION REVOKED: another client joined as '${this.agentName}'. Stopping adapter.`, 'warn');
     this._running = false;
   }
 

package/src/adapters/failure-streak.js

@@ -0,0 +1,89 @@
+'use strict';
+
+/**
+ * Logging policy for background calls that fail repeatedly — the message poll
+ * and the workspace heartbeat.
+ *
+ * Both retry forever, so an unreachable or slow workspace used to produce one
+ * entry per attempt: the poll wrote a full stack every ~20s (15s deadline + 5s
+ * back-off) at INFO, and the Logs page — inferring severity from "failed" plus
+ * the stack — showed a wall of red ERRORs for what was a network outage.
+ *
+ * A streak logs its 1st, 3rd, 10th, 30th and then every 100th failure, and one
+ * line when it ends. Network-level failures are expected in the field and are
+ * WARN without a stack; anything else is an ERROR, with its stack once.
+ *
+ * Pure and dependency-light, so it is unit-testable without an adapter.
+ */
+
+const { httpStatusOf } = require('./health-status');
+
+const TRANSIENT_CODES = new Set([
+  'ETIMEDOUT',
+  'ECONNRESET',
+  'ECONNREFUSED',
+  'ECONNABORTED',
+  'ENOTFOUND',
+  'EAI_AGAIN',
+  'ENETUNREACH',
+  'ENETDOWN',
+  'EHOSTUNREACH',
+  'EPIPE',
+  'UND_ERR_SOCKET',
+  'UND_ERR_CONNECT_TIMEOUT',
+]);
+
+/**
+ * True for failures of the network or of an overloaded server — the kind a
+ * retry is expected to fix, not a bug or a rejected credential.
+ */
+function isTransientNetworkError(err) {
+  if (!err) return false;
+  if (err.code && TRANSIENT_CODES.has(err.code)) return true;
+  if (err.name === 'AbortError' || err.name === 'TimeoutError') return true;
+  const status = httpStatusOf(err);
+  if (typeof status === 'number') return status === 429 || status >= 500;
+  return /\b(timed out|socket hang up|network)\b/i.test(err.message || '');
+}
+
+/** Which failure counts in a streak get a log line. */
+function isLogPoint(count) {
+  return count === 1 || count === 3 || count === 10 || count === 30 || count % 100 === 0;
+}
+
+class FailureStreak {
+  constructor() {
+    this.count = 0;
+    this.since = 0;
+  }
+
+  /** Record one failure. True when this one should be logged. */
+  fail(now = Date.now()) {
+    this.count++;
+    if (this.count === 1) this.since = now;
+    return isLogPoint(this.count);
+  }
+
+  /**
+   * Record a success. Returns the streak it ended — `{ count, ms }` — or null
+   * when there was none.
+   */
+  succeed(now = Date.now()) {
+    if (this.count === 0) return null;
+    const ended = { count: this.count, ms: now - this.since };
+    this.count = 0;
+    this.since = 0;
+    return ended;
+  }
+}
+
+/** "45s" / "12m" / "3h" — for the line that closes a streak. */
+function formatDuration(ms) {
+  const s = Math.max(0, Math.round(ms / 1000));
+  if (s < 120) return `${s}s`;
+  const m = Math.round(s / 60);
+  if (m < 120) return `${m}m`;
+  return `${Math.round(m / 60)}h`;
+}
+
+module.exports = { FailureStreak, isTransientNetworkError, isLogPoint, formatDuration };

package/src/config.js

@@ -269,9 +269,18 @@ class Config {
     const { keptLines, removed } = filterLogsByTimeRange(allLines, start, end);
 
     const nextContent = keptLines.join('\n') + (hasTrailingNewline && keptLines.length > 0 ? '\n' : '');
-    const tempFile = `${this.logFile}.tmp`;
-    fs.writeFileSync(tempFile, nextContent, 'utf-8');
-    fs.renameSync(tempFile, this.logFile);
+    // Rewrite in place, not write-temp + rename: the running daemon's stdout
+    // and stderr are append-mode handles to daemon.log. A rename leaves them
+    // writing into the replaced file (and fails outright on Windows while they
+    // are open); truncating in place keeps them appending to daemon.log.
+    const nextBytes = Buffer.from(nextContent, 'utf-8');
+    const fd = fs.openSync(this.logFile, 'r+');
+    try {
+      if (nextBytes.length > 0) fs.writeSync(fd, nextBytes, 0, nextBytes.length, 0);
+      fs.ftruncateSync(fd, nextBytes.length);
+    } finally {
+      fs.closeSync(fd);
+    }
 
     return { removed, remaining: keptLines.length };
   }

package/src/daemon.js

@@ -12,6 +12,7 @@ const { WorkspaceClient } = require('./workspace-client');
 const { listEndpointModels } = require('./model-list');
 const { AUTH_MODE_KEY, isCliLogin, stripForCliLogin, typeEnvFor } = require('./env');
 const { getEnhancedEnv, whichBinary, IS_WINDOWS, defaultAgentWorkdir } = require('./paths');
+const { LogWriter } = require('./log-writer');
 
 /**
  * Mask an API key for display (same shape the workspace backend uses for
@@ -247,7 +248,7 @@ class Daemon {
       this._log(`${name}: workspace credential for '${info.networkRef}' rotated (device re-paired) — restarting to pick up the new token`);
       this.restartAgent(name).catch((e) => {
         info._credRestartPending = false;
-        this._log(`${name}: credential-rotation restart failed: ${e.message}`);
+        this._log(`${name}: credential-rotation restart failed: ${e.message}`, 'warn');
       });
     }
   }
@@ -583,7 +584,7 @@ class Daemon {
     }
     for (const [key, value] of Object.entries(config)) {
       if (!allowed.has(key)) {
-        this._log(`config for '${type}': refused non-env_config key '${key}'`);
+        this._log(`config for '${type}': refused non-env_config key '${key}'`, 'warn');
         continue;
       }
       if (value === null || value === undefined) continue;
@@ -805,11 +806,11 @@ async _runNodeCommand(n, cmd) {
       this._crashGuardsInstalled = true;
       process.on('unhandledRejection', (reason) => {
         const msg = reason && reason.stack ? reason.stack : String(reason);
-        this._log(`UNHANDLED REJECTION (daemon kept alive): ${msg}`);
+        this._log(`UNHANDLED REJECTION (daemon kept alive): ${msg}`, 'error');
       });
       process.on('uncaughtException', (err) => {
         const msg = err && err.stack ? err.stack : String(err);
-        this._log(`UNCAUGHT EXCEPTION (daemon kept alive): ${msg}`);
+        this._log(`UNCAUGHT EXCEPTION (daemon kept alive): ${msg}`, 'error');
       });
     }
 
@@ -919,6 +920,7 @@ async _runNodeCommand(n, cmd) {
     this._writeStatus();
     this._cleanupPid();
     this._log('Daemon stopped');
+    if (this._logWriter) await this._logWriter.flush();
 
     if (this._shutdownResolve) this._shutdownResolve();
   }
@@ -947,7 +949,7 @@ async _runNodeCommand(n, cmd) {
     // a hung adapter.run() promise prevents the slot from ever being
     // released, and subsequent start/restart commands see "already running".
     if (this._adapters && this._adapters[agentName]) {
-      this._log(`WARNING: ${agentName} adapter did not exit after stop — force-releasing slot`);
+      this._log(`WARNING: ${agentName} adapter did not exit after stop — force-releasing slot`, 'warn');
       try { this._adapters[agentName].stop(); } catch {}
       delete this._adapters[agentName];
     }
@@ -1282,7 +1284,7 @@ async _runNodeCommand(n, cmd) {
         const exitCode = await new Promise((resolve) => {
           proc.on('exit', (code) => resolve(code));
           proc.on('error', (err) => {
-            this._log(`${name} spawn error: ${err.message}`);
+            this._log(`${name} spawn error: ${err.message}`, 'error');
             resolve(1);
           });
         });
@@ -1309,13 +1311,13 @@ async _runNodeCommand(n, cmd) {
         this._writeStatus();
 
         if (info.restarts >= 10) {
-          this._log(`${name} crashed ${info.restarts} times, giving up. Fix the issue and restart manually.`);
+          this._log(`${name} crashed ${info.restarts} times, giving up. Fix the issue and restart manually.`, 'error');
           info.state = 'stopped';
           this._writeStatus();
           break;
         }
 
-        this._log(`${name} crashed: ${info.lastError}, restarting in ${info._backoff}s (attempt ${info.restarts})`);
+        this._log(`${name} crashed: ${info.lastError}, restarting in ${info._backoff}s (attempt ${info.restarts})`, 'warn');
         await this._sleep(info._backoff * 1000);
         info._backoff = Math.min(info._backoff * 2, 60);
       }
@@ -1384,6 +1386,7 @@ async _runNodeCommand(n, cmd) {
         toolMode: agentCfg.tool_mode || 'skills',
         // Live runtime/connectivity status → daemon.status.json (Agents list/TUI).
         onStatus: (update) => this._applyAdapterStatus(name, info, update),
+        logSink: (level, msg) => this._logAs(`adapter [${name}]`, level, msg),
       });
     } catch (e) {
       // A construction failure (e.g. unknown agent type in this core) is a hard
@@ -1391,7 +1394,7 @@ async _runNodeCommand(n, cmd) {
       info.state = 'error';
       info.errorReason = 'adapter_crashed';
       info.lastError = redactDiagnostic(e.message || String(e));
-      this._log(`${name} failed to create ${agentType} adapter: ${info.lastError}`);
+      this._log(`${name} failed to create ${agentType} adapter: ${info.lastError}`, 'error');
       this._writeStatus();
       return;
     }
@@ -1408,11 +1411,11 @@ async _runNodeCommand(n, cmd) {
         info.errorReason = pf.reason || 'runtime_missing';
         info.lastError = redactDiagnostic(pf.message || 'runtime not available');
         this._writeStatus();
-        this._log(`${name} preflight failed (${info.errorReason}): ${info.lastError}`);
+        this._log(`${name} preflight failed (${info.errorReason}): ${info.lastError}`, 'warn');
         return;
       }
     } catch (e) {
-      this._log(`${name} preflight error (ignored, continuing): ${e.message}`);
+      this._log(`${name} preflight error (ignored, continuing): ${e.message}`, 'warn');
     }
 
     // Store adapter reference for stop and duplicate detection
@@ -1440,7 +1443,7 @@ async _runNodeCommand(n, cmd) {
     } catch (e) {
       info.errorReason = info.errorReason || 'adapter_crashed';
       info.lastError = redactDiagnostic((e.message || String(e)).slice(0, 200));
-      this._log(`${name} adapter error: ${info.lastError}`);
+      this._log(`${name} adapter error: ${info.lastError}`, 'error');
     }
 
     delete this._adapters[name];
@@ -1756,7 +1759,7 @@ async _runNodeCommand(n, cmd) {
     // The old adapter will exit on its next poll iteration since its
     // entry in _stoppedAgents triggers adapter.stop() via checkStop.
     if (this._adapters && this._adapters[name]) {
-      this._log(`WARNING: adapter '${name}' did not clear after 10s — force-releasing slot to avoid duplicate`);
+      this._log(`WARNING: adapter '${name}' did not clear after 10s — force-releasing slot to avoid duplicate`, 'warn');
       try { this._adapters[name].stop(); } catch {}
       delete this._adapters[name];
     }
@@ -1773,33 +1776,25 @@ async _runNodeCommand(n, cmd) {
     try { fs.unlinkSync(this.config.statusFile); } catch {}
   }
 
-  _log(msg) {
-    const ts = new Date().toISOString();
-    const line = `${ts} INFO daemon: ${msg}`;
-    try {
-      fs.appendFileSync(this.config.logFile, line + '\n', 'utf-8');
-      this._maybeRotateLog();
-    } catch {}
+  _log(msg, level = 'info') {
+    this._logAs('daemon', level, msg);
+  }
+
+  /**
+   * One entry in daemon.log. Adapters log through here too (see the `logSink`
+   * passed in _adapterLoop), so batching, repeat suppression and rotation cover
+   * their lines as well — they used to bypass all of it via console.log.
+   */
+  _logAs(scope, level, msg) {
+    if (!this._logWriter) this._logWriter = new LogWriter(this.config.logFile);
+    const written = this._logWriter.write(level, scope, msg);
     // Only log to console if stdout is a TTY (not redirected to log file)
     // to avoid duplicate lines when daemonized
-    if (!this._shuttingDown && process.stdout.isTTY) {
-      console.log(line);
+    if (written && !this._shuttingDown && process.stdout.isTTY) {
+      console.log(`${new Date().toISOString()} ${String(level).toUpperCase()} ${scope}: ${msg}`);
     }
   }
 
-  _maybeRotateLog() {
-    // Rotate at 10MB, keep 1 backup
-    const MAX_SIZE = 10 * 1024 * 1024;
-    try {
-      const stat = fs.statSync(this.config.logFile);
-      if (stat.size > MAX_SIZE) {
-        const backup = this.config.logFile + '.1';
-        try { fs.unlinkSync(backup); } catch {}
-        fs.renameSync(this.config.logFile, backup);
-      }
-    } catch {}
-  }
-
   _sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }

package/src/log-writer.js

@@ -0,0 +1,351 @@
+'use strict';
+
+/**
+ * The daemon's writer for daemon.log — one sink shared by the daemon and every
+ * adapter running inside it.
+ *
+ * The line format is unchanged (`<ISO time> <LEVEL> <scope>: <message>`, extra
+ * message lines following as continuation lines): Launchers already in the
+ * field parse this file, and they may run a newer core than they shipped with.
+ * What changes is how lines get there:
+ *
+ *  - Batched, asynchronous writes. The old writer did an appendFileSync — an
+ *    open/write/close on the event loop — plus a statSync for every line. Lines
+ *    now collect in memory and go out in one append per `flushMs`, or sooner
+ *    once `flushBytes` are waiting. The size check runs once per batch.
+ *
+ *  - Repeat suppression. A failure that repeats every few seconds used to fill
+ *    the file with identical entries and rotate out everything useful. Within
+ *    each `rateWindowMs`, lines with the same level, scope and message shape
+ *    (digits and ids masked) pass `rateBurst` times; the rest are counted and
+ *    reported in one line when the window ends. ERROR lines always pass.
+ *
+ *  - Copy-truncate rotation with gzip generations. The old rename-based
+ *    rotation moved the file out from under every process that inherited a
+ *    handle to it — the daemon's own stdout/stderr, and with them every
+ *    adapter line — so those kept writing into the renamed backup, which the
+ *    next rotation deleted while still open. Copying the file aside and then
+ *    truncating it keeps every holder writing to daemon.log (they all opened
+ *    it in append mode). The copy is gzipped into daemon.log.1.gz, and the
+ *    older generations shift up to `keep`.
+ *
+ * Writes are best-effort, as they always were: a log that cannot be written
+ * must never take the daemon down.
+ */
+
+const fs = require('fs');
+const zlib = require('zlib');
+const { pipeline } = require('stream');
+
+const LEVEL_TOKENS = { debug: 'DEBUG', info: 'INFO', warn: 'WARN', error: 'ERROR' };
+
+const DEFAULTS = {
+  flushMs: 250,
+  flushBytes: 64 * 1024,
+  // Backlog bound for a log that cannot keep up (a stalled disk). Past this the
+  // oldest waiting lines are dropped and the drop is reported in the log.
+  maxPendingBytes: 4 * 1024 * 1024,
+  maxBytes: 10 * 1024 * 1024,
+  keep: 5,
+  rateWindowMs: 60 * 1000,
+  rateBurst: 20,
+  // Distinct message shapes tracked per window. A shape seen after the table
+  // is full is let through rather than tracked.
+  maxRateKeys: 1024,
+};
+
+/** Every writer with lines that may still be in memory; flushed on exit. */
+const live = new Set();
+let exitHookInstalled = false;
+
+function installExitHook() {
+  if (exitHookInstalled) return;
+  exitHookInstalled = true;
+  process.once('exit', () => {
+    for (const w of live) w.flushSync();
+  });
+}
+
+function normalizeLevel(level) {
+  return Object.prototype.hasOwnProperty.call(LEVEL_TOKENS, level) ? level : 'info';
+}
+
+/**
+ * The shape of a message: its first line with ids and numbers masked, so
+ * `Poll #257 failed` and `Poll #258 failed` count as the same line.
+ */
+function messageShape(message) {
+  const first = String(message).split('\n', 1)[0];
+  return first
+    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<id>')
+    .replace(/\d+/g, '#')
+    .slice(0, 200);
+}
+
+class LogWriter {
+  /**
+   * @param {string} file - daemon.log
+   * @param {object} [opts] - overrides for DEFAULTS
+   */
+  constructor(file, opts = {}) {
+    this.file = file;
+    this.opts = { ...DEFAULTS, ...opts };
+
+    this._pending = [];
+    this._pendingBytes = 0;
+    this._timer = null;
+    this._writing = false;
+    this._rotating = false;
+    this._waiters = [];
+
+    this._rate = new Map();
+    this._windowStart = Date.now();
+    this._windowTimer = null;
+
+    this.stats = { written: 0, suppressed: 0, dropped: 0, writeErrors: 0, rotations: 0 };
+    this._droppedSinceNote = 0;
+
+    live.add(this);
+    installExitHook();
+  }
+
+  /** Queue one entry. Returns false when it was suppressed as a repeat. */
+  write(level, scope, message) {
+    const lvl = normalizeLevel(level);
+    const now = Date.now();
+    if (!this._admit(lvl, scope, message, now)) return false;
+    this._enqueue(lvl, scope, message, now);
+    return true;
+  }
+
+  /** Resolves once everything queued so far is on disk (or failed to be). */
+  flush() {
+    return new Promise((resolve) => {
+      this._rollWindow(Date.now());
+      if (!this._writing && this._pending.length === 0) return resolve();
+      this._waiters.push(resolve);
+      if (this._timer) { clearTimeout(this._timer); this._timer = null; }
+      this._flush();
+    });
+  }
+
+  /**
+   * Write whatever is still queued, synchronously. For process exit, where an
+   * asynchronous write would never complete.
+   */
+  flushSync() {
+    this._rollWindow(Date.now());
+    if (this._timer) { clearTimeout(this._timer); this._timer = null; }
+    const data = this._takePending();
+    if (!data) return;
+    try {
+      fs.appendFileSync(this.file, data, 'utf-8');
+      this.stats.written += data.length;
+    } catch {
+      this.stats.writeErrors++;
+    }
+  }
+
+  /** Flush synchronously and stop tracking this writer. */
+  close() {
+    this.flushSync();
+    if (this._windowTimer) { clearTimeout(this._windowTimer); this._windowTimer = null; }
+    live.delete(this);
+  }
+
+  // ------------------------------------------------------------------
+  // Repeat suppression
+  // ------------------------------------------------------------------
+
+  _admit(level, scope, message, now) {
+    if (level === 'error') return true;
+    if (now - this._windowStart >= this.opts.rateWindowMs) this._rollWindow(now);
+
+    const key = `${level}\u0000${scope}\u0000${messageShape(message)}`;
+    let slot = this._rate.get(key);
+    if (!slot) {
+      if (this._rate.size >= this.opts.maxRateKeys) return true;
+      slot = { level, scope, sample: String(message).split('\n', 1)[0], seen: 0, suppressed: 0 };
+      this._rate.set(key, slot);
+    }
+    slot.seen++;
+    if (slot.seen <= this.opts.rateBurst) return true;
+
+    slot.suppressed++;
+    this.stats.suppressed++;
+    // Report at the end of this window even if nothing else is ever logged.
+    if (!this._windowTimer) {
+      const wait = Math.max(0, this._windowStart + this.opts.rateWindowMs - now);
+      this._windowTimer = setTimeout(() => {
+        this._windowTimer = null;
+        this._rollWindow(Date.now());
+      }, wait);
+      if (this._windowTimer.unref) this._windowTimer.unref();
+    }
+    return false;
+  }
+
+  /** Close the current window: one summary line per suppressed shape. */
+  _rollWindow(now) {
+    const secs = Math.max(1, Math.round((now - this._windowStart) / 1000));
+    for (const slot of this._rate.values()) {
+      if (slot.suppressed > 0) {
+        this._enqueue(
+          slot.level,
+          slot.scope,
+          `Suppressed ${slot.suppressed} more like this in the last ${secs}s: ${slot.sample}`,
+          now,
+        );
+      }
+    }
+    this._rate.clear();
+    this._windowStart = now;
+    if (this._windowTimer) { clearTimeout(this._windowTimer); this._windowTimer = null; }
+  }
+
+  // ------------------------------------------------------------------
+  // Batching
+  // ------------------------------------------------------------------
+
+  _format(level, scope, message, now) {
+    return `${new Date(now).toISOString()} ${LEVEL_TOKENS[level]} ${scope}: ${message}\n`;
+  }
+
+  _enqueue(level, scope, message, now) {
+    const line = this._format(level, scope, message, now);
+    this._pending.push(line);
+    this._pendingBytes += line.length;
+
+    while (this._pendingBytes > this.opts.maxPendingBytes && this._pending.length > 1) {
+      this._pendingBytes -= this._pending.shift().length;
+      this.stats.dropped++;
+      this._droppedSinceNote++;
+    }
+
+    this._schedule(this._pendingBytes >= this.opts.flushBytes ? 0 : this.opts.flushMs);
+  }
+
+  _schedule(delay) {
+    // A write in progress picks up the backlog when it completes.
+    if (this._writing) return;
+    if (this._timer) {
+      if (delay > 0) return;
+      clearTimeout(this._timer);
+    }
+    this._timer = setTimeout(() => {
+      this._timer = null;
+      this._flush();
+    }, delay);
+    if (this._timer.unref) this._timer.unref();
+  }
+
+  _takePending() {
+    if (this._droppedSinceNote > 0) {
+      this._pending.unshift(this._format(
+        'warn', 'daemon',
+        `Log writer fell behind — dropped ${this._droppedSinceNote} line(s)`,
+        Date.now(),
+      ));
+      this._droppedSinceNote = 0;
+    }
+    if (this._pending.length === 0) return '';
+    const data = this._pending.join('');
+    this._pending = [];
+    this._pendingBytes = 0;
+    return data;
+  }
+
+  _flush() {
+    if (this._writing) return;
+    const data = this._takePending();
+    if (!data) return this._settle();
+
+    this._writing = true;
+    fs.appendFile(this.file, data, 'utf-8', (err) => {
+      if (err) this.stats.writeErrors++;
+      else this.stats.written += data.length;
+      this._maybeRotate(() => {
+        this._writing = false;
+        if (this._pending.length > 0) this._flush();
+        else this._settle();
+      });
+    });
+  }
+
+  _settle() {
+    if (this._writing || this._pending.length > 0) return;
+    const waiters = this._waiters;
+    this._waiters = [];
+    for (const resolve of waiters) resolve();
+  }
+
+  // ------------------------------------------------------------------
+  // Rotation
+  // ------------------------------------------------------------------
+
+  _gen(n) {
+    return `${this.file}.${n}.gz`;
+  }
+
+  _maybeRotate(done) {
+    if (this._rotating) return done();
+    fs.stat(this.file, (err, st) => {
+      if (err || st.size < this.opts.maxBytes) return done();
+      this._rotate(done);
+    });
+  }
+
+  /**
+   * Copy the full log aside, truncate it in place, then compress the copy in
+   * the background. `done` runs as soon as the truncate lands, so writing
+   * continues into the emptied file while the copy is compressed.
+   *
+   * A line another process appends between the copy and the truncate is lost.
+   * That window is the duration of one file copy, once per `maxBytes` of log.
+   */
+  _rotate(done) {
+    this._rotating = true;
+    const copy = `${this.file}.rotating`;
+    try {
+      fs.copyFileSync(this.file, copy);
+      fs.truncateSync(this.file, 0);
+    } catch {
+      try { fs.unlinkSync(copy); } catch { /* not created */ }
+      this._rotating = false;
+      return done();
+    }
+    this.stats.rotations++;
+    done();
+
+    this._shiftGenerations();
+    const target = this._gen(1);
+    const partial = `${target}.tmp`;
+    pipeline(
+      fs.createReadStream(copy),
+      zlib.createGzip(),
+      fs.createWriteStream(partial),
+      (err) => {
+        try { fs.unlinkSync(copy); } catch { /* already gone */ }
+        if (err) {
+          try { fs.unlinkSync(partial); } catch { /* not created */ }
+        } else {
+          try { fs.renameSync(partial, target); } catch { /* best effort */ }
+        }
+        this._rotating = false;
+      },
+    );
+  }
+
+  _shiftGenerations() {
+    const { keep } = this.opts;
+    try { fs.unlinkSync(this._gen(keep)); } catch { /* none yet */ }
+    for (let n = keep - 1; n >= 1; n--) {
+      try { fs.renameSync(this._gen(n), this._gen(n + 1)); } catch { /* none yet */ }
+    }
+    // The uncompressed backup the previous writer kept. It was always deleted
+    // at the next rotation; this is that rotation.
+    try { fs.unlinkSync(`${this.file}.1`); } catch { /* none */ }
+  }
+}
+
+module.exports = { LogWriter, messageShape, DEFAULTS };

package/src/workspace-client.js

@@ -5,6 +5,29 @@ const http = require('http');
 
 const DEFAULT_ENDPOINT = 'https://workspace-endpoint.openagents.org';
 
+/**
+ * The error a request deadline produces. Every request carries a hard
+ * AbortSignal.timeout deadline (see _get), and when it fires Node rejects with
+ * a bare "AbortError: The operation was aborted" — which reads like somebody
+ * cancelled the call and names no cause. The socket-inactivity timeout said
+ * "Request timed out". Both now say the same thing, with the deadline, and
+ * carry ETIMEDOUT so callers can tell a slow network from a bug.
+ */
+function requestTimeoutError(timeout) {
+  const after = timeout >= 1000 ? `${Math.round(timeout / 1000)}s` : `${timeout}ms`;
+  const err = new Error(`Request timed out after ${after}`);
+  err.code = 'ETIMEDOUT';
+  return err;
+}
+
+/** A request 'error' handler that reports a fired deadline as a timeout. */
+function rejectWithDeadline(reject, timeout) {
+  return (err) => {
+    const aborted = err && (err.name === 'AbortError' || err.code === 'ABORT_ERR');
+    reject(aborted ? requestTimeoutError(timeout) : err);
+  };
+}
+
 /**
  * Thrown when the workspace rejects a request because our session_id has
  * been revoked by a newer /v1/join as the same agent. Callers should
@@ -967,18 +990,25 @@ class WorkspaceClient {
           try {
             const parsed = JSON.parse(data);
             if (res.statusCode >= 400) {
-              reject(new Error(parsed.message || `HTTP ${res.statusCode}`));
+              const err = new Error(parsed.message || `HTTP ${res.statusCode}`);
+              // Lets the poll loop tell a rejected credential (401/403) and an
+              // overloaded server (5xx) apart from a bug.
+              err.status = res.statusCode;
+              reject(err);
             } else {
               resolve(parsed);
             }
           } catch {
-            reject(new Error(`Invalid response: ${data.slice(0, 200)}`));
+            // A proxy's HTML error page (502/504) lands here.
+            const err = new Error(`Invalid response: ${data.slice(0, 200)}`);
+            if (res.statusCode >= 400) err.status = res.statusCode;
+            reject(err);
           }
         });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.on('error', rejectWithDeadline(reject, timeout));
+      req.on('timeout', () => { req.destroy(); reject(requestTimeoutError(timeout)); });
       req.end();
     });
   }
@@ -1008,8 +1038,8 @@ class WorkspaceClient {
         });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.on('error', rejectWithDeadline(reject, timeout));
+      req.on('timeout', () => { req.destroy(); reject(requestTimeoutError(timeout)); });
       req.end();
     });
   }
@@ -1058,8 +1088,8 @@ class WorkspaceClient {
         });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.on('error', rejectWithDeadline(reject, timeout));
+      req.on('timeout', () => { req.destroy(); reject(requestTimeoutError(timeout)); });
       req.write(jsonBody);
       req.end();
     });
@@ -1101,8 +1131,8 @@ class WorkspaceClient {
         });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.on('error', rejectWithDeadline(reject, timeout));
+      req.on('timeout', () => { req.destroy(); reject(requestTimeoutError(timeout)); });
       req.write(jsonBody);
       req.end();
     });
@@ -1139,8 +1169,8 @@ class WorkspaceClient {
         });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.on('error', rejectWithDeadline(reject, timeout));
+      req.on('timeout', () => { req.destroy(); reject(requestTimeoutError(timeout)); });
       req.write(jsonBody);
       req.end();
     });
@@ -1175,8 +1205,8 @@ class WorkspaceClient {
         });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.on('error', rejectWithDeadline(reject, 15000));
+      req.on('timeout', () => { req.destroy(); reject(requestTimeoutError(15000)); });
       req.end();
     });
   }