neoagent 3.0.1-beta.2 → 3.0.1-beta.21

package/server/services/runtime/guest_image.js

@@ -0,0 +1,182 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+const { DATA_DIR } = require('../../../runtime/paths');
+const { stageGuestPayload, normalizeRuntimeProfile } = require('./guest_bootstrap');
+
+// Where build contexts are staged. One directory per profile.
+const BUILD_ROOT = path.join(DATA_DIR, 'runtime-vms', 'guest-image');
+// Slim official Node base — Playwright browsers + OS deps are added at build time
+// via `playwright install --with-deps`, so the image is self-contained and the
+// browser version always matches the pinned `playwright-chromium` dependency.
+const BASE_IMAGE = String(process.env.NEOAGENT_GUEST_BASE_IMAGE || 'node:20-bookworm-slim').trim();
+const IMAGE_REPO = 'neoagent-guest-agent';
+const BUILD_TIMEOUT_MS = Number(process.env.NEOAGENT_GUEST_IMAGE_BUILD_TIMEOUT_MS || 20 * 60 * 1000);
+
+// The build context is the staged guest payload (package.json + runtime/ + server/).
+// Dependencies and browsers are installed once, at image build time — never per
+// container start. Copy package.json first so the dependency layer stays cached
+// across source-only changes.
+function dockerfileFor(profile) {
+  if (normalizeRuntimeProfile(profile) === 'android') {
+    return [
+      `FROM ${BASE_IMAGE}`,
+      'ENV NODE_ENV=production',
+      'ENV NEOAGENT_GUEST_PROFILE=android',
+      'WORKDIR /opt/neoagent',
+      'COPY package.json ./',
+      'RUN npm install --omit=dev --no-audit --no-fund && npm cache clean --force',
+      'COPY runtime ./runtime',
+      'COPY server ./server',
+      // World-writable runtime dir so the agent works whether the container runs
+      // as root (macOS) or as the host uid:gid (Linux, for shared file ownership).
+      'RUN mkdir -p /opt/neoagent/.runtime && chmod -R 0777 /opt/neoagent/.runtime',
+      'CMD ["node", "server/guest_agent.js"]',
+      '',
+    ].join('\n');
+  }
+  return [
+    `FROM ${BASE_IMAGE}`,
+    'ENV NODE_ENV=production',
+    'ENV PLAYWRIGHT_BROWSERS_PATH=/ms-playwright',
+    'ENV NEOAGENT_GUEST_PROFILE=browser_cli',
+    'WORKDIR /opt/neoagent',
+    'COPY package.json ./',
+    // Install deps without running package postinstall scripts, then fetch the
+    // matching Chromium and its OS dependencies explicitly. This mirrors the
+    // proven QEMU guest bootstrap and keeps the browser revision deterministic.
+    'RUN npm install --omit=dev --ignore-scripts --no-audit --no-fund \\',
+    ' && npx playwright install --with-deps chromium \\',
+    ' && npm cache clean --force',
+    'COPY runtime ./runtime',
+    'COPY server ./server',
+    // World-writable runtime dir + browser cache so the agent works whether the
+    // container runs as root (macOS) or as the host uid:gid (Linux, for shared
+    // file ownership). Chromium needs PLAYWRIGHT_BROWSERS_PATH readable by all.
+    'RUN mkdir -p /opt/neoagent/.runtime && chmod -R 0777 /opt/neoagent/.runtime && chmod -R a+rX /ms-playwright',
+    'CMD ["node", "server/guest_agent.js"]',
+    '',
+  ].join('\n');
+}
+
+// Stable content hash over every staged file plus the Dockerfile, so the image
+// tag changes whenever the guest source, its dependencies, or the base image
+// change. A new tag forces a rebuild; an unchanged tag reuses the cached image.
+function hashBuildContext(contextDir, dockerfile) {
+  const hash = crypto.createHash('sha256');
+  hash.update(dockerfile);
+  const walk = (dir) => {
+    for (const name of fs.readdirSync(dir).sort()) {
+      const full = path.join(dir, name);
+      const stat = fs.statSync(full);
+      if (stat.isDirectory()) {
+        walk(full);
+      } else {
+        hash.update(path.relative(contextDir, full));
+        hash.update(fs.readFileSync(full));
+      }
+    }
+  };
+  walk(contextDir);
+  return hash.digest('hex').slice(0, 12);
+}
+
+function docker(args, opts = {}) {
+  return spawnSync('docker', args, {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: opts.timeout || 30000,
+    ...opts,
+  });
+}
+
+function dockerAvailable() {
+  const result = docker(['info'], { timeout: 5000 });
+  return !result.error && result.status === 0;
+}
+
+// Builds and caches the per-profile guest-agent Docker image. The image bakes in
+// the guest agent, its dependencies, and (for browser_cli) the Chromium browser,
+// so containers start the agent directly with no runtime installation step.
+class GuestImageBuilder {
+  #buildPromise = null;
+  #cachedTag = null;
+  #cachedBuiltAt = 0;
+
+  constructor(options = {}) {
+    this.profile = normalizeRuntimeProfile(options.runtimeProfile || 'browser_cli');
+    this.contextDir = path.join(BUILD_ROOT, this.profile);
+  }
+
+  // Stage the build context on disk and return its content-addressed image tag.
+  prepareContext() {
+    const dockerfile = dockerfileFor(this.profile);
+    stageGuestPayload(this.contextDir, this.profile);
+    fs.writeFileSync(path.join(this.contextDir, 'Dockerfile'), dockerfile);
+    fs.writeFileSync(path.join(this.contextDir, '.dockerignore'), 'node_modules\n');
+    const tag = `${IMAGE_REPO}:${this.profile}-${hashBuildContext(this.contextDir, dockerfile)}`;
+    this.#cachedTag = tag;
+    return tag;
+  }
+
+  imageExists(tag) {
+    const result = docker(['image', 'inspect', tag], { timeout: 10000 });
+    return !result.error && result.status === 0;
+  }
+
+  // Returns { dockerAvailable, imageBuilt, image } without triggering a build.
+  // Cheap enough to call from readiness polling (only stages the context once).
+  getState() {
+    if (!dockerAvailable()) {
+      return { dockerAvailable: false, imageBuilt: false, image: this.#cachedTag };
+    }
+    let tag = this.#cachedTag;
+    try {
+      if (!tag) tag = this.prepareContext();
+    } catch (err) {
+      console.warn(`[GuestImage:${this.profile}] Failed to stage build context: ${err.message}`);
+      return { dockerAvailable: true, imageBuilt: false, image: null };
+    }
+    return { dockerAvailable: true, imageBuilt: this.imageExists(tag), image: tag };
+  }
+
+  // Ensure the image exists, building it if necessary. Concurrent callers share
+  // the same in-flight build. Returns the resolved image tag.
+  async ensure() {
+    const tag = this.prepareContext();
+    if (this.imageExists(tag)) {
+      this.#cachedBuiltAt = Date.now();
+      return tag;
+    }
+    if (this.#buildPromise) return this.#buildPromise;
+    this.#buildPromise = this.#build(tag).finally(() => { this.#buildPromise = null; });
+    return this.#buildPromise;
+  }
+
+  async #build(tag) {
+    console.log(`[GuestImage:${this.profile}] Building guest image ${tag} (one-time; downloads browser + deps)…`);
+    const started = Date.now();
+    const result = docker(['build', '-t', tag, this.contextDir], {
+      timeout: BUILD_TIMEOUT_MS,
+      stdio: ['ignore', 'inherit', 'inherit'],
+    });
+    if (result.error) {
+      throw new Error(`Guest image build failed to start: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+      throw new Error(`Guest image build for ${tag} exited with status ${result.status}`);
+    }
+    this.#cachedBuiltAt = Date.now();
+    console.log(`[GuestImage:${this.profile}] Built ${tag} in ${Math.round((Date.now() - started) / 1000)}s`);
+    return tag;
+  }
+}
+
+module.exports = {
+  GuestImageBuilder,
+  dockerAvailable,
+  BASE_IMAGE,
+};

package/server/services/runtime/manager.js

@@ -19,7 +19,6 @@ class RuntimeManager {
 
     const browserVmManager = options.browserVmManager || new DockerVMManager({
       runtimeProfile: 'browser_cli',
-      image: 'mcr.microsoft.com/playwright:v1.44.0-focal',
       memoryMb: DEFAULT_VM_MEMORY_MB,
       cpus: DEFAULT_VM_CPUS,
     });

package/server/services/runtime/validation.js

@@ -11,14 +11,9 @@ function getRuntimeValidation(runtimeManager) {
 
   if (policy.profile === 'prod' || nodeEnvIsProd) {
     if (!browserVmReadiness) {
-      issues.push('prod profile requires a working local VM runtime for browser/CLI.');
-    } else if (!browserVmReadiness.ready) {
-      if (!browserVmReadiness.qemuAvailable) {
-        issues.push(`prod profile requires QEMU (${browserVmReadiness.qemuBinary}) to be installed for browser/CLI.`);
-      }
-      if (!browserVmReadiness.baseImageExists && !browserVmReadiness.downloadConfigured) {
-        issues.push('prod profile requires a VM base image or a downloadable base image URL for browser/CLI.');
-      }
+      issues.push('prod profile requires a working container runtime for browser/CLI.');
+    } else if (!browserVmReadiness.dockerAvailable) {
+      issues.push('prod profile requires Docker to be installed and running for the browser/CLI runtime.');
     }
   }
 

package/server/services/tasks/runtime.js

@@ -14,6 +14,7 @@ const { TriggerRegistry } = require('./trigger_registry');
 const scheduleAdapter = require('./adapters/schedule');
 const { normalizeJsonObject } = require('./utils');
 const { normalizeOutgoingMessageForPlatform } = require('../messaging/formatting_guides');
+const { isTransientError } = require('../ai/providerRetry');
 
 const MAX_AUTONOMOUS_RETRIES = 1;
 const MAX_RECURRING_TASK_START_DELAY_MS = 90 * 1000;
@@ -461,6 +462,8 @@ class TaskRuntime {
     const deliveryState = {
       messagingSent: false,
       noResponse: false,
+      proactiveMessageStaged: false,
+      stagedProactiveMessage: null,
       lastSentMessage: '',
       sentMessages: [],
     };
@@ -483,11 +486,12 @@ class TaskRuntime {
       normalizedConfig = this._ensureDefaultNotifyTarget(userId, agentId, taskConfig, taskId);
       const triggerSummary = this._summarizeTrigger(task.trigger_type, triggerConfig);
       let notifyHint = '';
+      const manualRun = executionMeta.manual === true;
 
       if (normalizedConfig.callTo) {
         notifyHint = `\n\nThis task is configured to notify the user by phone. Use the make_call tool to call "${normalizedConfig.callTo}" with an appropriate greeting based on your findings. The configured greeting hint is: "${normalizedConfig.callGreeting || 'Hello, this is your task reminder.'}"`;
       } else if (normalizedConfig.notifyPlatform && normalizedConfig.notifyTo) {
-        notifyHint = `\n\nIf your task result is worth notifying the user about, send it proactively via send_message to platform="${normalizedConfig.notifyPlatform}" to="${normalizedConfig.notifyTo}" and set purpose="final_result" for a concrete useful outcome or purpose="blocker" for a real issue the user should know about. If nothing important or actionable changed, call send_message with purpose="no_response" and content="[NO RESPONSE]".`;
+        notifyHint = `\n\nIf your task result is worth notifying the user about, send it proactively via send_message to platform="${normalizedConfig.notifyPlatform}" to="${normalizedConfig.notifyTo}" and set purpose="final_result" for a concrete useful outcome or purpose="blocker" for a real issue the user should know about. If nothing important or actionable changed, call send_message with purpose="no_response" and content="[NO RESPONSE]" exactly; never leave content blank for no_response. When a tool result already gives you summary fields or flags that answer the task, decide from that evidence instead of re-running nearby variants of the same lookup.${manualRun ? '' : ' For this automatic scheduled run, plain assistant text is internal only and is NOT delivered. You MUST end the run with exactly one explicit send_message decision (purpose="final_result", "blocker", or "no_response") — if you produce a real result, deliver it with send_message or it is lost.'}`;
       }
 
       const triggerPayloadText = executionMeta.triggerPayload
@@ -519,13 +523,14 @@ class TaskRuntime {
           taskId,
           deliveryState,
           allowMultipleProactiveMessages: normalizedConfig.allowMultipleMessages === true || normalizedConfig.allow_multiple_messages === true,
+          stageProactiveMessages: true,
           skipTaskAnalysis: true,
           skipDeliverableWorkflow: true,
           skipGlobalRecall: true,
           skipConversationHistory: true,
           skipConversationMaintenance: true,
           skipRunContextPersistence: true,
-          skipVerifier: true,
+          skipVerifier: false,
           stream: false,
           context: executionMeta.triggerPayload || {},
         };
@@ -541,6 +546,7 @@ class TaskRuntime {
             taskConfig: normalizedConfig,
             result,
             deliveryState,
+            allowPlainResultFallback: manualRun,
           });
           if (fallbackDelivery && result && typeof result === 'object') {
             result.taskDelivery = fallbackDelivery;
@@ -562,10 +568,19 @@ class TaskRuntime {
           this.io.to(`user:${userId}`).emit('tasks:task_complete', { taskId, result });
           return result;
         } catch (err) {
-          if (completedRunId) {
+          const transientExecutionError = isTransientError(err);
+          if (completedRunId && !transientExecutionError) {
             this.taskRepository.markAgentRunFailed(completedRunId, userId, err.message);
           }
           if (err?.code === 'TASK_DELIVERY_FAILED') throw err;
+          if (transientExecutionError) {
+            this.io.to(`user:${userId}`).emit('tasks:task_skipped', {
+              taskId,
+              reason: 'transient_rate_limit',
+              timestamp: new Date().toISOString(),
+            });
+            return { skipped: true, reason: 'transient_rate_limit', runId: completedRunId, error: err.message };
+          }
           if (attempt >= MAX_AUTONOMOUS_RETRIES) throw err;
           attempt += 1;
           completedRunId = null;
@@ -584,20 +599,28 @@ class TaskRuntime {
     } catch (err) {
       console.error(`[Tasks] Task ${taskId} error:`, err.message);
       if (err?.code !== 'TASK_DELIVERY_FAILED') {
-        await this._deliverTaskResultIfNeeded({
-          userId,
-          agentId,
-          taskId,
-          taskConfig: normalizedConfig,
-          result: {
-            content: `Background task "${taskName}" could not complete after retrying. Check the task run logs for details.`,
-          },
-          deliveryState,
-        });
+        const failureMessage = this._buildTaskFailureMessage(taskName, err);
+        // A null message means the failure is transient infrastructure (rate/quota
+        // limit) that is not user-actionable and would spam every run during the
+        // limit window — it is logged above, but not surfaced to the user.
+        if (failureMessage) {
+          await this._deliverTaskResultIfNeeded({
+            userId,
+            agentId,
+            taskId,
+            taskConfig: normalizedConfig,
+            result: {
+              content: failureMessage,
+            },
+            deliveryState,
+            allowPlainResultFallback: true,
+          });
+        }
       }
       this.io.to(`user:${userId}`).emit('tasks:task_skipped', {
         taskId,
         reason: 'execution_failed',
+        error: err.message,
         timestamp: new Date().toISOString(),
       });
       return { skipped: false, error: err.message, runId: completedRunId };
@@ -784,6 +807,29 @@ class TaskRuntime {
     return normalized;
   }
 
+  // Build the user-facing notice for a task that errored out after retries.
+  // Returns null when the failure should NOT be surfaced (transient infra limits).
+  _buildTaskFailureMessage(taskName, err) {
+    const raw = String(err?.message || '').trim();
+    const lower = raw.toLowerCase();
+    // Rate/quota limits are transient, self-healing, and not user-actionable. Every
+    // scheduled run during the window would hit the same error, so a per-run notice
+    // would just be spam. Log only (done by the caller), no user message.
+    if (
+      lower.includes('rate limit')
+      || lower.includes('rate_limit')
+      || lower.includes('quota')
+      || lower.includes('tokens in the last')
+      || /\b429\b/.test(lower)
+    ) {
+      return null;
+    }
+    // Genuine failure: tell the user the actual reason instead of "check the logs",
+    // which they cannot do. Collapse whitespace and cap length to keep it readable.
+    const reason = raw ? raw.replace(/\s+/g, ' ').slice(0, 200) : 'an unknown error';
+    return `Background task "${taskName}" could not complete: ${reason}`;
+  }
+
   async _deliverTaskResultIfNeeded({
     userId,
     agentId,
@@ -791,10 +837,42 @@ class TaskRuntime {
     taskConfig,
     result,
     deliveryState,
+    allowPlainResultFallback = true,
   }) {
     if (deliveryState?.messagingSent || deliveryState?.noResponse || taskConfig.callTo) return null;
     const targets = this._buildNotifyTargets(userId, agentId, taskConfig);
     if (!targets.length) return null;
+    const resultText = stringifyTaskResult(result).trim();
+    const resultLooksLikeError = Boolean(result?.error);
+    const stagedMessage = normalizeOutgoingMessageForPlatform(
+      deliveryState?.stagedProactiveMessage?.platform,
+      deliveryState?.stagedProactiveMessage?.content || '',
+      { stripNoResponseMarker: false },
+    );
+    const explicitStagedDelivery = deliveryState?.proactiveMessageStaged === true && Boolean(stagedMessage);
+    // A forced terminal wrap-up (read-only/blocked hard-stop) is the model's final
+    // answer produced WITHOUT the ability to call send_message itself. Gating it
+    // would silently drop a stuck scheduled task's result, so deliver it even on an
+    // automatic run. Ordinary mid-run plain text (model had send_message available
+    // and chose not to use it) is still gated below.
+    const forcedTerminal = deliveryState?.terminalWrapup === true && Boolean(resultText);
+    if (!allowPlainResultFallback && !resultLooksLikeError && !forcedTerminal && !explicitStagedDelivery) {
+      // Automatic run produced substantive text but never made an explicit
+      // send_message decision (a deliberate no_response would have short-circuited
+      // above). We suppress to avoid recurring-check spam, but surface it so a
+      // genuinely dropped notification is visible rather than silently lost.
+      if (resultText) {
+        console.warn(
+          `[Tasks] Task ${taskId} produced an undelivered result on an automatic run `
+          + `(no explicit send_message decision): ${resultText.slice(0, 140)}`
+        );
+      }
+      return {
+        sent: false,
+        skipped: true,
+        reason: 'explicit_delivery_required',
+      };
+    }
 
     const manager = this.app?.locals?.messagingManager || this.agentEngine?.messagingManager || null;
     if (!manager) {
@@ -805,10 +883,17 @@ class TaskRuntime {
     }
 
     let lastError = null;
-    for (const target of targets) {
+    const resolvedTargets = explicitStagedDelivery
+      ? [{
+        platform: deliveryState.stagedProactiveMessage.platform,
+        to: deliveryState.stagedProactiveMessage.to,
+        mediaPath: deliveryState.stagedProactiveMessage.mediaPath || null,
+      }]
+      : targets;
+    for (const target of resolvedTargets) {
       const message = normalizeOutgoingMessageForPlatform(
         target.platform,
-        stringifyTaskResult(result),
+        resultText || stagedMessage,
         { stripNoResponseMarker: false },
       );
       if (!message || message.toUpperCase() === '[NO RESPONSE]') return null;
@@ -824,10 +909,13 @@ class TaskRuntime {
       try {
         const sendResult = await manager.sendMessage(userId, target.platform, target.to, message, {
           agentId,
+          mediaPath: target.mediaPath || null,
           runId: result?.runId || null,
           persistConversation: true,
         });
         deliveryState.messagingSent = true;
+        deliveryState.proactiveMessageStaged = false;
+        deliveryState.stagedProactiveMessage = null;
         deliveryState.lastSentMessage = message;
         if (!Array.isArray(deliveryState.sentMessages)) {
           deliveryState.sentMessages = [];

package/server/services/tasks/schedule_utils.js

@@ -141,11 +141,11 @@ function parseCronExpression(expression) {
 }
 
 function matchesCron(date, schedule) {
-  const minute = date.getUTCMinutes();
-  const hour = date.getUTCHours();
-  const dayOfMonth = date.getUTCDate();
-  const month = date.getUTCMonth() + 1;
-  const dayOfWeek = date.getUTCDay();
+  const minute = date.getMinutes();
+  const hour = date.getHours();
+  const dayOfMonth = date.getDate();
+  const month = date.getMonth() + 1;
+  const dayOfWeek = date.getDay();
 
   if (!schedule.minute.values.has(minute)) return false;
   if (!schedule.hour.values.has(hour)) return false;

package/server/services/voice/runtimeManager.js

@@ -52,6 +52,9 @@ class VoiceRuntimeManager {
       agentId,
     );
     const resolvedSessionId = String(sessionId || randomUUID()).trim();
+    if (this.sessions.has(resolvedSessionId)) {
+      throw new Error('Voice session ID collision: a session with this ID already exists.');
+    }
     const adapter = this.#createAdapter(voiceSettings.liveProvider);
     await adapter.open();
 
@@ -153,9 +156,12 @@ class VoiceRuntimeManager {
     });
   }
 
-  async closeSession(sessionId, reason = 'closed') {
+  async closeSession(sessionId, reason = 'closed', userId = null) {
     const session = this.getSession(sessionId);
     if (!session) return;
+    if (userId != null && session.userId != null && String(session.userId) !== String(userId)) {
+      throw new Error('Voice session access denied.');
+    }
     if (reason === 'socket_disconnected') {
       await this.abortActiveRun(session.id, 'voice_disconnect');
     }
@@ -164,8 +170,8 @@ class VoiceRuntimeManager {
     await session.close(reason);
   }
 
-  async beginInput(sessionId, options = {}) {
-    const session = this.#requireSession(sessionId);
+  async beginInput(sessionId, options = {}, userId = null) {
+    const session = this.#requireSession(sessionId, userId);
     await session.interruptOutput();
     await this.abortActiveRun(session.id, 'voice_interrupt');
     session.resetTurnState();
@@ -176,13 +182,13 @@ class VoiceRuntimeManager {
     await session.setState('listening');
   }
 
-  async appendInputAudio(sessionId, audioBytes, options = {}) {
-    const session = this.#requireSession(sessionId);
+  async appendInputAudio(sessionId, audioBytes, options = {}, userId = null) {
+    const session = this.#requireSession(sessionId, userId);
     return session.adapter.appendAudioChunk(session, audioBytes, options);
   }
 
-  async commitInput(sessionId, options = {}) {
-    const session = this.#requireSession(sessionId);
+  async commitInput(sessionId, options = {}, userId = null) {
+    const session = this.#requireSession(sessionId, userId);
     if (session.inputBytes === 0) {
       return { transcript: '' };
     }
@@ -207,8 +213,8 @@ class VoiceRuntimeManager {
     };
   }
 
-  async interruptSession(sessionId) {
-    const session = this.#requireSession(sessionId);
+  async interruptSession(sessionId, userId = null) {
+    const session = this.#requireSession(sessionId, userId);
     await this.abortActiveRun(session.id, 'voice_interrupt');
     await session.interruptOutput();
     session.resetTurnState();
@@ -378,11 +384,14 @@ class VoiceRuntimeManager {
     return new OpenAiLiveRelayAdapter();
   }
 
-  #requireSession(sessionId) {
+  #requireSession(sessionId, userId = null) {
     const session = this.getSession(sessionId);
     if (!session) {
       throw new Error('Voice session was not found.');
     }
+    if (userId != null && session.userId != null && String(session.userId) !== String(userId)) {
+      throw new Error('Voice session access denied.');
+    }
     return session;
   }
 

package/server/services/wearable/gateway.js

@@ -27,11 +27,14 @@ function rejectUpgrade(socket, statusCode, message) {
 }
 
 function remoteAddressFromRequest(req) {
-  const forwarded = req.headers?.['x-forwarded-for'];
-  if (typeof forwarded === 'string' && forwarded.trim()) {
-    return forwarded.split(',')[0].trim();
+  const directPeer = req.socket?.remoteAddress || 'unknown';
+  if (process.env.TRUST_PROXY === 'true' || process.env.TRUST_PROXY === '1') {
+    const forwarded = req.headers?.['x-forwarded-for'];
+    if (typeof forwarded === 'string' && forwarded.trim()) {
+      return forwarded.split(',')[0].trim();
+    }
   }
-  return req.socket?.remoteAddress || 'unknown';
+  return directPeer;
 }
 
 function createUpgradeLimiter() {
@@ -142,7 +145,7 @@ function createWearableVoiceSink(ws, voiceRuntimeManager) {
 }
 
 function bindWearableGateway(httpServer, app, sessionMiddleware) {
-  const wss = new WebSocketServer({ noServer: true });
+  const wss = new WebSocketServer({ noServer: true, maxPayload: 1 * 1024 * 1024 });
   const allowUpgradeAttempt = createUpgradeLimiter();
 
   httpServer.on('upgrade', (req, socket, head) => {

package/server/services/websocket.js

@@ -15,6 +15,11 @@ const MAX_QUERY_CHARS = 2000;
 const DEFAULT_RATE_LIMIT_WINDOW_MS = 10 * 1000;
 const DEFAULT_RATE_LIMIT_MAX = 30;
 const RATE_LIMIT_OBSERVER_ENTRY_TTL_MS = 10 * 60 * 1000;
+// Shared rate-limit state keyed by userId so that multiple sockets from the
+// same authenticated user share a single budget rather than getting N × budget.
+const userRateLimitStates = new Map();
+const userSocketCounts = new Map();
+
 const EVENT_RATE_LIMITS = Object.freeze({
   'agent:run': { windowMs: 15 * 1000, max: 4 },
   'agent:abort': { windowMs: 10 * 1000, max: 20 },
@@ -74,8 +79,7 @@ function resolveAgentFromPayload(userId, value) {
   return resolveAgentId(userId, data?.agentId || data?.agent_id || null);
 }
 
-function createSocketRateLimiter() {
-  const state = new Map();
+function createSocketRateLimiter(state = new Map()) {
   return (eventName) => {
     const config = EVENT_RATE_LIMITS[eventName] || {
       windowMs: DEFAULT_RATE_LIMIT_WINDOW_MS,
@@ -184,7 +188,6 @@ function setupWebSocket(io, services) {
     services.app.locals.getWebsocketRateLimitSnapshot = () => rateLimitObserver.snapshot();
   }
   io.on('connection', (socket) => {
-    const allowEvent = createSocketRateLimiter();
     const session = socket.request.session;
     if (!session?.userId) {
       console.warn(`[WS] Rejecting unauthenticated socket ${socket.id}`);
@@ -195,6 +198,13 @@ function setupWebSocket(io, services) {
     const userId = session.userId;
     socket.join(`user:${userId}`);
 
+    // Share rate-limit budget across all sockets from the same authenticated user.
+    userSocketCounts.set(userId, (userSocketCounts.get(userId) || 0) + 1);
+    if (!userRateLimitStates.has(userId)) {
+      userRateLimitStates.set(userId, new Map());
+    }
+    const allowEvent = createSocketRateLimiter(userRateLimitStates.get(userId));
+
     console.log(`[WS] User ${userId} connected (${socket.id})`);
 
     // ── Agent Events ──
@@ -544,7 +554,7 @@ function setupWebSocket(io, services) {
         await voiceRuntimeManager.beginInput(sessionId, {
           mimeType: toOptionalString(data?.mimeType, 128),
           turnId: toOptionalString(data?.turnId, 128),
-        });
+        }, userId);
       } catch (err) {
         console.error(`[WS] voice:input_start failed for user ${userId}:`, err);
         socket.emit('voice:error', {
@@ -600,7 +610,7 @@ function setupWebSocket(io, services) {
           mimeType: toOptionalString(data?.mimeType, 128),
           turnId,
           sequence,
-        });
+        }, userId);
         socket.emit('voice:chunk_ack', {
           sessionId,
           turnId,
@@ -672,7 +682,7 @@ function setupWebSocket(io, services) {
           finalSequence: toBoundedInt(data?.finalSequence, -1, -1, 1_000_000),
           promptHint: toOptionalString(data?.promptHint, 2000),
           metadata,
-        });
+        }, userId);
       } catch (err) {
         console.error(`[WS] voice:input_commit failed for user ${userId}:`, err);
         socket.emit('voice:error', {
@@ -696,7 +706,7 @@ function setupWebSocket(io, services) {
         if (!sessionId) {
           return socket.emit('voice:error', { error: 'sessionId is required' });
         }
-        await voiceRuntimeManager.interruptSession(sessionId);
+        await voiceRuntimeManager.interruptSession(sessionId, userId);
       } catch (err) {
         console.error(`[WS] voice:interrupt failed for user ${userId}:`, err);
         socket.emit('voice:error', {
@@ -720,7 +730,7 @@ function setupWebSocket(io, services) {
         if (!sessionId) {
           return socket.emit('voice:error', { error: 'sessionId is required' });
         }
-        await voiceRuntimeManager.closeSession(sessionId, 'client_closed');
+        await voiceRuntimeManager.closeSession(sessionId, 'client_closed', userId);
         socket.data.voiceSessionIds?.delete(sessionId);
       } catch (err) {
         console.error(`[WS] voice:session_close failed for user ${userId}:`, err);
@@ -911,6 +921,14 @@ function setupWebSocket(io, services) {
     // ── Disconnect ──
 
     socket.on('disconnect', () => {
+      const remaining = (userSocketCounts.get(userId) || 1) - 1;
+      if (remaining <= 0) {
+        userSocketCounts.delete(userId);
+        userRateLimitStates.delete(userId);
+      } else {
+        userSocketCounts.set(userId, remaining);
+      }
+
       const streamHub = services.streamHub || services.app?.locals?.streamHub;
       if (streamHub && typeof streamHub.unsubscribeAll === 'function') {
         void streamHub.unsubscribeAll(socket.id).catch((err) => {