npm - @aiworker/web - Versions diffs - 1.23.0 → 1.23.1 - Mend

@aiworker/web 1.23.0 → 1.23.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (152) hide show

package/dist/index.html CHANGED Viewed

@@ -509,16 +509,16 @@
         pointer-events: none;
       }
     </style>
-    <script type="module" crossorigin src="/assets/main-CzdPuL0s.js"></script>
+    <script type="module" crossorigin src="/assets/main-D3ZDQglc.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-vite-runtime-DD1OZmLC.js">
+    <link rel="modulepreload" crossorigin href="/assets/vendor-zod-B6551dwG.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-scheduler-7OC5HNn7.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-BUCujlKS.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-zustand-BAGL70zf.js">
-    <link rel="modulepreload" crossorigin href="/assets/vendor-zod-BPAANqvH.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-opencode-sdk-BJ73u-bH.js">
-    <link rel="modulepreload" crossorigin href="/assets/index-DVwMarHI.js">
+    <link rel="modulepreload" crossorigin href="/assets/index-BD8ILbxF.js">
     <link rel="modulepreload" crossorigin href="/assets/contextPanelEmbeddedChat-BdA6bdky.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-B68h5S5B.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-zhgg-SDz.css">
   </head>
   <body class="h-full bg-background text-foreground">
     <div id="root" class="h-full">

package/dist/mini-chat.html CHANGED Viewed

@@ -74,15 +74,15 @@
       }
     </style>
-    <script type="module" crossorigin src="/assets/miniChat-CCkqKOLp.js"></script>
+    <script type="module" crossorigin src="/assets/miniChat-d01k801U.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-vite-runtime-DD1OZmLC.js">
+    <link rel="modulepreload" crossorigin href="/assets/vendor-zod-B6551dwG.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-scheduler-7OC5HNn7.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-BUCujlKS.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-zustand-BAGL70zf.js">
-    <link rel="modulepreload" crossorigin href="/assets/vendor-zod-BPAANqvH.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-opencode-sdk-BJ73u-bH.js">
-    <link rel="modulepreload" crossorigin href="/assets/index-DVwMarHI.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-B68h5S5B.css">
+    <link rel="modulepreload" crossorigin href="/assets/index-BD8ILbxF.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-zhgg-SDz.css">
   </head>
   <body class="h-full bg-background text-foreground">
     <div id="root" class="h-full">

package/dist/mobile.html CHANGED Viewed

@@ -63,15 +63,15 @@
       })();
     </script>
-    <script type="module" crossorigin src="/assets/mobile-mvxTo055.js"></script>
+    <script type="module" crossorigin src="/assets/mobile-D7VV-Ufz.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-vite-runtime-DD1OZmLC.js">
+    <link rel="modulepreload" crossorigin href="/assets/vendor-zod-B6551dwG.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-scheduler-7OC5HNn7.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-BUCujlKS.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-zustand-BAGL70zf.js">
-    <link rel="modulepreload" crossorigin href="/assets/vendor-zod-BPAANqvH.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-opencode-sdk-BJ73u-bH.js">
-    <link rel="modulepreload" crossorigin href="/assets/index-DVwMarHI.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-B68h5S5B.css">
+    <link rel="modulepreload" crossorigin href="/assets/index-BD8ILbxF.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-zhgg-SDz.css">
   </head>
   <body class="h-full bg-background text-foreground">
     <div id="root" class="h-full"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@aiworker/web",
-  "version": "1.23.0",
+  "version": "1.23.1",
   "private": false,
   "type": "module",
   "main": "./server/index.js",

package/server/index.js CHANGED Viewed

@@ -112,7 +112,6 @@ import { createDevServerScanner } from './lib/dev-servers/routes.js';
 import { createDevTunnelRuntime } from './lib/dev-tunnel/runtime.js';
 import { registerBrowserControlRoutes } from './lib/browser-control/routes.js';
 import { createSystemPromptRuntime } from './lib/system-prompt/runtime.js';
-import { createMcpReconnectRuntime } from './lib/mcp-reconnect/runtime.js';
 import { createAiWorkerSessionService } from './lib/openchamber-sessions/routes.js';
 import { createScheduledTaskService } from './lib/scheduled-tasks/service.js';
 import { createAiWorkerControlService } from './lib/openchamber-control/service.js';
@@ -302,7 +301,6 @@ const readCustomThemesFromDisk = (...args) => themeRuntime.readCustomThemesFromD
 let notificationTemplateRuntime = null;
 let agentToolRuntime = null;
 let systemPromptRuntime = null;
