@jmoyers/harness 0.1.0

package/src/services/conversation-lifecycle.ts

@@ -0,0 +1,176 @@
+import {
+  ConversationStartupHydrationService,
+  type ConversationStartupHydrationServiceOptions,
+  type SessionSummaryLike,
+} from './conversation-startup-hydration.ts';
+import {
+  RuntimeConversationStarter,
+  type RuntimeConversationStarterConversationRecord,
+  type RuntimeConversationStarterOptions,
+} from './runtime-conversation-starter.ts';
+import {
+  RuntimeConversationActivation,
+  type RuntimeConversationActivationOptions,
+} from './runtime-conversation-activation.ts';
+import {
+  RuntimeConversationActions,
+  type RuntimeConversationActionsOptions,
+} from './runtime-conversation-actions.ts';
+import {
+  RuntimeConversationTitleEditService,
+  type RuntimeConversationTitleEditServiceOptions,
+} from './runtime-conversation-title-edit.ts';
+import {
+  RuntimeStreamSubscriptions,
+  type RuntimeStreamSubscriptionsOptions,
+} from './runtime-stream-subscriptions.ts';
+import {
+  StartupPersistedConversationQueueService,
+  type StartupPersistedConversationQueueServiceOptions,
+  type StartupQueueConversationRecord,
+} from './startup-persisted-conversation-queue.ts';
+
+interface ConversationLifecycleOptions<
+  TConversation extends RuntimeConversationStarterConversationRecord &
+    StartupQueueConversationRecord & { title: string },
+  TSessionSummary extends SessionSummaryLike,
+  TControllerRecord,
+> {
+  readonly streamSubscriptions: RuntimeStreamSubscriptionsOptions;
+  readonly starter: Omit<
+    RuntimeConversationStarterOptions<TConversation, TSessionSummary>,
+    'subscribeConversationEvents'
+  >;
+  readonly startupHydration: Omit<
+    ConversationStartupHydrationServiceOptions<TSessionSummary>,
+    'subscribeConversationEvents'
+  >;
+  readonly startupQueue: Omit<
+    StartupPersistedConversationQueueServiceOptions<TConversation>,
+    'startConversation'
+  >;
+  readonly activation: Omit<RuntimeConversationActivationOptions, 'startConversation'>;
+  readonly actions: Omit<
+    RuntimeConversationActionsOptions<TControllerRecord>,
+    'startConversation' | 'activateConversation'
+  >;
+  readonly titleEdit: RuntimeConversationTitleEditServiceOptions<TConversation>;
+}
+
+export class ConversationLifecycle<
+  TConversation extends RuntimeConversationStarterConversationRecord &
+    StartupQueueConversationRecord & { title: string },
+  TSessionSummary extends SessionSummaryLike,
+  TControllerRecord,
+> {
+  private readonly streamSubscriptions: RuntimeStreamSubscriptions;
+  private readonly starter: RuntimeConversationStarter<TConversation, TSessionSummary>;
+  private readonly startupHydration: ConversationStartupHydrationService<TSessionSummary>;
+  private readonly startupQueue: StartupPersistedConversationQueueService<TConversation>;
+  private readonly activation: RuntimeConversationActivation;
+  private readonly actions: RuntimeConversationActions<TControllerRecord>;
+  private readonly titleEdit: RuntimeConversationTitleEditService<TConversation>;
+
+  constructor(
+    options: ConversationLifecycleOptions<TConversation, TSessionSummary, TControllerRecord>,
+  ) {
+    this.streamSubscriptions = new RuntimeStreamSubscriptions(options.streamSubscriptions);
+    this.starter = new RuntimeConversationStarter({
+      ...options.starter,
+      subscribeConversationEvents: async (sessionId) => {
+        await this.subscribeConversationEvents(sessionId);
+      },
+    });
+    this.startupHydration = new ConversationStartupHydrationService({
+      ...options.startupHydration,
+      subscribeConversationEvents: async (sessionId) => {
+        await this.subscribeConversationEvents(sessionId);
+      },
+    });
+    this.startupQueue = new StartupPersistedConversationQueueService({
+      ...options.startupQueue,
+      startConversation: async (sessionId) => {
+        await this.startConversation(sessionId);
+      },
+    });
+    this.activation = new RuntimeConversationActivation({
+      ...options.activation,
+      startConversation: async (sessionId) => {
+        await this.startConversation(sessionId);
+      },
+    });
+    this.actions = new RuntimeConversationActions({
+      ...options.actions,
+      startConversation: async (sessionId) => {
+        await this.startConversation(sessionId);
+      },
+      activateConversation: async (sessionId) => {
+        await this.activateConversation(sessionId);
+      },
+    });
+    this.titleEdit = new RuntimeConversationTitleEditService(options.titleEdit);
+  }
+
+  async subscribeConversationEvents(sessionId: string): Promise<void> {
+    await this.streamSubscriptions.subscribeConversationEvents(sessionId);
+  }
+
+  async unsubscribeConversationEvents(sessionId: string): Promise<void> {
+    await this.streamSubscriptions.unsubscribeConversationEvents(sessionId);
+  }
+
+  async subscribeTaskPlanningEvents(afterCursor: number | null): Promise<void> {
+    await this.streamSubscriptions.subscribeTaskPlanningEvents(afterCursor);
+  }
+
+  async unsubscribeTaskPlanningEvents(): Promise<void> {
+    await this.streamSubscriptions.unsubscribeTaskPlanningEvents();
+  }
+
+  async startConversation(sessionId: string): Promise<TConversation> {
+    return await this.starter.startConversation(sessionId);
+  }
+
+  async activateConversation(sessionId: string): Promise<void> {
+    await this.activation.activateConversation(sessionId);
+  }
+
+  async createAndActivateConversationInDirectory(
+    directoryId: string,
+    agentType: string,
+  ): Promise<void> {
+    await this.actions.createAndActivateConversationInDirectory(directoryId, agentType);
+  }
+
+  async openOrCreateCritiqueConversationInDirectory(directoryId: string): Promise<void> {
+    await this.actions.openOrCreateCritiqueConversationInDirectory(directoryId);
+  }
+
+  async takeoverConversation(sessionId: string): Promise<void> {
+    await this.actions.takeoverConversation(sessionId);
+  }
+
+  scheduleConversationTitlePersist(): void {
+    this.titleEdit.schedulePersist();
+  }
+
+  stopConversationTitleEdit(persistPending: boolean): void {
+    this.titleEdit.stop(persistPending);
+  }
+
+  beginConversationTitleEdit(conversationId: string): void {
+    this.titleEdit.begin(conversationId);
+  }
+
+  clearConversationTitleEditTimer(): void {
+    this.titleEdit.clearCurrentTimer();
+  }
+
+  async hydrateConversationList(): Promise<void> {
+    await this.startupHydration.hydrateConversationList();
+  }
+
+  queuePersistedConversationsInBackground(activeSessionId: string | null): number {
+    return this.startupQueue.queuePersistedConversationsInBackground(activeSessionId);
+  }
+}

