@vellumai/assistant 0.6.3 → 0.6.5

package/src/runtime/http-server.ts

@@ -21,6 +21,10 @@ import {
   startGuardianActionSweep,
   stopGuardianActionSweep,
 } from "../calls/guardian-action-sweep.js";
+import {
+  activeMediaStreamSessions,
+  MediaStreamCallSession,
+} from "../calls/media-stream-server.js";
 import type { RelayWebSocketData } from "../calls/relay-server.js";
 import {
   activeRelayConnections,
@@ -37,6 +41,7 @@ import {
   hasUngatedHttpAuthDisabled,
   isHttpAuthDisabled,
 } from "../config/env.js";
+import { getConfig } from "../config/loader.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { PairingStore } from "../daemon/pairing-store.js";
 import {
@@ -62,10 +67,15 @@ import {
 import type { ExternalConversationBinding } from "../memory/external-conversation-store.js";
 import * as externalConversationStore from "../memory/external-conversation-store.js";
 import { listGroups } from "../memory/group-crud.js";
+import { resolveStreamingTranscriber } from "../providers/speech-to-text/resolve.js";
 import {
   consumeCallback,
   consumeCallbackError,
 } from "../security/oauth-callback-registry.js";
+import {
+  activeSttStreamSessions,
+  SttStreamSession,
+} from "../stt/stt-stream-session.js";
 import { UserError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import { getRuntimePortFilePath } from "../util/platform.js";
@@ -121,8 +131,8 @@ import { approvalRouteDefinitions } from "./routes/approval-routes.js";
 import { attachmentRouteDefinitions } from "./routes/attachment-routes.js";
 import { handleGetAudio } from "./routes/audio-routes.js";
 import { avatarRouteDefinitions } from "./routes/avatar-routes.js";
+import { backupRouteDefinitions } from "./routes/backup-routes.js";
 import { brainGraphRouteDefinitions } from "./routes/brain-graph-routes.js";
-import { browserCdpRouteDefinitions } from "./routes/browser-cdp-routes.js";
 import { handleBrowserExtensionPair } from "./routes/browser-extension-pair-routes.js";
 import { btwRouteDefinitions } from "./routes/btw-routes.js";
 import { callRouteDefinitions } from "./routes/call-routes.js";
@@ -154,12 +164,15 @@ import { debugRouteDefinitions } from "./routes/debug-routes.js";
 import { diagnosticsRouteDefinitions } from "./routes/diagnostics-routes.js";
 import { documentRouteDefinitions } from "./routes/documents-routes.js";
 import { eventsRouteDefinitions } from "./routes/events-routes.js";
+import { filingRouteDefinitions } from "./routes/filing-routes.js";
 import { globalSearchRouteDefinitions } from "./routes/global-search-routes.js";
 import { groupRouteDefinitions } from "./routes/group-routes.js";
 import { guardianActionRouteDefinitions } from "./routes/guardian-action-routes.js";
 import { handleGuardianBootstrap } from "./routes/guardian-bootstrap-routes.js";
 import { handleGuardianRefresh } from "./routes/guardian-refresh-routes.js";
 import { heartbeatRouteDefinitions } from "./routes/heartbeat-routes.js";
+import { homeFeedRouteDefinitions } from "./routes/home-feed-routes.js";
+import { homeStateRouteDefinitions } from "./routes/home-state-routes.js";
 import { hostBashRouteDefinitions } from "./routes/host-bash-routes.js";
 import {
   hostBrowserRouteDefinitions,
@@ -199,6 +212,7 @@ import { scheduleRouteDefinitions } from "./routes/schedule-routes.js";
 import { secretRouteDefinitions } from "./routes/secret-routes.js";
 import { settingsRouteDefinitions } from "./routes/settings-routes.js";
 import { skillRouteDefinitions } from "./routes/skills-routes.js";
+import { sttRouteDefinitions } from "./routes/stt-routes.js";
 import { subagentRouteDefinitions } from "./routes/subagents-routes.js";
 import { surfaceActionRouteDefinitions } from "./routes/surface-action-routes.js";
 import { surfaceContentRouteDefinitions } from "./routes/surface-content-routes.js";
@@ -213,6 +227,8 @@ import { watchRouteDefinitions } from "./routes/watch-routes.js";
 import { workItemRouteDefinitions } from "./routes/work-items-routes.js";
 import { workspaceCommitRouteDefinitions } from "./routes/workspace-commit-routes.js";
 import { workspaceRouteDefinitions } from "./routes/workspace-routes.js";
+import { setAnalysisDeps } from "./services/analyze-deps-singleton.js";
+import { matchSkillRoute } from "./skill-route-registry.js";
 
 // Re-export for consumers
 export { isPrivateAddress } from "./middleware/auth.js";
@@ -282,6 +298,40 @@ interface BrowserRelayWebSocketData {
   clientInstanceId?: string;
 }
 
+/**
+ * WebSocket data attached to `/v1/calls/media-stream` connections.
+ * The `wsType` discriminator routes frames to the media-stream call
+ * session instead of the ConversationRelay or browser-relay handlers.
+ */
+interface MediaStreamWebSocketData {
+  wsType: "media-stream";
+  callSessionId: string;
+  /** Bound at open time so the close handler tears down the exact session
+   *  that owns *this* socket, avoiding races with reconnects. */
+  session?: MediaStreamCallSession;
+}
+
+/**
+ * WebSocket data attached to `/v1/stt/stream` connections.
+ * The `wsType` discriminator routes frames to the STT streaming
+ * session orchestrator instead of the other WebSocket handlers.
+ *
+ * `provider` is optional compatibility metadata from the client/gateway.
+ * The runtime is config-authoritative — it always resolves the streaming
+ * transcriber from `services.stt.provider` in the assistant config.
+ */
+interface SttStreamWebSocketData {
+  wsType: "stt-stream";
+  /** Optional requested provider — metadata only; runtime uses config. */
+  provider?: string;
+  mimeType: string;
+  sampleRate?: number;
+  /** The session ID for tracking in the active sessions registry. */
+  sessionId: string;
+  /** Bound at open time so the close handler tears down the exact session. */
+  session?: SttStreamSession;
+}
+
 export class RuntimeHttpServer {
   private server: ReturnType<typeof Bun.serve> | null = null;
   private port: number;
@@ -311,6 +361,7 @@ export class RuntimeHttpServer {
   private getCesClient?: RuntimeHttpServerOptions["getCesClient"];
   private onProviderCredentialsChanged?: RuntimeHttpServerOptions["onProviderCredentialsChanged"];
   private getHeartbeatService?: RuntimeHttpServerOptions["getHeartbeatService"];
+  private getFilingService?: RuntimeHttpServerOptions["getFilingService"];
   private router: HttpRouter;
 
   constructor(options: RuntimeHttpServerOptions = {}) {
@@ -335,6 +386,7 @@ export class RuntimeHttpServer {
     this.getCesClient = options.getCesClient;
     this.onProviderCredentialsChanged = options.onProviderCredentialsChanged;
     this.getHeartbeatService = options.getHeartbeatService;
+    this.getFilingService = options.getFilingService;
     this.router = new HttpRouter(this.buildRouteTable());
   }
 
@@ -372,7 +424,11 @@ export class RuntimeHttpServer {
   }
 
   async start(): Promise<void> {
-    type AllWebSocketData = RelayWebSocketData | BrowserRelayWebSocketData;
+    type AllWebSocketData =
+      | RelayWebSocketData
+      | BrowserRelayWebSocketData
+      | MediaStreamWebSocketData
+      | SttStreamWebSocketData;
     this.server = Bun.serve<AllWebSocketData>({
       port: this.port,
       hostname: this.hostname,
@@ -399,6 +455,94 @@ export class RuntimeHttpServer {
             }
             return;
           }
+          if ("wsType" in data && data.wsType === "media-stream") {
+            const msData = data as MediaStreamWebSocketData;
+            log.info(
+              { callSessionId: msData.callSessionId },
+              "Media-stream WebSocket opened",
+            );
+            const session = new MediaStreamCallSession(
+              ws,
+              msData.callSessionId,
+            );
+            activeMediaStreamSessions.set(msData.callSessionId, session);
+            // Bind the session instance to the websocket so the close
+            // handler tears down *this* session, not a replacement that
+            // a reconnect may have inserted under the same callSessionId.
+            msData.session = session;
+            return;
+          }
+          if ("wsType" in data && data.wsType === "stt-stream") {
+            const sttData = data as SttStreamWebSocketData;
+
+            // The runtime is config-authoritative: always resolve the
+            // provider from `services.stt.provider` regardless of what
+            // the client/gateway requested.
+            //
+            // getConfig() can throw (e.g. after invalidateConfigCache()
+            // when config.json is temporarily invalid). Wrap in try/catch
+            // so the session still starts normally — resolveStreamingTranscriber
+            // reads config inside SttStreamSession.start()'s own guarded path.
+            let configuredProvider: string | undefined;
+            try {
+              configuredProvider = getConfig().services.stt.provider;
+
+              // Mismatch telemetry: when the optional requested provider
+              // disagrees with the configured provider, log a warning so
+              // operators can detect stale client builds.
+              if (sttData.provider && sttData.provider !== configuredProvider) {
+                log.warn(
+                  {
+                    requestedProvider: sttData.provider,
+                    configuredProvider,
+                    sessionId: sttData.sessionId,
+                  },
+                  "STT stream provider mismatch — requested provider differs from configured provider; using configured provider",
+                );
+              }
+            } catch (err) {
+              log.warn(
+                {
+                  error: err instanceof Error ? err.message : String(err),
+                  sessionId: sttData.sessionId,
+                },
+                "Failed to read config for STT provider mismatch telemetry — proceeding without mismatch check",
+              );
+            }
+
+            // Fall back to the requested provider (or "unknown") when
+            // config reading failed, so the session constructor still
+            // gets a usable label for logging/error messages.
+            const effectiveProvider =
+              configuredProvider ?? sttData.provider ?? "unknown";
+
+            log.info(
+              {
+                requestedProvider: sttData.provider ?? "(none)",
+                configuredProvider: effectiveProvider,
+                mimeType: sttData.mimeType,
+                sessionId: sttData.sessionId,
+              },
+              "STT stream WebSocket opened",
+            );
+            const session = new SttStreamSession(
+              ws,
+              effectiveProvider,
+              sttData.mimeType,
+              { sampleRate: sttData.sampleRate },
+            );
+            sttData.session = session;
+            activeSttStreamSessions.set(sttData.sessionId, session);
+
+            // Start the session asynchronously — resolves the streaming
+            // transcriber and sends a `ready` event on success.
+            void session.start(() =>
+              resolveStreamingTranscriber({
+                sampleRate: sttData.sampleRate,
+              }),
+            );
+            return;
+          }
           const callSessionId = (data as RelayWebSocketData).callSessionId;
           log.info({ callSessionId }, "ConversationRelay WebSocket opened");
           if (callSessionId) {
@@ -521,6 +665,14 @@ export class RuntimeHttpServer {
                 }
                 return;
               }
+              case "keepalive": {
+                // Extension keepalive frames refresh the connection's
+                // activity timestamp without producing log noise or
+                // altering routing semantics. Unknown extra keys on
+                // the frame are silently ignored (lenient validation).
+                getChromeExtensionRegistry().touch(data.connectionId);
+                return;
+              }
               default: {
                 log.debug(
                   { connectionId: data.connectionId, type: frame.type },
@@ -530,6 +682,28 @@ export class RuntimeHttpServer {
               }
             }
           }
+          if ("wsType" in data && data.wsType === "media-stream") {
+            const msData = data as MediaStreamWebSocketData;
+            msData.session?.handleMessage(raw);
+            return;
+          }
+          if ("wsType" in data && data.wsType === "stt-stream") {
+            const sttData = data as SttStreamWebSocketData;
+            const session = sttData.session;
+            if (!session) return;
+
+            if (typeof message === "string") {
+              session.handleMessage(message);
+            } else {
+              // Binary frame — raw audio bytes.
+              const buffer =
+                message instanceof ArrayBuffer
+                  ? Buffer.from(new Uint8Array(message))
+                  : Buffer.from(message);
+              session.handleBinaryAudio(buffer);
+            }
+            return;
+          }
           const callSessionId = (data as RelayWebSocketData).callSessionId;
           if (callSessionId) {
             const connection = activeRelayConnections.get(callSessionId);
@@ -547,6 +721,56 @@ export class RuntimeHttpServer {
             getChromeExtensionRegistry().unregister(data.connectionId);
             return;
           }
+          if ("wsType" in data && data.wsType === "media-stream") {
+            const msData = data as MediaStreamWebSocketData;
+            log.info(
+              {
+                callSessionId: msData.callSessionId,
+                code,
+                reason: reason?.toString(),
+              },
+              "Media-stream WebSocket closed",
+            );
+            // Use the session bound at open time so we tear down the
+            // exact session that owns *this* socket, not a replacement
+            // that a reconnect may have inserted under the same key.
+            const msSession = msData.session;
+            if (msSession) {
+              msSession.handleTransportClosed(code, reason?.toString());
+              msSession.destroy();
+              // Only delete from the map if *our* session is still the
+              // registered one — a reconnect may have already replaced it.
+              if (
+                activeMediaStreamSessions.get(msData.callSessionId) ===
+                msSession
+              ) {
+                activeMediaStreamSessions.delete(msData.callSessionId);
+              }
+            }
+            return;
+          }
+          if ("wsType" in data && data.wsType === "stt-stream") {
+            const sttData = data as SttStreamWebSocketData;
+            log.info(
+              {
+                provider: sttData.provider,
+                sessionId: sttData.sessionId,
+                code,
+                reason: reason?.toString(),
+              },
+              "STT stream WebSocket closed",
+            );
+            const session = sttData.session;
+            if (session) {
+              session.handleClose(code, reason?.toString());
+              // Only delete from the map if our session is still the
+              // registered one — avoids races with reconnects.
+              if (activeSttStreamSessions.get(sttData.sessionId) === session) {
+                activeSttStreamSessions.delete(sttData.sessionId);
+              }
+            }
+            return;
+          }
           const callSessionId = (data as RelayWebSocketData).callSessionId;
           log.info(
             { callSessionId, code, reason: reason?.toString() },
@@ -715,6 +939,15 @@ export class RuntimeHttpServer {
       clearInterval(this.retrySweepTimer);
       this.retrySweepTimer = null;
     }
+
+    // Deterministic teardown of active STT streaming sessions before
+    // stopping the HTTP server so provider sessions are cleaned up
+    // and clients receive proper close frames.
+    for (const [sessionId, session] of activeSttStreamSessions) {
+      session.destroy();
+      activeSttStreamSessions.delete(sessionId);
+    }
+
     if (this.server) {
       this.server.stop(true);
       this.server = null;
@@ -771,6 +1004,24 @@ export class RuntimeHttpServer {
       return this.handleRelayUpgrade(req, server);
     }
 
+    // WebSocket upgrade for Twilio Media Streams — same private-network
+    // restrictions as relay upgrades.
+    if (
+      path.startsWith("/v1/calls/media-stream") &&
+      req.headers.get("upgrade")?.toLowerCase() === "websocket"
+    ) {
+      return this.handleMediaStreamUpgrade(req, server);
+    }
+
+    // WebSocket upgrade for STT streaming — private-network restrictions
+    // and explicit gateway-service token verification before upgrade.
+    if (
+      path === "/v1/stt/stream" &&
+      req.headers.get("upgrade")?.toLowerCase() === "websocket"
+    ) {
+      return this.handleSttStreamUpgrade(req, server);
+    }
+
     // Twilio webhook endpoints — before auth check because Twilio
     // webhook POSTs don't include bearer tokens.
     const twilioResponse = await this.handleTwilioWebhook(req, path);
@@ -810,6 +1061,20 @@ export class RuntimeHttpServer {
       return await handleGuardianRefresh(req);
     }
 
+    // Skill-registered routes (e.g. meet-bot event ingress). Handled before
+    // JWT auth because skills may use their own auth (e.g. per-meeting bearer
+    // tokens minted by a session manager).
+    const skillMatch = matchSkillRoute(path, req.method);
+    if (skillMatch) {
+      if (skillMatch.kind === "methodMismatch") {
+        return new Response("Method Not Allowed", {
+          status: 405,
+          headers: { Allow: skillMatch.allow.join(", ") },
+        });
+      }
+      return await skillMatch.route.handler(req, skillMatch.match);
+    }
+
     // JWT bearer authentication — replaces the old shared-secret comparison.
     // authenticateRequest handles dev bypass (DISABLE_HTTP_AUTH) internally.
     //
@@ -1060,6 +1325,108 @@ export class RuntimeHttpServer {
     return undefined!;
   }
 
+  private handleMediaStreamUpgrade(
+    req: Request,
+    server: ReturnType<typeof Bun.serve>,
+  ): Response {
+    if (!isPrivateNetworkPeer(server, req) || !isPrivateNetworkOrigin(req)) {
+      return httpError(
+        "FORBIDDEN",
+        "Direct media-stream access disabled — only private network peers allowed",
+        403,
+      );
+    }
+
+    const wsUrl = new URL(req.url);
+    const callSessionId = wsUrl.searchParams.get("callSessionId");
+    if (!callSessionId) {
+      return new Response("Missing callSessionId", { status: 400 });
+    }
+    // Media-stream connections use a distinct wsType so the open/message/close
+    // handlers route them to MediaStreamCallSession instead of RelayConnection.
+    const upgraded = server.upgrade(req, {
+      data: {
+        wsType: "media-stream",
+        callSessionId,
+      } satisfies MediaStreamWebSocketData,
+    });
+    if (!upgraded) {
+      return new Response("WebSocket upgrade failed", { status: 500 });
+    }
+    // Bun's WebSocket upgrade consumes the request — no Response is sent.
+    return undefined!;
+  }
+
+  /**
+   * Handle WebSocket upgrade for `/v1/stt/stream`.
+   *
+   * Private-network restrictions apply (same as relay/media-stream) so the
+   * runtime remains unreachable from the public internet. The gateway
+   * authenticates the downstream client and proxies the upgrade with a
+   * short-lived gateway service token.
+   */
+  private handleSttStreamUpgrade(
+    req: Request,
+    server: ReturnType<typeof Bun.serve>,
+  ): Response {
+    if (!isPrivateNetworkPeer(server, req) || !isPrivateNetworkOrigin(req)) {
+      return httpError(
+        "FORBIDDEN",
+        "Direct STT stream access disabled — only private network peers allowed",
+        403,
+      );
+    }
+
+    // Verify the gateway service token before accepting the upgrade.
+    if (!isHttpAuthDisabled()) {
+      const wsUrl = new URL(req.url);
+      const token = wsUrl.searchParams.get("token");
+      if (!token) {
+        return httpError("UNAUTHORIZED", "Unauthorized", 401);
+      }
+      const jwtResult = verifyToken(token, "vellum-daemon");
+      if (!jwtResult.ok) {
+        return httpError("UNAUTHORIZED", "Unauthorized", 401);
+      }
+      // Accept gateway service tokens (svc:gateway:*) — these are the
+      // only tokens the gateway mints for upstream connections.
+      const subResult = parseSub(jwtResult.claims.sub);
+      if (!subResult.ok || subResult.principalType !== "svc_gateway") {
+        return httpError("UNAUTHORIZED", "Unauthorized", 401);
+      }
+    }
+
+    const wsUrl = new URL(req.url);
+    // provider is optional compatibility metadata — the runtime resolves
+    // the streaming transcriber from config (`services.stt.provider`).
+    const provider = wsUrl.searchParams.get("provider") ?? undefined;
+    const mimeType = wsUrl.searchParams.get("mimeType");
+    if (!mimeType) {
+      return new Response("Missing required query parameter: mimeType", {
+        status: 400,
+      });
+    }
+
+    const sampleRateRaw = wsUrl.searchParams.get("sampleRate");
+    const sampleRate = sampleRateRaw ? parseInt(sampleRateRaw, 10) : undefined;
+
+    const sessionId = crypto.randomUUID();
+    const upgraded = server.upgrade(req, {
+      data: {
+        wsType: "stt-stream",
+        provider,
+        mimeType,
+        sampleRate,
+        sessionId,
+      } satisfies SttStreamWebSocketData,
+    });
+    if (!upgraded) {
+      return new Response("WebSocket upgrade failed", { status: 500 });
+    }
+    // Bun's WebSocket upgrade consumes the request — no Response is sent.
+    return undefined!;
+  }
+
   private async handleTwilioWebhook(
     req: Request,
     path: string,
@@ -1237,6 +1604,9 @@ export class RuntimeHttpServer {
           : {}),
       groupId: displayMeta?.groupId ?? null,
       ...(forkParent ? { forkParent } : {}),
+      ...(conversation.archivedAt != null
+        ? { archivedAt: conversation.archivedAt }
+        : {}),
     };
   }
 
@@ -1339,6 +1709,11 @@ export class RuntimeHttpServer {
       ...heartbeatRouteDefinitions({
         getHeartbeatService: this.getHeartbeatService,
       }),
+      ...filingRouteDefinitions({
+        getFilingService: this.getFilingService,
+      }),
+      ...homeStateRouteDefinitions(),
+      ...homeFeedRouteDefinitions(),
       ...notificationRouteDefinitions(),
       ...diagnosticsRouteDefinitions(),
       ...logExportRouteDefinitions(),
@@ -1372,6 +1747,7 @@ export class RuntimeHttpServer {
           : undefined,
       }),
       ...ttsRouteDefinitions(),
+      ...sttRouteDefinitions(),
 
       // Conversation list and seen signal — kept inline because they
       // depend on multiple cross-cutting stores that aren't grouped
@@ -1438,13 +1814,28 @@ export class RuntimeHttpServer {
         ? conversationManagementRouteDefinitions(conversationManagementDeps)
         : []),
 
-      ...(this.sendMessageDeps
-        ? conversationAnalysisRouteDefinitions({
-            sendMessageDeps: this.sendMessageDeps,
-            buildConversationDetailResponse: (id) =>
-              this.buildConversationDetailResponse(id),
-          })
-        : []),
+      ...((): RouteDefinition[] => {
+        const sendMessageDeps = this.sendMessageDeps;
+        if (!sendMessageDeps) return [];
+        const analysisDeps = {
+          sendMessageDeps,
+          buildConversationDetailResponse: (id: string) =>
+            this.buildConversationDetailResponse(id),
+        };
+        // Also expose via the module singleton so background callers
+        // (e.g. job handlers) can invoke analyzeConversation() without
+        // HTTP-layer wiring. Daemon startup must never block, so failures
+        // to register the singleton are logged and swallowed.
+        try {
+          setAnalysisDeps(analysisDeps);
+        } catch (err) {
+          log.warn(
+            { err },
+            "Failed to register analysis deps singleton; background analysis jobs will be skipped",
+          );
+        }
+        return conversationAnalysisRouteDefinitions(analysisDeps);
+      })(),
 
       ...groupRouteDefinitions(),
 
@@ -1466,6 +1857,21 @@ export class RuntimeHttpServer {
               404,
             );
           try {
+            // Snapshot current state to detect whether the seen cursor
+            // actually advances (avoids emitting on no-op signals).
+            // Only consider a conversation "unseen" when a latest assistant
+            // message exists and the seen cursor is behind it — matching
+            // the hasUnseenLatestAssistantMessage logic in buildAssistantAttention.
+            const priorState = getAttentionStateByConversationIds([
+              conversationId,
+            ]).get(conversationId);
+            const wasUnseen =
+              priorState != null &&
+              priorState.latestAssistantMessageAt != null &&
+              (priorState.lastSeenAssistantMessageAt == null ||
+                priorState.lastSeenAssistantMessageAt <
+                  priorState.latestAssistantMessageAt);
+
             recordConversationSeenSignal({
               conversationId,
               sourceChannel: (body.sourceChannel as string) ?? "vellum",
@@ -1478,6 +1884,21 @@ export class RuntimeHttpServer {
               metadata: body.metadata as Record<string, unknown> | undefined,
               observedAt: body.observedAt as number | undefined,
             });
+            if (wasUnseen) {
+              assistantEventHub
+                .publish(
+                  buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+                    type: "conversation_list_invalidated",
+                    reason: "seen_changed",
+                  }),
+                )
+                .catch((err) => {
+                  log.warn(
+                    { err },
+                    "Failed to publish conversation_list_invalidated (seen_changed)",
+                  );
+                });
+            }
             return Response.json({ ok: true });
           } catch (err) {
             log.error(
@@ -1509,7 +1930,22 @@ export class RuntimeHttpServer {
               404,
             );
           try {
-            markConversationUnread(conversationId);
+            const changed = markConversationUnread(conversationId);
+            if (changed) {
+              assistantEventHub
+                .publish(
+                  buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+                    type: "conversation_list_invalidated",
+                    reason: "seen_changed",
+                  }),
+                )
+                .catch((err) => {
+                  log.warn(
+                    { err },
+                    "Failed to publish conversation_list_invalidated (seen_changed)",
+                  );
+                });
+            }
             return Response.json({ ok: true });
           } catch (err) {
             if (err instanceof UserError) {
@@ -1563,7 +1999,6 @@ export class RuntimeHttpServer {
       ...approvalRouteDefinitions(),
       ...hostBashRouteDefinitions(),
       ...hostBrowserRouteDefinitions(),
-      ...browserCdpRouteDefinitions(),
       ...hostCuRouteDefinitions(),
       ...hostFileRouteDefinitions(),
       ...(this.getSkillContext
@@ -1685,6 +2120,7 @@ export class RuntimeHttpServer {
       ...eventsRouteDefinitions(),
       ...traceEventRouteDefinitions(),
       ...migrationRouteDefinitions(),
+      ...backupRouteDefinitions(),
 
       // User-defined routes under /x/* — must be LAST so built-in routes
       // always take priority.