-let mcpReconnectRuntime = null;
 const createTimeoutSignal = (...args) => notificationTemplateRuntime.createTimeoutSignal(...args);
 const formatProjectLabel = (...args) => notificationTemplateRuntime.formatProjectLabel(...args);
@@ -1256,14 +1254,11 @@ const openCodeLifecycleRuntime = createOpenCodeLifecycleRuntime({
       ? await (agentToolRuntime?.prepareManagedOpenCodeEnv({ includeControl, includeWeb, includeMemory }) || {})
       : {};
-    // Each managed plugin appends itself to the config the previous one produced.
-    let configContent = managedEnv.OPENCODE_CONFIG_CONTENT ?? process.env.OPENCODE_CONFIG_CONTENT;
     if (settings?.optimizeSystemPrompt === true) {
-      ({ OPENCODE_CONFIG_CONTENT: configContent } = await systemPromptRuntime.prepareManagedOpenCodeEnv(configContent));
+      const configContent = managedEnv.OPENCODE_CONFIG_CONTENT ?? process.env.OPENCODE_CONFIG_CONTENT;
+      Object.assign(managedEnv, await systemPromptRuntime.prepareManagedOpenCodeEnv(configContent));
     }
-    // Always on for managed OpenCode: it only retries servers OpenCode gave up on.
-    const mcpReconnectEnv = await mcpReconnectRuntime.prepareManagedOpenCodeEnv(configContent);
-    return { ...managedEnv, ...mcpReconnectEnv };
+    return managedEnv;
   },
 });
@@ -1537,11 +1532,6 @@ async function main(options = {}) {
     path,
     dataDir: AIWORKER_DATA_DIR,
   });
-  mcpReconnectRuntime = createMcpReconnectRuntime({
-    fsPromises,
-    path,
-    dataDir: AIWORKER_DATA_DIR,
-  });
   // Pairing transports advertised to the create-device dialog. LAN reachability is
   // derived from the SERVER's actual bind (a wildcard bind → the machine's LAN IP;

package/server/lib/agent-memory/runtime.js CHANGED Viewed

@@ -4,7 +4,10 @@
  * What the agent has learned and chose to keep, in two scopes:
  *
  * - **project** — `<projectsDir>/<projectId>/memory.json`. How this codebase
- *   works, what was decided, where things live.
+ *   works, what was decided, where things live. `<projectId>` is the bounded
+ *   stem `projectConfigFileStemOf` gives the id (the id itself up to 200
+ *   characters, `path_sha256_<digest>` beyond), the same folder that holds
+ *   `project-context`'s `context.json` and sits beside the config file.
  * - **global** — `<userConfigRoot>/memory.json`. Who the user is and how they
  *   want to be worked with. It belongs to no project, so it cannot live under
  *   one.
@@ -51,6 +54,7 @@ const PROJECT_MEMORY_MAX_ITEMS = 200;
  */
 const MEMORY_TYPES = new Set(['fact', 'preference', 'reference']);
+import { projectConfigFileStemOf } from '../projects/project-id.js';
 import { findThreatPattern } from './threat-patterns.js';
 const PROJECT_ID_PATTERN = /^[a-zA-Z0-9._:-]+$/;
@@ -211,7 +215,8 @@ export const createAgentMemoryRuntime = (deps) => {
       return {
         scope: 'project',
         key: `project:${projectId}`,
-        filePath: path.join(projectsDirPath, projectId, 'memory.json'),
+        // Same bounded folder name as `project-context` and the config file.
+        filePath: path.join(projectsDirPath, projectConfigFileStemOf(projectId), 'memory.json'),
       };
     }
     throw new Error('scope is required');

package/server/lib/agent-memory/runtime.test.js CHANGED Viewed

@@ -3,6 +3,7 @@ import fsPromises from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { createProjectIdFromPath, projectConfigFileStemOf } from '../projects/project-id.js';
 import { createAgentMemoryRuntime } from './runtime.js';
 const PROJECT_ID = 'path_dGVzdA';
@@ -48,6 +49,27 @@ describe('scope resolution', () => {
     await fsPromises.access(projectPath());
   });