package/src/services/conversation-startup-hydration.ts

@@ -0,0 +1,47 @@
+export interface SessionSummaryLike {
+  readonly sessionId: string;
+  readonly live: boolean;
+}
+
+interface PerfSpanLike {
+  end(input?: Record<string, unknown>): void;
+}
+
+export interface ConversationStartupHydrationServiceOptions<
+  TSessionSummary extends SessionSummaryLike,
+> {
+  readonly startHydrationSpan: () => PerfSpanLike;
+  readonly hydrateDirectoryList: () => Promise<void>;
+  readonly directoryIds: () => readonly string[];
+  readonly hydratePersistedConversationsForDirectory: (directoryId: string) => Promise<number>;
+  readonly listSessions: () => Promise<readonly TSessionSummary[]>;
+  readonly upsertFromSessionSummary: (summary: TSessionSummary) => void;
+  readonly subscribeConversationEvents: (sessionId: string) => Promise<void>;
+}
+
+export class ConversationStartupHydrationService<TSessionSummary extends SessionSummaryLike> {
+  constructor(
+    private readonly options: ConversationStartupHydrationServiceOptions<TSessionSummary>,
+  ) {}
+
+  async hydrateConversationList(): Promise<void> {
+    const hydrateSpan = this.options.startHydrationSpan();
+    await this.options.hydrateDirectoryList();
+    let persistedCount = 0;
+    for (const directoryId of this.options.directoryIds()) {
+      persistedCount += await this.options.hydratePersistedConversationsForDirectory(directoryId);
+    }
+
+    const summaries = await this.options.listSessions();
+    for (const summary of summaries) {
+      this.options.upsertFromSessionSummary(summary);
+      if (summary.live) {
+        await this.options.subscribeConversationEvents(summary.sessionId);
+      }
+    }
+    hydrateSpan.end({
+      persisted: persistedCount,
+      live: summaries.length,
+    });
+  }
+}

