@schlessera/brain-ui-server 0.17.0 → 0.19.0

package/src/ws/dispatch.ts

@@ -177,6 +177,19 @@ export async function handleClientMessage(
       break;
     }
 
+    case "activity_subscribe": {
+      // View-scoped opt-in: without a subscription this connection never
+      // receives an activity frame. No turn correlation — subscriptions are
+      // connection state, not turn state.
+      host.activity?.stream.handleSubscribe(ws, msg);
+      break;
+    }
+
+    case "activity_unsubscribe": {
+      host.activity?.stream.handleUnsubscribe(ws, msg);
+      break;
+    }
+
     case "session_resume": {
       host.sendMessage(ws, {
         type: "session_info",

package/src/ws/host.ts

@@ -5,6 +5,16 @@ import type { SessionCatalog } from "./session-catalog.js";
 import type { BackendRegistry } from "../agent/backend.js";
 import { createSilentObservability, type Observability } from "../observability/index.js";
 import { FrameRateLimiter } from "./rate-limit.js";
+import type { ActivityStore } from "../activity/store.js";
+import type { ActivityStream } from "../activity/stream.js";
+
+/** The activity record and its live stream, when the host records activity. */
+export interface ActivityRuntime {
+  store: ActivityStore;
+  stream: ActivityStream;
+  /** Read seam for the agent-facing query tool (bridge.queryActivity). */
+  query?: (query: import("@schlessera/brain-ui-sdk/server").ActivityQuery) => Record<string, unknown>;
+}
 
 /** Host-side turn timeout. The backend no longer times out — the host owns it. */
 const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
@@ -65,6 +75,12 @@ export interface WsHostOptions {
    * fronting the socket with its own limiter wants.
    */
   wsRate?: { ratePerSecond: number; burst: number };
+  /**
+   * Activity recording (span store + live stream). Optional: a host without
+   * one records nothing and never sends activity frames — which is also what
+   * most existing tests want.
+   */
+  activity?: ActivityRuntime;
 }
 
 /** Identity of one turn, as it appears on a log record. */
@@ -102,6 +118,7 @@ export class WsHost {
   maxConcurrentSessions: () => number;
   readonly observability: Observability;
   readonly wsRate: { ratePerSecond: number; burst: number } | null;
+  readonly activity: ActivityRuntime | null;
   /** Scoped instruments, resolved once — `[ws]` is the existing log prefix. */
   readonly log: ReturnType<Observability["logger"]>;
   private readonly framesDropped: ReturnType<
@@ -130,6 +147,7 @@ export class WsHost {
     this.observability = options.observability ?? createSilentObservability();
     this.wsRate =
       options.wsRate && options.wsRate.ratePerSecond > 0 ? options.wsRate : null;
+    this.activity = options.activity ?? null;
     this.log = this.observability.logger("ws");
     const meter = this.observability.meter("ws");
     this.framesDropped = meter.createCounter("ws.frames.dropped", {

package/src/ws/run-session.ts

@@ -2,6 +2,7 @@ import type { ChatImageAttachment, ClientEnvironment } from "@schlessera/brain-u
 import type { WSContext } from "./clients.js";
 import { withSessionId, withTurnScope } from "./frames.js";
 import { makeBridge, emitTurnError } from "./bridge.js";
+import { createTurnRecorder, type TurnRecorder } from "../activity/recorder.js";
 import { resolveTurnTarget } from "./routing.js";
 import type { QueuedFollowUp, RunningTurn } from "./turns.js";
 import { queuedBytes, queuedFollowUpBytes } from "./turns.js";
@@ -114,7 +115,19 @@ export async function runSession(
       }, host.turnTimeoutMs);
       turn.timeoutHandle = timeoutHandle;
 
-      const bridge = makeBridge(host, turn, text, backend.id);
+      // One recorder per turn identity: a queued follow-up re-mints turnId
+      // and gets its own run in the activity record.
+      const recorder: TurnRecorder | undefined = host.activity
+        ? createTurnRecorder(
+            {
+              store: host.activity.store,
+              onWrite: () => host.activity!.stream.pump(),
+              log: host.log,
+            },
+            { turnId: turn.turnId, sessionId: turn.sessionId }
+          )
+        : undefined;
+      const bridge = makeBridge(host, turn, text, backend.id, recorder);
       const startedAt = Date.now();
       host.reportTurnStarted(turn);
       try {
@@ -124,6 +137,10 @@ export async function runSession(
           sessionId: resumeId,
           profileId,
           signal: abortController.signal,
+          // The budget this very timer enforces, so the backend can put the
+          // real number in front of the model instead of it finding the cap
+          // mid-flight.
+          turnBudgetMs: host.turnTimeoutMs,
           bridge,
           ...(client ? { client } : {}),
         });
@@ -135,8 +152,22 @@ export async function runSession(
         } else {
           host.reportTurnCompleted(turn, Date.now() - startedAt);
         }
+        // Terminal precedence: cancellation and timeout are host-owned facts;
+        // otherwise the recorder refines from the buffered result frame.
+        recorder?.finish(
+          turn.cancelled
+            ? "cancelled"
+            : abortController.signal.aborted
+              ? "timeout"
+              : turn.lastResult === "error"
+                ? "error"
+                : "success"
+        );
       } catch (err) {
         emitTurnError(host, turn, err);
+        recorder?.finish(
+          turn.cancelled ? "cancelled" : abortController.signal.aborted ? "timeout" : "error"
+        );
       } finally {
         clearTimeout(timeoutHandle);
       }

package/src/ws/turns.ts

@@ -2,10 +2,15 @@ import type { Logger } from "@opentelemetry/api-logs";
 import type {
   AgentBackend,
   PermissionDecision,
+  PermissionRequest,
   AskUserResult,
   LocationFix,
 } from "@schlessera/brain-ui-sdk/server";
-import type { ChatImageAttachment, ClientEnvironment } from "@schlessera/brain-ui-sdk/protocol";
+import type {
+  AskUserQuestion,
+  ChatImageAttachment,
+  ClientEnvironment,
+} from "@schlessera/brain-ui-sdk/protocol";
 
 export interface QueuedFollowUp {
   text: string;
@@ -77,12 +82,21 @@ export interface RunningTurn {
 export interface PendingApproval {
   turn: RunningTurn;
   turnId: string;
+  /**
+   * The original request, kept so the card can be RE-DELIVERED to a client
+   * that connects later. On a phone the socket drops every time the screen
+   * locks; an approval must survive that and reappear, not silently die.
+   */
+  request: PermissionRequest;
   resolve: (decision: PermissionDecision) => void;
 }
 
 export interface PendingAskUser {
   turn: RunningTurn;
   turnId: string;
+  /** Kept for re-delivery on reconnect, like PendingApproval.request. */
+  requestId: string;
+  questions: AskUserQuestion[];
   resolve: (result: AskUserResult) => void;
   reject: (err: Error) => void;
 }
@@ -168,6 +182,20 @@ export class TurnCoordinator {
       p.reject(new Error(reason));
       this.pendingAskUser.delete(id);
     }
+    this.drainClientBoundForTurn(turn, reason);
+  }
+
+  /**
+   * Reject only the requests that NEED a live client at this instant —
+   * location and mask, whose sibling handlers already fail fast with no
+   * client attached. Approvals and ask-user cards deliberately survive a
+   * disconnect: on a phone the socket drops at every screen lock, and before
+   * this split a pending approval was silently denied the moment the screen
+   * went dark ("Client disconnected") while one raised DURING the dark parked
+   * until the turn timeout. Both now hold, bounded by the turn timeout, and
+   * re-deliver on reconnect.
+   */
+  drainClientBoundForTurn(turn: RunningTurn, reason: string): void {
     for (const [id, p] of this.pendingLocation) {
       if (p.turn !== turn) continue;
       p.reject(new Error(reason));