+  test('a project id too long for a folder name is stored under the bounded stem', async () => {
+    // A checkout nested deep enough that its `path_<base64url>` id is longer
+    // than a folder name may be; the store lands under the bounded stem the
+    // config file and project context use, instead of failing with ENAMETOOLONG.
+    const longProjectId = createProjectIdFromPath(`/private/tmp/claude-501/${'segment-'.repeat(18)}/scratchpad/evidence/demo-repo`);
+    const stem = projectConfigFileStemOf(longProjectId);
+    expect(longProjectId.length).toBeGreaterThan(240);
+    expect(stem.startsWith('path_sha256_')).toBe(true);
+    const target = { scope: 'project', projectId: longProjectId };
+    expect((await runtime.read(target)).entries).toEqual([]);
+    await runtime.create(target, { title: 'Uses bun', body: 'Tests run with bun test.' });
+    expect((await runtime.read(target)).entries.map((e) => e.title)).toEqual(['Uses bun']);
+    expect((await runtime.readAll(longProjectId)).project.map((e) => e.title)).toEqual(['Uses bun']);
+    await fsPromises.access(path.join(rootDir, 'config', 'projects', stem, 'memory.json'));
+    expect(await fsPromises.readdir(path.join(rootDir, 'config', 'projects'))).toEqual([stem]);
+    // A short id keeps naming its folder itself.
+    expect(runtime.resolveTarget(PROJECT).filePath).toBe(projectPath());
+  });
   test('rejects an unknown scope', async () => {
     await expect(runtime.read({ scope: 'nope' })).rejects.toThrow('scope is required');
   });

package/server/lib/event-stream/DOCUMENTATION.md CHANGED Viewed

@@ -24,6 +24,7 @@ This module contains the AiWorker message-stream WebSocket protocol and runtime
 - `parseSseEventEnvelope(block)`: parses an SSE block into `{ eventId, directory, payload }`.
 - `sendMessageStreamWsFrame(socket, payload)`: serializes and sends a JSON WS frame.
 - `sendMessageStreamWsEvent(socket, payload, options)`: sends an event frame with optional `eventId` and `directory`.
+- `serializeMessageStreamWsEvent(payload, options)` and `sendSerializedMessageStreamWsFrame(socket, frame)` separate encoding from per-socket delivery. Delivery retains ready-state and backpressure checks.
 ### Runtime helpers
 - `createGlobalMessageStreamHub(...)`: creates a shared `/global/event` upstream SSE hub with event/status subscribers and bounded event-id replay.
@@ -40,12 +41,14 @@ This module contains the AiWorker message-stream WebSocket protocol and runtime
 - AiWorker still fetches OpenCode upstream event streams over SSE.
 - The web server creates one shared global message-stream hub. OpenCode watcher side effects and global WS clients subscribe to that hub, so there is one upstream `/global/event` SSE reader for both server-side processing and browser fan-out.
 - The global hub keeps a bounded replay buffer keyed by SSE `eventId` so reconnecting browser clients can receive buffered events after their requested `Last-Event-ID`.
+- Replay retains at most 2,048 events and 8 MiB of UTF-8 wire frames. It stores encoded frames rather than retaining parsed payloads as well. Encoding is shared with live WS fanout. An oversized event still reaches live clients in full, but clears the retained suffix so replay cannot cross its gap. A missing replay cursor returns `null`, distinct from a complete empty tail; the bridge sends `ready` with `replayReset: true` and no partial replay. The client retires its cursor and requests authoritative repair, including during the early-boot reconnect grace period. A stopped hub retains its bounded suffix for clients reconnecting after the last socket closed.
 - Directory WS clients still attach one upstream `/event?directory=...` SSE reader per connection because directory streams are scoped.
 - If an upstream SSE stream stalls after the browser WS is already ready, the reader aborts that upstream fetch and reconnects upstream with `Last-Event-ID`, keeping the browser WS alive when recovery is fast.
 - When the shared global upstream reconnects after it was previously ready, the global WS bridge sends a fresh `ready` frame to already-ready browser clients. The browser treats this as a reconnect edge and can run scoped state repair without requiring the browser WS to close.
 - Health checks are reserved for initial upstream connect failures and explicit upstream-unavailable responses, not for ordinary stall recovery on an already-established stream.
 - Global synthetic events such as `aiworker:session-status`, `aiworker:session-activity`, `aiworker:notification`, and `aiworker:heartbeat` are preserved on the WS path, but heartbeat frames are emitted only while an upstream SSE stream is actively attached.
 - Global UI broadcasts are fan-out capable across both SSE and WS clients.
+- Global UI broadcasts serialize once per wire format, irrespective of client count. The SSE writer accepts an optional pre-serialized payload; isolated callers keep the two-argument contract. Failed or backpressured clients cannot block delivery to healthy clients.
 - The reusable upstream reader centralizes SSE fetch/parsing/reconnect behavior for the WS runtime and OpenCode watcher. Additional event consumers should move to it only with parity tests for their lifecycle and error semantics.
 - Browser transport concerns live in the WS bridge modules; server-side global stream ownership lives in `global-hub.js`.