package/src/services/directory-hydration.ts

@@ -0,0 +1,49 @@
+interface DirectoryRecordLike {
+  readonly directoryId: string;
+  readonly path: string;
+}
+
+interface DirectoryHydrationControlPlane<TDirectoryRecord extends DirectoryRecordLike> {
+  listDirectories(): Promise<readonly TDirectoryRecord[]>;
+  upsertDirectory(input: { directoryId: string; path: string }): Promise<TDirectoryRecord>;
+}
+
+interface DirectoryHydrationServiceOptions<TDirectoryRecord extends DirectoryRecordLike> {
+  readonly controlPlaneService: DirectoryHydrationControlPlane<TDirectoryRecord>;
+  readonly resolveWorkspacePathForMux: (rawPath: string) => string;
+  readonly clearDirectories: () => void;
+  readonly setDirectory: (directoryId: string, directory: TDirectoryRecord) => void;
+  readonly hasDirectory: (directoryId: string) => boolean;
+  readonly persistedDirectory: TDirectoryRecord;
+  readonly resolveActiveDirectoryId: () => string | null;
+}
+
+export class DirectoryHydrationService<TDirectoryRecord extends DirectoryRecordLike> {
+  constructor(private readonly options: DirectoryHydrationServiceOptions<TDirectoryRecord>) {}
+
+  async hydrate(): Promise<void> {
+    const rows = await this.options.controlPlaneService.listDirectories();
+    this.options.clearDirectories();
+    for (const row of rows) {
+      const normalizedPath = this.options.resolveWorkspacePathForMux(row.path);
+      if (normalizedPath !== row.path) {
+        const repairedRecord = await this.options.controlPlaneService.upsertDirectory({
+          directoryId: row.directoryId,
+          path: normalizedPath,
+        });
+        this.options.setDirectory(row.directoryId, repairedRecord);
+        continue;
+      }
+      this.options.setDirectory(row.directoryId, row);
+    }
+    if (!this.options.hasDirectory(this.options.persistedDirectory.directoryId)) {
+      this.options.setDirectory(
+        this.options.persistedDirectory.directoryId,
+        this.options.persistedDirectory,
+      );
+    }
+    if (this.options.resolveActiveDirectoryId() === null) {
+      throw new Error('no active directory available after hydrate');
+    }
+  }
+}

package/src/services/event-persistence.ts