package/server/lib/event-stream/global-hub.js CHANGED Viewed

@@ -1,8 +1,10 @@
 import { createUpstreamSseReader } from './upstream-reader.js';
+import { serializeMessageStreamWsEvent } from './protocol.js';
 // Raised from 512 → 2048 to improve recovery after brief disconnects during
 // long-running agent sessions where many events accumulate quickly.
 const MESSAGE_STREAM_GLOBAL_REPLAY_LIMIT = 2048;
+const MESSAGE_STREAM_GLOBAL_REPLAY_BYTES = 8 * 1024 * 1024;
 export function createGlobalMessageStreamHub({
   buildOpenCodeUrl,
@@ -11,10 +13,16 @@ export function createGlobalMessageStreamHub({
   upstreamStallTimeoutMs,
   upstreamReconnectDelayMs,
   replayLimit = MESSAGE_STREAM_GLOBAL_REPLAY_LIMIT,
+  replayByteLimit = MESSAGE_STREAM_GLOBAL_REPLAY_BYTES,
 }) {
+  if (!Number.isSafeInteger(replayLimit) || replayLimit < 0 || !Number.isSafeInteger(replayByteLimit) || replayByteLimit < 0) {
+    throw new RangeError('Replay limits must be nonnegative safe integers');
+  }
   const eventSubscribers = new Set();
   const statusSubscribers = new Set();
   const replay = [];
+  let replayBytes = 0;
+  let latestEventId;
   let controller = null;
   let reader = null;
@@ -45,11 +53,16 @@ export function createGlobalMessageStreamHub({
     const directory =
       typeof envelope?.directory === 'string' && envelope.directory.length > 0 ? envelope.directory : 'global';
     const eventId = typeof envelope?.eventId === 'string' && envelope.eventId.length > 0 ? envelope.eventId : undefined;
+    let serializedFrame;
     return {
       envelope,
       payload,
       directory,
       eventId,
+      serialize() {
+        serializedFrame ??= serializeMessageStreamWsEvent(payload, { directory, eventId });
+        return serializedFrame;
+      },
     };
   };
@@ -87,9 +100,20 @@ export function createGlobalMessageStreamHub({
       onEvent(event) {
         const normalized = normalizeEvent(event);
         if (normalized.eventId) {
-          replay.push(normalized);
-          if (replay.length > replayLimit) {
-            replay.splice(0, replay.length - replayLimit);
+          latestEventId = normalized.eventId;
+          const serializedFrame = normalized.serialize();
+          const bytes = Buffer.byteLength(serializedFrame);
+          if (bytes > replayByteLimit) {
+            // An oversized live event creates a hole: retain only a contiguous
+            // suffix after it, never replay an older prefix across the gap.
+            replay.length = 0;
+            replayBytes = 0;
+          } else {
+            replay.push({ eventId: normalized.eventId, serializedFrame, bytes });
+            replayBytes += bytes;
+            while (replay.length > replayLimit || replayBytes > replayByteLimit) {
+              replayBytes -= replay.shift().bytes;
+            }
           }
         }
@@ -152,7 +176,8 @@ export function createGlobalMessageStreamHub({
       }
       const index = replay.findIndex((entry) => entry.eventId === eventId);
-      return index === -1 ? [] : replay.slice(index + 1);
+      if (eventId === latestEventId) return [];
+      return index === -1 ? null : replay.slice(index + 1);
     },
   };
 }

package/server/lib/event-stream/global-hub.test.js CHANGED Viewed

@@ -2,6 +2,28 @@ import { describe, expect, it, vi } from 'vitest';
 import { createGlobalMessageStreamHub } from './global-hub.js';
+it('bounds a contiguous replay suffix by UTF-8 bytes and event count', async () => {
+  const blocks = Array.from({ length: 8 }, (_, i) => `id: e${i}\ndata: ${JSON.stringify({ type: 'message', properties: { text: '界'.repeat(40) } })}\n\n`);
+  const received = [];
+  const hub = createGlobalMessageStreamHub({
+    buildOpenCodeUrl: path => `http://127.0.0.1:4096${path}`,
+    getOpenCodeAuthHeaders: () => ({}), replayLimit: 3, replayByteLimit: 550,
+    upstreamReconnectDelayMs: 60_000,
+    fetchImpl: async () => createSseResponse({ blocks }),
+  });
+  hub.subscribeEvent(event => received.push(event.eventId));
+  try {
+    hub.start();
+    await waitForAssertion(() => expect(received).toHaveLength(8));
+    expect(hub.replayAfter('e0')).toBeNull();
+    expect(hub.replayAfter('e5')).toBeNull();
+    const tail = hub.replayAfter('e6');
+    expect(tail.map(entry => entry.eventId)).toEqual(['e7']);
+    expect(Buffer.byteLength(tail[0].serializedFrame) * 2).toBeLessThanOrEqual(550);
+    expect(Buffer.byteLength(tail[0].serializedFrame) * 3).toBeGreaterThan(550);
+  } finally { hub.stop(); }
+});
 function createSseResponse({ blocks = [] } = {}) {
   const encoder = new TextEncoder();
   let index = 0;

package/server/lib/event-stream/global-ws-bridge.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { sendMessageStreamWsEvent, sendMessageStreamWsFrame } from './protocol.js';
+import { sendMessageStreamWsEvent, sendMessageStreamWsFrame, sendSerializedMessageStreamWsFrame, serializeMessageStreamWsEvent } from './protocol.js';
 function shouldTriggerUpstreamHealthCheck(upstream) {
   if (!upstream) {
@@ -31,12 +31,9 @@ export function createGlobalMessageStreamWsBridge({
     wsClients.delete(socket);
   };
-  const replayEvents = (socket, requestedLastEventId) => {
-    for (const entry of globalHub.replayAfter(requestedLastEventId)) {
-      const sent = sendMessageStreamWsEvent(socket, entry.payload, {
-        directory: entry.directory,
-        eventId: entry.eventId,
-      });
+  const replayEvents = (socket, entries) => {
+    for (const entry of entries) {
+      const sent = sendSerializedMessageStreamWsFrame(socket, entry.serializedFrame);
       if (!sent) {
         removeClient(socket);
         return;
@@ -49,10 +46,10 @@ export function createGlobalMessageStreamWsBridge({
       return;
     }
-    const sent = sendMessageStreamWsFrame(socket, {
-      type: 'ready',
-      scope: 'global',
-    });
+    const replay = globalHub.replayAfter(requestedLastEventId);
+    const ready = { type: 'ready', scope: 'global' };
+    if (replay === null) ready.replayReset = true;
+    const sent = sendMessageStreamWsFrame(socket, ready);
     if (!sent) {
       removeClient(socket);
       return;
@@ -60,7 +57,7 @@ export function createGlobalMessageStreamWsBridge({
     readyClients.add(socket);
     wsClients.add(socket);
-    replayEvents(socket, requestedLastEventId);
+    if (replay !== null) replayEvents(socket, replay);
   };
   const stopHubIfUnused = () => {
@@ -88,26 +85,26 @@ export function createGlobalMessageStreamWsBridge({
     }
   };
-  const unsubscribeEvent = globalHub.subscribeEvent(({ payload, directory, eventId }) => {
+  const unsubscribeEvent = globalHub.subscribeEvent((event) => {
+    const { payload } = event;
     for (const socket of Array.from(clients)) {
       if (!readyClients.has(socket)) {
         continue;
       }
-      const sent = sendMessageStreamWsEvent(socket, payload, {
-        directory,
-        eventId,
-      });
+      const sent = sendSerializedMessageStreamWsFrame(socket, event.serialize());
       if (!sent) {
         removeClient(socket);
       }
     }
     processForwardedEventPayload(payload, (syntheticPayload) => {
+      if (readyClients.size === 0) return;
+      const serializedFrame = serializeMessageStreamWsEvent(syntheticPayload, { directory: 'global' });
       for (const socket of Array.from(clients)) {
         if (!readyClients.has(socket)) {
           continue;
         }
-        const sent = sendMessageStreamWsEvent(socket, syntheticPayload, { directory: 'global' });
+        const sent = sendSerializedMessageStreamWsFrame(socket, serializedFrame);
         if (!sent) {
           removeClient(socket);
         }

package/server/lib/event-stream/protocol.js CHANGED Viewed

@@ -71,6 +71,14 @@ export function parseSseEventEnvelope(block) {
 }
 export function sendMessageStreamWsFrame(socket, payload) {
+  try {
+    return sendSerializedMessageStreamWsFrame(socket, JSON.stringify(payload));
+  } catch {
+    return false;
+  }
+}
+export function sendSerializedMessageStreamWsFrame(socket, serializedFrame) {
   if (!socket || socket.readyState !== 1) {
     return false;
   }
@@ -86,7 +94,7 @@ export function sendMessageStreamWsFrame(socket, payload) {
   }
   try {
-    socket.send(JSON.stringify(payload));
+    socket.send(serializedFrame);
     const bufferedAfter = typeof socket.bufferedAmount === 'number' ? socket.bufferedAmount : 0;
     if (bufferedAfter > MESSAGE_STREAM_WS_MAX_BUFFERED_BYTES) {
       try {
@@ -124,10 +132,16 @@ export function sendMessageStreamWsFrame(socket, payload) {
 }
 export function sendMessageStreamWsEvent(socket, payload, options = {}) {
-  return sendMessageStreamWsFrame(socket, {
-    type: 'event',
-    payload,
-    ...(typeof options.eventId === 'string' && options.eventId.length > 0 ? { eventId: options.eventId } : {}),
-    ...(typeof options.directory === 'string' && options.directory.length > 0 ? { directory: options.directory } : {}),
-  });
+  try {
+    return sendSerializedMessageStreamWsFrame(socket, serializeMessageStreamWsEvent(payload, options));
+  } catch {
+    return false;
+  }
+}
+export function serializeMessageStreamWsEvent(payload, options = {}) {
+  const frame = { type: 'event', payload };
+  if (typeof options.eventId === 'string' && options.eventId.length > 0) frame.eventId = options.eventId;
+  if (typeof options.directory === 'string' && options.directory.length > 0) frame.directory = options.directory;
+  return JSON.stringify(frame);
 }

package/server/lib/event-stream/runtime.js CHANGED Viewed

@@ -5,7 +5,8 @@ import {
   MESSAGE_STREAM_DIRECTORY_WS_PATH,
   MESSAGE_STREAM_GLOBAL_WS_PATH,
   MESSAGE_STREAM_WS_HEARTBEAT_INTERVAL_MS,
-  sendMessageStreamWsEvent,
+  serializeMessageStreamWsEvent,
+  sendSerializedMessageStreamWsFrame,
 } from './protocol.js';
 import { createGlobalMessageStreamHub } from './global-hub.js';
 import { createGlobalMessageStreamWsBridge } from './global-ws-bridge.js';
@@ -28,20 +29,22 @@ export function createGlobalUiEventBroadcaster({
     }
     if (hasSseClients) {
+      const serializedPayload = JSON.stringify(payload);
       for (const res of sseClients) {
         try {
-          writeSseEvent(res, payload);
+          writeSseEvent(res, payload, serializedPayload);
         } catch {
         }
       }
     }
     if (hasWsClients) {
+      const serializedFrame = serializeMessageStreamWsEvent(payload, {
+        directory: typeof options.directory === 'string' && options.directory.length > 0 ? options.directory : 'global',
+        eventId: typeof options.eventId === 'string' && options.eventId.length > 0 ? options.eventId : undefined,
+      });
       for (const socket of Array.from(wsClients)) {
-        const sent = sendMessageStreamWsEvent(socket, payload, {
-          directory: typeof options.directory === 'string' && options.directory.length > 0 ? options.directory : 'global',
-          eventId: typeof options.eventId === 'string' && options.eventId.length > 0 ? options.eventId : undefined,
-        });
+        const sent = sendSerializedMessageStreamWsFrame(socket, serializedFrame);
         if (!sent) {
           wsClients.delete(socket);
         }

package/server/lib/event-stream/runtime.test.js CHANGED Viewed

@@ -2,6 +2,66 @@ import { EventEmitter } from 'node:events';
 import { describe, expect, it } from 'vitest';
 import { createGlobalUiEventBroadcaster, createMessageStreamWsRuntime } from './runtime.js';
+import { createGlobalMessageStreamHub } from './global-hub.js';
+import { createNotificationEmitterRuntime } from '../notifications/emitter-runtime.js';
+it('serializes a UI broadcast once per wire format and isolates failed clients', () => {
+  let serializations = 0;
+  const payload = { toJSON() { serializations++; return { type: 'aiworker:test', properties: { value: 'same' } }; } };
+  const writes = [];
+  const sseClients = new Set(Array.from({ length: 4 }, () => ({ write: text => writes.push(text) })));
+  const sockets = Array.from({ length: 4 }, () => ({ readyState: 1, bufferedAmount: 0, send: text => writes.push(text) }));
+  const failed = { readyState: 1, bufferedAmount: 0, send() { throw new Error('closed'); } };
+  const wsClients = new Set([...sockets, failed]);
+  const { writeSseEvent } = createNotificationEmitterRuntime({});
+  const broadcast = createGlobalUiEventBroadcaster({ sseClients, wsClients, writeSseEvent });
+  broadcast(payload);
+  expect(serializations).toBe(2);
+  expect(writes).toHaveLength(8);
+  expect(wsClients.has(failed)).toBe(false);
+  expect(wsClients.size).toBe(4);
+  expect(writes[0]).toBe(writes[3]);
+  expect(writes[4]).toBe(writes[7]);
+  sseClients.clear(); wsClients.clear();
+  broadcast(payload);
+  expect(serializations).toBe(2);
+});
+it('delivers oversized events live, but reports a replay gap instead of replaying across it', async () => {
+  const hub = createGlobalMessageStreamHub({
+    buildOpenCodeUrl: path => `http://127.0.0.1:4096${path}`,
+    getOpenCodeAuthHeaders: () => ({}),
+    replayByteLimit: 512,
+    fetchImpl: async (_url, options) => createSseResponse({
+      signal: options.signal, holdOpen: true,
+      blocks: [
+        'id: first\ndata: {"type":"first","properties":{}}\n\n',
+        `id: large\ndata: ${JSON.stringify({ type: 'large', properties: { text: '界'.repeat(1024) } })}\n\n`,
+        'id: last\ndata: {"type":"last","properties":{}}\n\n',
+      ],
+    }),
+  });
+  const runtime = createMessageStreamWsRuntime({
+    server: new EventEmitter(), globalEventHub: hub, wsClients: new Set(),
+    uiAuthController: null, isRequestOriginAllowed: async () => true,
+    rejectWebSocketUpgrade() {}, buildOpenCodeUrl: path => `http://127.0.0.1:4096${path}`,
+    getOpenCodeAuthHeaders: () => ({}), processForwardedEventPayload() {},
+  });
+  const first = new FakeSocket();
+  const reconnect = new FakeSocket();
+  try {
+    runtime.wsServer.emit('connection', first, { url: '/api/global/event/ws' });
+    await expect.poll(() => first.sent.filter(frame => frame.type === 'event').length).toBe(3);
+    expect(first.sent.find(frame => frame.eventId === 'large').payload.properties.text).toHaveLength(1024);
+    expect(hub.replayAfter('first')).toBeNull();
+    expect(hub.replayAfter('last')).toEqual([]);
+    runtime.wsServer.emit('connection', reconnect, { url: '/api/global/event/ws?lastEventId=first' });
+    await expect.poll(() => reconnect.sent.length).toBeGreaterThan(0);
+    expect(reconnect.sent).toEqual([{ type: 'ready', scope: 'global', replayReset: true }]);
+  } finally {
+    first.close(); reconnect.close(); hub.stop(); await runtime.close();
+  }
+});
 class FakeSocket extends EventEmitter {
   constructor() {

package/server/lib/git/DOCUMENTATION.md CHANGED Viewed

@@ -50,12 +50,21 @@ The following functions are exported and used by the web server:
 - `getRemotes(directory)`: Get list of configured remotes.
 ### Worktree Operations
-- `getWorktrees(directory)`: List all git worktrees for a repository.
+- `getWorktrees(directory)`: List all git worktrees for a repository. A directory outside any repository (or one that does not exist) is an authoritative empty list; any other git failure throws so callers keep their last known topology instead of clearing it. `GET /api/git/worktrees` answers such a failure with 500.
+- `observeWorktreeTopology(directory)`: Compare the repository's registered linked-worktree set with the last one seen for it and notify `subscribeWorktreeTopologyChanges` listeners when it changed. The set is fingerprinted from the `worktrees` directory under the common Git directory (mtime plus entry names), so the check is a stat and a readdir; the common directory is resolved with `git rev-parse --git-common-dir` once per requested directory and cached. The first observation only records a baseline. Never throws.
+- `subscribeWorktreeTopologyChanges(listener)`: Listener receives `{ directories, at }`, where `directories` are every directory of that repository the server has observed, so clients can map them onto registered projects. Returns an unsubscribe function.
 - `validateWorktreeCreate(directory, input)`: Validate worktree creation parameters (mode, branchName, startRef, upstream config).
 - `createWorktree(directory, input)`: Create a new worktree (supports 'new' and 'existing' modes, upstream setup). When the current tracked branch has no unpublished commits, the UI supplies its remote-tracking ref and this operation fetches that branch once before creating the worktree. A failed fetch falls back to the local branch and reports `sourceFetchFailed`; other remote start refs still require an existing local ref when their fetch fails. After populating the worktree, the repository's `post-checkout` hook runs once with git's standard arguments (null ref as previous HEAD, the checked-out HEAD, and flag `1`) from the worktree directory, mirroring `git worktree add` without `--no-checkout`; a missing or non-executable hook is skipped and a failing hook is logged as a warning, never failing worktree creation or the session bootstrap.
 - `removeWorktree(directory, input)`: Remove a worktree (optionally delete local branch).
 - `isLinkedWorktree(directory)`: Check if directory is a linked worktree (not primary).
+### Worktree topology change tracking
+There is no filesystem watcher and no polling. The server notices worktree changes in two ways, and both scale with what users are doing rather than with the number of registered projects:
+- Its own `createWorktree` and `removeWorktree` publish a change right after `git worktree add` / `git worktree remove` succeed (creation notifies before background population and setup scripts run).
+- `GET /api/git/status` for a repository and `GET /api/git/worktrees` with a non-empty listing call `observeWorktreeTopology` beside the response. Clients request status while they work in a repository, and a completed agent tool call already triggers a status refresh, so a worktree added by an agent or from a terminal is noticed on the next such request; nothing runs while the app is idle.
+`feature-routes-runtime.js` forwards each change to connected control-event clients as `aiworker:worktree-changed` with `{ directories, at }`. A repository nobody sends status or listing requests for is not observed until the next ordinary listing. `git worktree move` rewrites files inside an entry without touching the `worktrees` directory and is not detected. Tracking state is bounded: 500 directory-to-repository entries, 200 repositories, 100 directories per repository, least recently used dropped first.
 ### Worktree creation from a GitHub pull request
 The UI provisions `pr-<owner>` via `ensureRemoteName`/`ensureRemoteUrl`
 (HTTPS clone URL preferred over SSH) and checks out

package/server/lib/git/routes.js CHANGED Viewed

@@ -1,8 +1,11 @@
-export function registerGitRoutes(app) {
+export function registerGitRoutes(app, { emitWorktreeChanged } = {}) {
   let gitLibraries = null;
   const getGitLibraries = async () => {
     if (!gitLibraries) {
       gitLibraries = await import('./index.js');
+      if (emitWorktreeChanged) {
+        gitLibraries.subscribeWorktreeTopologyChanges(emitWorktreeChanged);
+      }
     }
     return gitLibraries;
   };
@@ -220,7 +223,7 @@ export function registerGitRoutes(app) {
   });
   app.get('/api/git/status', async (req, res) => {
-    const { getStatus, isGitRepository } = await getGitLibraries();
+    const { getStatus, isGitRepository, observeWorktreeTopology } = await getGitLibraries();
     try {
       const directory = resolveDirectoryQuery(req.query.directory);
@@ -233,6 +236,11 @@ export function registerGitRoutes(app) {
         return res.json(nonRepoStatusPayload());
       }
+      // Clients ask for status while they work in a repository, so this is
+      // where an externally added or removed worktree gets noticed. It runs
+      // beside the status call and never delays or fails the response.
+      void observeWorktreeTopology(directory);
       const mode = req.query.mode === 'light' ? 'light' : undefined;
       const status = await getStatus(directory, { mode });
       res.json(status);
@@ -1078,7 +1086,7 @@ export function registerGitRoutes(app) {
   });
   app.get('/api/git/worktrees', async (req, res) => {
-    const { getWorktrees } = await getGitLibraries();
+    const { getWorktrees, observeWorktreeTopology } = await getGitLibraries();
     try {
       const directory = req.query.directory;
       if (!directory) {
@@ -1086,13 +1094,18 @@ export function registerGitRoutes(app) {
       }
       const worktrees = await getWorktrees(directory);
+      // A repository always lists at least its primary worktree; an empty
+      // list means "not a repository" and has no topology to track.
+      if (worktrees.length > 0) {
+        void observeWorktreeTopology(directory);
+      }
       res.json(worktrees);
     } catch (error) {
-      // Worktrees are an optional feature. Avoid repeated 500s (and repeated client retries)
-      // when the directory isn't a git repo or uses shell shorthand like "~/".
-      console.warn('Failed to get worktrees, returning empty list:', error?.message || error);
-      res.setHeader('X-AiWorker-Warning', 'git worktrees unavailable');
-      res.json([]);
+      // A directory outside any repository still answers `[]` from getWorktrees.
+      // Anything else is a real failure the client must not mistake for "no
+      // worktrees", or it would drop the ones it already knows.
+      console.error('Failed to get worktrees:', error);
+      res.status(500).json({ error: error.message || 'Failed to get worktrees' });
     }
   });