@@ -0,0 +1,104 @@
+import type { NormalizedEventEnvelope } from '../events/normalized-events.ts';
+
+type PerfAttrs = Record<string, boolean | number | string>;
+
+type FlushReason = 'timer' | 'immediate' | 'shutdown';
+
+interface PerfSpanLike {
+  end(attrs: PerfAttrs): void;
+}
+
+type StartPerfSpanLike = (name: string, attrs: PerfAttrs) => PerfSpanLike;
+
+interface EventPersistenceOptions {
+  readonly appendEvents: (events: readonly NormalizedEventEnvelope[]) => void;
+  readonly startPerfSpan: StartPerfSpanLike;
+  readonly writeStderr: (text: string) => void;
+  readonly flushDelayMs?: number;
+  readonly flushMaxBatch?: number;
+  readonly setTimeoutFn?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+  readonly clearTimeoutFn?: (timer: ReturnType<typeof setTimeout>) => void;
+}
+
+const DEFAULT_FLUSH_DELAY_MS = 12;
+const DEFAULT_FLUSH_MAX_BATCH = 64;
+
+export class EventPersistence {
+  private readonly flushDelayMs: number;
+  private readonly flushMaxBatch: number;
+  private readonly setTimeoutFn: (
+    callback: () => void,
+    delayMs: number,
+  ) => ReturnType<typeof setTimeout>;
+  private readonly clearTimeoutFn: (timer: ReturnType<typeof setTimeout>) => void;
+  private pendingEvents: NormalizedEventEnvelope[] = [];
+  private flushTimer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(private readonly options: EventPersistenceOptions) {
+    this.flushDelayMs = options.flushDelayMs ?? DEFAULT_FLUSH_DELAY_MS;
+    this.flushMaxBatch = options.flushMaxBatch ?? DEFAULT_FLUSH_MAX_BATCH;
+    this.setTimeoutFn = options.setTimeoutFn ?? setTimeout;
+    this.clearTimeoutFn = options.clearTimeoutFn ?? clearTimeout;
+  }
+
+  pendingCount(): number {
+    return this.pendingEvents.length;
+  }
+
+  enqueue(event: NormalizedEventEnvelope): void {
+    this.pendingEvents.push(event);
+    if (this.pendingEvents.length >= this.flushMaxBatch) {
+      this.flush('immediate');
+      return;
+    }
+    this.scheduleFlush();
+  }
+
+  flush(reason: FlushReason): void {
+    this.clearScheduledFlush();
+    if (this.pendingEvents.length === 0) {
+      return;
+    }
+    const batch = this.pendingEvents;
+    this.pendingEvents = [];
+    const flushSpan = this.options.startPerfSpan('mux.events.flush', {
+      reason,
+      count: batch.length,
+    });
+    try {
+      this.options.appendEvents(batch);
+      flushSpan.end({
+        reason,
+        status: 'ok',
+        count: batch.length,
+      });
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      flushSpan.end({
+        reason,
+        status: 'error',
+        count: batch.length,
+        message,
+      });
+      this.options.writeStderr(`[mux] event-store error ${message}\n`);
+    }
+  }
+
+  private scheduleFlush(): void {
+    if (this.flushTimer !== null) {
+      return;
+    }
+    this.flushTimer = this.setTimeoutFn(() => {
+      this.flushTimer = null;
+      this.flush('timer');
+    }, this.flushDelayMs);
+  }
+
+  private clearScheduledFlush(): void {
+    if (this.flushTimer === null) {
+      return;
+    }
+    this.clearTimeoutFn(this.flushTimer);
+    this.flushTimer = null;
+  }
+}

package/src/services/mux-ui-state-persistence.ts

@@ -0,0 +1,82 @@
+export interface MuxUiStateSnapshot {
+  paneWidthPercent: number;
+  repositoriesCollapsed: boolean;
+  shortcutsCollapsed: boolean;
+}
+
+interface MuxUiStatePersistenceOptions {
+  readonly enabled: boolean;
+  readonly initialState: MuxUiStateSnapshot;
+  readonly debounceMs: number;
+  readonly persistState: (pending: MuxUiStateSnapshot) => MuxUiStateSnapshot;
+  readonly applyState: (state: MuxUiStateSnapshot) => void;
+  readonly writeStderr: (text: string) => void;
+  readonly setTimeoutFn?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+  readonly clearTimeoutFn?: (timer: ReturnType<typeof setTimeout>) => void;
+}
+
+export class MuxUiStatePersistence {
+  private persistedState: MuxUiStateSnapshot;
+  private pendingState: MuxUiStateSnapshot | null = null;
+  private persistTimer: ReturnType<typeof setTimeout> | null = null;
+  private readonly setTimeoutFn: (
+    callback: () => void,
+    delayMs: number,
+  ) => ReturnType<typeof setTimeout>;
+  private readonly clearTimeoutFn: (timer: ReturnType<typeof setTimeout>) => void;
+
+  constructor(private readonly options: MuxUiStatePersistenceOptions) {
+    this.persistedState = options.initialState;
+    this.setTimeoutFn = options.setTimeoutFn ?? setTimeout;
+    this.clearTimeoutFn = options.clearTimeoutFn ?? clearTimeout;
+  }
+
+  queue(nextState: MuxUiStateSnapshot): void {
+    if (!this.options.enabled) {
+      return;
+    }
+    this.pendingState = nextState;
+    if (this.persistTimer !== null) {
+      this.clearTimeoutFn(this.persistTimer);
+    }
+    this.persistTimer = this.setTimeoutFn(() => {
+      this.persistTimer = null;
+      this.persistNow();
+    }, this.options.debounceMs);
+    this.persistTimer.unref?.();
+  }
+
+  persistNow(): void {
+    if (!this.options.enabled) {
+      return;
+    }
+    if (this.persistTimer !== null) {
+      this.clearTimeoutFn(this.persistTimer);
+      this.persistTimer = null;
+    }
+    const pending = this.pendingState;
+    if (pending === null) {
+      return;
+    }
+    this.pendingState = null;
+    if (this.stateEqual(pending, this.persistedState)) {
+      return;
+    }
+    try {
+      const updated = this.options.persistState(pending);
+      this.persistedState = updated;
+      this.options.applyState(updated);
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.options.writeStderr(`[config] unable to persist mux ui state: ${message}\n`);
+    }
+  }
+
+  private stateEqual(left: MuxUiStateSnapshot, right: MuxUiStateSnapshot): boolean {
+    return (
+      left.paneWidthPercent === right.paneWidthPercent &&
+      left.repositoriesCollapsed === right.repositoriesCollapsed &&
+      left.shortcutsCollapsed === right.shortcutsCollapsed
+    );
+  }
+}

package/src/services/output-load-sampler.ts

@@ -0,0 +1,231 @@
+import { monitorEventLoopDelay } from 'node:perf_hooks';
+
+type PerfAttrs = Record<string, boolean | number | string>;
+
+interface EventLoopDelayMonitorLike {
+  enable(): void;
+  disable(): void;
+  reset(): void;
+  percentile(percentile: number): number;
+  readonly max: number;
+}
+
+interface ControlPlaneQueueMetrics {
+  readonly interactiveQueued: number;
+  readonly backgroundQueued: number;
+  readonly running: boolean;
+}
+
+interface OutputLoadPerfStatusRow {
+  readonly fps: number;
+  readonly kbPerSecond: number;
+  readonly renderAvgMs: number;
+  readonly renderMaxMs: number;
+  readonly outputHandleAvgMs: number;
+  readonly outputHandleMaxMs: number;
+  readonly eventLoopP95Ms: number;
+}
+
+interface OutputLoadSamplerOptions {
+  readonly recordPerfEvent: (name: string, attrs: PerfAttrs) => void;
+  readonly getControlPlaneQueueMetrics: () => ControlPlaneQueueMetrics;
+  readonly getActiveConversationId: () => string | null;
+  readonly getPendingPersistedEvents: () => number;
+  readonly onStatusRowChanged: () => void;
+  readonly nowMs?: () => number;
+  readonly sampleIntervalMs?: number;
+  readonly setIntervalFn?: (
+    callback: () => void,
+    delayMs: number,
+  ) => ReturnType<typeof setInterval>;
+  readonly clearIntervalFn?: (timer: ReturnType<typeof setInterval>) => void;
+  readonly createEventLoopDelayMonitor?: () => EventLoopDelayMonitorLike;
+}
+
+const DEFAULT_SAMPLE_INTERVAL_MS = 1000;
+
+function defaultEventLoopDelayMonitor(): EventLoopDelayMonitorLike {
+  return monitorEventLoopDelay({
+    resolution: 20,
+  });
+}
+
+export class OutputLoadSampler {
+  private readonly nowMs: () => number;
+  private readonly sampleIntervalMs: number;
+  private readonly setIntervalFn: (
+    callback: () => void,
+    delayMs: number,
+  ) => ReturnType<typeof setInterval>;
+  private readonly clearIntervalFn: (timer: ReturnType<typeof setInterval>) => void;
+  private readonly eventLoopDelayMonitor: EventLoopDelayMonitorLike;
+  private sampleTimer: ReturnType<typeof setInterval> | null = null;
+  private windowStartedAtMs: number;
+  private outputActiveBytes = 0;
+  private outputInactiveBytes = 0;
+  private outputActiveChunks = 0;
+  private outputInactiveChunks = 0;
+  private outputHandleSampleCount = 0;
+  private outputHandleSampleTotalMs = 0;
+  private outputHandleSampleMaxMs = 0;
+  private renderSampleCount = 0;
+  private renderSampleTotalMs = 0;
+  private renderSampleMaxMs = 0;
+  private renderSampleChangedRows = 0;
+  private readonly outputSessionIds = new Set<string>();
+  private statusRow: OutputLoadPerfStatusRow = {
+    fps: 0,
+    kbPerSecond: 0,
+    renderAvgMs: 0,
+    renderMaxMs: 0,
+    outputHandleAvgMs: 0,
+    outputHandleMaxMs: 0,
+    eventLoopP95Ms: 0,
+  };
+
+  constructor(private readonly options: OutputLoadSamplerOptions) {
+    this.nowMs = options.nowMs ?? Date.now;
+    this.sampleIntervalMs = options.sampleIntervalMs ?? DEFAULT_SAMPLE_INTERVAL_MS;
+    this.setIntervalFn = options.setIntervalFn ?? setInterval;
+    this.clearIntervalFn = options.clearIntervalFn ?? clearInterval;
+    this.eventLoopDelayMonitor =
+      options.createEventLoopDelayMonitor?.() ?? defaultEventLoopDelayMonitor();
+    this.windowStartedAtMs = this.nowMs();
+  }
+
+  currentStatusRow(): OutputLoadPerfStatusRow {
+    return this.statusRow;
+  }
+
+  start(): void {
+    if (this.sampleTimer !== null) {
+      return;
+    }
+    this.eventLoopDelayMonitor.enable();
+    this.sampleTimer = this.setIntervalFn(() => {
+      this.sampleNow();
+    }, this.sampleIntervalMs);
+  }
+
+  stop(): void {
+    if (this.sampleTimer === null) {
+      return;
+    }
+    this.clearIntervalFn(this.sampleTimer);
+    this.sampleTimer = null;
+    this.eventLoopDelayMonitor.disable();
+  }
+
+  recordOutputChunk(sessionId: string, bytes: number, activeConversation: boolean): void {
+    this.outputSessionIds.add(sessionId);
+    if (activeConversation) {
+      this.outputActiveBytes += bytes;
+      this.outputActiveChunks += 1;
+      return;
+    }
+    this.outputInactiveBytes += bytes;
+    this.outputInactiveChunks += 1;
+  }
+
+  recordOutputHandled(durationMs: number): void {
+    this.outputHandleSampleCount += 1;
+    this.outputHandleSampleTotalMs += durationMs;
+    if (durationMs > this.outputHandleSampleMaxMs) {
+      this.outputHandleSampleMaxMs = durationMs;
+    }
+  }
+
+  recordRenderSample(durationMs: number, changedRows: number): void {
+    this.renderSampleCount += 1;
+    this.renderSampleTotalMs += durationMs;
+    if (durationMs > this.renderSampleMaxMs) {
+      this.renderSampleMaxMs = durationMs;
+    }
+    this.renderSampleChangedRows += changedRows;
+  }
+
+  sampleNow(): void {
+    const totalChunks = this.outputActiveChunks + this.outputInactiveChunks;
+    const hasRenderSamples = this.renderSampleCount > 0;
+    const nowMs = this.nowMs();
+    const windowMs = Math.max(1, nowMs - this.windowStartedAtMs);
+    const eventLoopP95Ms = Number(this.eventLoopDelayMonitor.percentile(95)) / 1e6;
+    const eventLoopMaxMs = Number(this.eventLoopDelayMonitor.max) / 1e6;
+    const outputHandleAvgMs =
+      this.outputHandleSampleCount === 0
+        ? 0
+        : this.outputHandleSampleTotalMs / this.outputHandleSampleCount;
+    const renderAvgMs =
+      this.renderSampleCount === 0 ? 0 : this.renderSampleTotalMs / this.renderSampleCount;
+    const nextStatusRow: OutputLoadPerfStatusRow = {
+      fps: Number(((this.renderSampleCount * 1000) / windowMs).toFixed(1)),
+      kbPerSecond: Number(
+        (((this.outputActiveBytes + this.outputInactiveBytes) * 1000) / windowMs / 1024).toFixed(1),
+      ),
+      renderAvgMs: Number(renderAvgMs.toFixed(2)),
+      renderMaxMs: Number(this.renderSampleMaxMs.toFixed(2)),
+      outputHandleAvgMs: Number(outputHandleAvgMs.toFixed(2)),
+      outputHandleMaxMs: Number(this.outputHandleSampleMaxMs.toFixed(2)),
+      eventLoopP95Ms: Number(eventLoopP95Ms.toFixed(1)),
+    };
+    if (!this.statusRowEqual(this.statusRow, nextStatusRow)) {
+      this.statusRow = nextStatusRow;
+      this.options.onStatusRowChanged();
+    }
+    if (totalChunks > 0 || hasRenderSamples) {
+      const controlPlaneQueueMetrics = this.options.getControlPlaneQueueMetrics();
+      this.options.recordPerfEvent('mux.output-load.sample', {
+        windowMs,
+        activeChunks: this.outputActiveChunks,
+        inactiveChunks: this.outputInactiveChunks,
+        activeBytes: this.outputActiveBytes,
+        inactiveBytes: this.outputInactiveBytes,
+        outputHandleCount: this.outputHandleSampleCount,
+        outputHandleAvgMs: Number(outputHandleAvgMs.toFixed(3)),
+        outputHandleMaxMs: Number(this.outputHandleSampleMaxMs.toFixed(3)),
+        renderCount: this.renderSampleCount,
+        renderAvgMs: Number(renderAvgMs.toFixed(3)),
+        renderMaxMs: Number(this.renderSampleMaxMs.toFixed(3)),
+        renderChangedRows: this.renderSampleChangedRows,
+        eventLoopP95Ms: Number(eventLoopP95Ms.toFixed(3)),
+        eventLoopMaxMs: Number(eventLoopMaxMs.toFixed(3)),
+        activeConversationId: this.options.getActiveConversationId() ?? 'none',
+        sessionsWithOutput: this.outputSessionIds.size,
+        pendingPersistedEvents: this.options.getPendingPersistedEvents(),
+        interactiveQueued: controlPlaneQueueMetrics.interactiveQueued,
+        backgroundQueued: controlPlaneQueueMetrics.backgroundQueued,
+        controlPlaneOpRunning: controlPlaneQueueMetrics.running ? 1 : 0,
+      });
+    }
+    this.resetWindow(nowMs);
+  }
+
+  private resetWindow(nowMs: number): void {
+    this.windowStartedAtMs = nowMs;
+    this.outputActiveBytes = 0;
+    this.outputInactiveBytes = 0;
+    this.outputActiveChunks = 0;
+    this.outputInactiveChunks = 0;
+    this.outputHandleSampleCount = 0;
+    this.outputHandleSampleTotalMs = 0;
+    this.outputHandleSampleMaxMs = 0;
+    this.renderSampleCount = 0;
+    this.renderSampleTotalMs = 0;
+    this.renderSampleMaxMs = 0;
+    this.renderSampleChangedRows = 0;
+    this.outputSessionIds.clear();
+    this.eventLoopDelayMonitor.reset();
+  }
+
+  private statusRowEqual(left: OutputLoadPerfStatusRow, right: OutputLoadPerfStatusRow): boolean {
+    return (
+      left.fps === right.fps &&
+      left.kbPerSecond === right.kbPerSecond &&
+      left.renderAvgMs === right.renderAvgMs &&
+      left.renderMaxMs === right.renderMaxMs &&
+      left.outputHandleAvgMs === right.outputHandleAvgMs &&
+      left.outputHandleMaxMs === right.outputHandleMaxMs &&
+      left.eventLoopP95Ms === right.eventLoopP95Ms
+    );
+  }
+}