ompchamber 0.7.0 → 0.8.0

package/src/client/hooks/chat/timeline/session-pagination.ts

@@ -0,0 +1,144 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Older-window pagination for the chamber timeline: pages
+ * `/api/chat/:id?before=` into the head of the message list and keeps the
+ * viewport anchored on the rows the user was reading. Extracted from
+ * useSessionLoad so that hook stays under the repo's per-file size ceiling.
+ */
+
+import type { Dispatch, RefObject, SetStateAction } from 'preact/compat';
+import { useCallback, useLayoutEffect, useRef, useState } from 'preact/hooks';
+import type { ChatMessageData } from '@/shared/types';
+
+export interface UseSessionPaginationDeps {
+  sessionId: string | null;
+  /** Live session id, read when the page response lands: a window fetched for
+   *  the previous session is worse than a dropped page. */
+  sessionIdRef: { current: string | null };
+  setLocalMessages: Dispatch<SetStateAction<ChatMessageData[]>>;
+  /** Scroll container of the timeline: lets loadOlder preserve the viewport
+   *  position when older rows are prepended above it. */
+  scrollRef?: RefObject<HTMLDivElement>;
+}
+
+export interface SessionPagination {
+  hasMore: boolean;
+  loadingOlder: boolean;
+  /** Sticky failure flag for the "Load earlier messages" affordance: a failed
+   *  page fetch must keep the button visible (retryable) instead of silently
+   *  dropping hasMore, which made the button vanish with no feedback. */
+  loadOlderError: boolean;
+  loadOlder: () => void;
+  /** Forget the cursor and the retry flag — a window belongs to one session. */
+  resetPages: () => void;
+  /** Adopt the window metadata a session load returned. */
+  applyWindow: (hasMore: unknown, oldestIndex: unknown) => void;
+}
+
+export function useSessionPagination(deps: UseSessionPaginationDeps): SessionPagination {
+  const { sessionId, sessionIdRef, setLocalMessages, scrollRef } = deps;
+
+  const [hasMore, setHasMore] = useState(false);
+  const [oldestIndex, setOldestIndex] = useState(0);
+  const [loadingOlder, setLoadingOlder] = useState(false);
+  const [loadOlderError, setLoadOlderError] = useState(false);
+  // Bumped on every successful older-window prepend; the scroll-anchor layout
+  // effect keys on it (its other deps have stable identities, so it needs an
+  // explicit change signal per commit).
+  const [prependTick, setPrependTick] = useState(0);
+  const loadingOlderRef = useRef(false);
+  // Set while prepending older rows; the layout effect below re-anchors the
+  // viewport to the content the user was reading instead of jumping.
+  const pendingScrollAnchorRef = useRef<{ prevHeight: number; prevTop: number } | null>(null);
+
+  const resetPages = useCallback(() => {
+    setHasMore(false);
+    setOldestIndex(0);
+    loadingOlderRef.current = false;
+    setLoadingOlder(false);
+    setLoadOlderError(false);
+  }, []);
+
+  const applyWindow = useCallback((hasMoreFromLoad: unknown, oldestIndexFromLoad: unknown) => {
+    if (typeof hasMoreFromLoad === 'boolean') setHasMore(hasMoreFromLoad);
+    if (typeof oldestIndexFromLoad === 'number') setOldestIndex(oldestIndexFromLoad);
+  }, []);
+
+  /** Page the next older window into the timeline. Called from the click
+   *  handler and the scroll handler when the viewport reaches the top; a no-op
+   *  while a page is in flight, when the session has no more history, or while
+   *  the session is a pending optimistic spawn. Prepending older rows only
+   *  grows the list ABOVE the tail, so it is safe while the agent is
+   *  generating — unlike a committed refetch, it never clobbers the AI
+   *  placeholder, and blocking it made the button feel dead mid-run. */
+  const loadOlder = useCallback(() => {
+    if (!sessionId || sessionId.startsWith('new-')) return;
+    if (!hasMore || loadingOlderRef.current) return;
+    loadingOlderRef.current = true;
+    setLoadingOlder(true);
+    setLoadOlderError(false);
+    const el = scrollRef?.current;
+    if (el) pendingScrollAnchorRef.current = { prevHeight: el.scrollHeight, prevTop: el.scrollTop };
+    // Session id snapshot: prepending a window fetched for the PREVIOUS
+    // session into the freshly-switched timeline is worse than dropping the
+    // page, so the response is discarded if the user switched mid-flight.
+    const requestedSessionId = sessionId;
+    fetch(`/api/chat/${sessionId}?before=${oldestIndex}`)
+      .then(res => {
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        return res.json();
+      })
+      .then((data: { session?: { messages?: ChatMessageData[] }; hasMore?: boolean; oldestIndex?: number }) => {
+        // The main load effect may have cleared/repurposed localMessages for a
+        // new session while this fetch was in flight.
+        if (sessionIdRef.current !== requestedSessionId) return;
+        const older = data.session?.messages ?? [];
+        applyWindow(data.hasMore, data.oldestIndex);
+        if (older.length === 0) {
+          // No rows prepended: the recorded anchor is stale — drop it so a
+          // later tick cannot apply it against the wrong geometry.
+          pendingScrollAnchorRef.current = null;
+          return;
+        }
+        setLocalMessages(prev => {
+          // Drop overlap guard: the server window is index-based, so the
+          // fetched slice is strictly older than everything already mounted.
+          return [...older, ...prev];
+        });
+        // Bump the prepend tick so the layout effect below re-runs for THIS
+        // commit — it previously depended only on stable identities and ran
+        // exactly once at mount, so the viewport anchor never fired and every
+        // pagination jump snapped the user to the (shifted) top.
+        setPrependTick(t => t + 1);
+      })
+      .catch(() => {
+        // Keep the button mounted and marked for retry; a swallowed failure
+        // previously also cleared hasMore on the next full reload path.
+        if (sessionIdRef.current === requestedSessionId) setLoadOlderError(true);
+      })
+      .finally(() => {
+        loadingOlderRef.current = false;
+        setLoadingOlder(false);
+      });
+  }, [sessionId, sessionIdRef, hasMore, oldestIndex, scrollRef, setLocalMessages, applyWindow]);
+
+  // Position preservation: after older rows commit above the viewport, shift
+  // scrollTop by the height delta so the rows the user was reading stay put.
+  // prependTick changes on every prepend — without it the effect ran only at
+  // mount (its other deps are stable) and never re-anchored.
+  useLayoutEffect(() => {
+    const anchor = pendingScrollAnchorRef.current;
+    if (!anchor) return;
+    const el = scrollRef?.current;
+    if (!el) return;
+    pendingScrollAnchorRef.current = null;
+    const delta = el.scrollHeight - anchor.prevHeight;
+    if (delta > 0) el.scrollTop = anchor.prevTop + delta;
+  }, [prependTick, scrollRef]);
+
+  return { hasMore, loadingOlder, loadOlderError, loadOlder, resetPages, applyWindow };
+}

package/src/client/hooks/editor/use-code-window.ts

@@ -0,0 +1,118 @@
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'preact/hooks';
+import type { RefObject } from 'preact';
+
+import {
+  codeWindow,
+  firstWindow,
+  resolveWindow,
+  sameWindow,
+  type CodeWindow,
+  type LineGeometry,
+  type LineWindow,
+} from '@/shared/lib/code/lazy-window';
+
+export interface UseCodeWindowOptions {
+  /** The surface's root box: the frame every line offset in `geometry` is measured from. */
+  rootRef: RefObject<HTMLElement | null>;
+  /** Lines in the document on screen. */
+  lineCount: number;
+  /** Document geometry, or null until the wrap/row measurement lands. */
+  geometry: LineGeometry | null;
+  /** False for short documents (they render whole) and when geometry cannot be measured. */
+  enabled: boolean;
+}
+
+/** Nearest ancestor the document scrolls inside, or null when the page itself scrolls. */
+function findScrollContainer(element: HTMLElement): HTMLElement | null {
+  for (let node = element.parentElement; node; node = node.parentElement) {
+    const overflowY = getComputedStyle(node).overflowY;
+    if ((overflowY === 'auto' || overflowY === 'scroll' || overflowY === 'overlay') && node.scrollHeight > node.clientHeight) {
+      return node;
+    }
+  }
+  return null;
+}
+
+/**
+ * The lines visible inside the scroll container `root` lives in.
+ *
+ * Both rectangles are read in viewport coordinates, so this needs no knowledge
+ * of scroll offsets: the part of the editor's box the container actually shows
+ * is exactly the band between the two.
+ */
+function visibleWindow(root: HTMLElement, geometry: LineGeometry): LineWindow {
+  const frameTop = root.getBoundingClientRect().top;
+  const container = findScrollContainer(root);
+  const viewTop = container ? container.getBoundingClientRect().top : 0;
+  const viewBottom = container
+    ? container.getBoundingClientRect().bottom
+    : globalThis.innerHeight || geometry.rowHeight;
+  return resolveWindow(geometry, viewTop - frameTop, viewBottom - viewTop);
+}
+
+/**
+ * Rendering window for the lazy editor surface.
+ *
+ * A long document is highlighted, gutters and all, only where it can be seen;
+ * this hook owns which lines those are and re-resolves them on scroll, on
+ * resize, and whenever the geometry moves (a keystroke re-wraps a line). The
+ * scroll listener is a capturing one on the window: scroll events do not
+ * bubble, but they do reach a capturing listener, so the surface follows
+ * whichever ancestor scrolls — the desktop editor panel, the phone's
+ * full-screen editor, or the page.
+ *
+ * Returns null for a document that renders whole, which is the caller's cue to
+ * keep the plain, unwindowed surface.
+ */
+export function useCodeWindow({ rootRef, lineCount, geometry, enabled }: UseCodeWindowOptions): CodeWindow | null {
+  const [lineWindow, setLineWindow] = useState<LineWindow | null>(null);
+
+  const compute = useCallback(() => {
+    const root = rootRef.current;
+    if (!enabled || !root) return;
+    const next = geometry ? visibleWindow(root, geometry) : firstWindow(lineCount);
+    setLineWindow((previous) => (sameWindow(previous, next) ? previous : next));
+  }, [enabled, geometry, lineCount, rootRef]);
+
+  // Layout effect: the first window has to be resolved before the browser
+  // paints, or a long document flashes its untouched opening lines.
+  useLayoutEffect(() => {
+    compute();
+  }, [compute]);
+
+  // The listeners follow `enabled`, not `compute`: re-resolving on every
+  // keystroke must not tear down and rebuild the observer each time.
+  const computeRef = useRef(compute);
+  computeRef.current = compute;
+  useEffect(() => {
+    if (!enabled) return;
+    let frame = 0;
+    const schedule = () => {
+      if (frame) return;
+      frame = requestAnimationFrame(() => {
+        frame = 0;
+        computeRef.current();
+      });
+    };
+    window.addEventListener('scroll', schedule, { passive: true, capture: true });
+    window.addEventListener('resize', schedule);
+    const observer = typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(schedule);
+    const root = rootRef.current;
+    if (root) observer?.observe(root);
+    return () => {
+      if (frame) cancelAnimationFrame(frame);
+      window.removeEventListener('scroll', schedule, { capture: true });
+      window.removeEventListener('resize', schedule);
+      observer?.disconnect();
+    };
+  }, [enabled, rootRef]);
+
+  if (!enabled) return null;
+  if (!geometry) {
+    // First commit: the layout effect above lands the real window in the same
+    // frame, so this only bounds how much the opening render is allowed to draw.
+    const opening = firstWindow(lineCount);
+    return { ...opening, top: 0, bottom: 0, breakAtEnd: opening.end >= lineCount };
+  }
+  return codeWindow(geometry, lineWindow ?? firstWindow(geometry.lineCount));
+}

package/src/client/hooks/ui/input-required-alert.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * App-wide "an agent is blocked on you" cue.
+ *
+ * It runs off the shared session list rather than the open timeline, which is
+ * the whole point: the agent that needs an answer is usually NOT the session on
+ * screen — you sent a prompt in one workspace and moved to another. The list is
+ * fed by the sidebar loader (which derives `awaitingInput` from the live omp
+ * process registry), so the cue reaches the client even when that process'
+ * session was never opened.
+ */
+
+import { useEffect, useRef } from 'preact/hooks';
+import type { WorkspaceFolderData } from '@/shared/types';
+import { triggerInputRequiredSound } from '@/client/hooks/ui/notification-sound';
+
+export function useInputRequiredAlert(folders: WorkspaceFolderData[]): void {
+  // Null until the first snapshot: a page load must not replay a cue for
+  // questions that were already waiting before it.
+  const knownRef = useRef<Set<string> | null>(null);
+
+  useEffect(() => {
+    const waiting = new Set<string>();
+    for (const folder of folders) {
+      for (const session of folder.sessions ?? []) {
+        if (session.awaitingInput) waiting.add(String(session.id));
+      }
+    }
+
+    const known = knownRef.current;
+    knownRef.current = waiting;
+    if (!known) return;
+    for (const id of waiting) {
+      if (known.has(id)) continue;
+      triggerInputRequiredSound();
+      return;
+    }
+  }, [folders]);
+}

package/src/client/hooks/ui/notification-sound.ts

@@ -72,6 +72,60 @@ export function playNotificationSound() {
   }
 }
 
+/**
+ * Web Audio cue for "the agent is blocked on you" — an ask question or an
+ * approval gate. Deliberately the mirror image of the completion chime: a
+ * triangle wave stepping DOWN (A5 → E5) instead of two sines climbing, so the
+ * two are never mistaken for each other when the tab is in the background.
+ */
+export function playInputRequiredSound() {
+  if (typeof window === 'undefined') return;
+
+  try {
+    const AudioCtx = window.AudioContext || (window as WebkitWindow).webkitAudioContext;
+    if (!AudioCtx) return;
+
+    const ctx = new AudioCtx();
+    if (ctx.state === 'suspended') {
+      ctx.resume();
+    }
+
+    const now = ctx.currentTime;
+    const notes = [
+      { at: 0, frequency: 880, duration: 0.18, peak: 0.11 },
+      { at: 0.16, frequency: 659.25, duration: 0.46, peak: 0.13 },
+    ];
+
+    for (const note of notes) {
+      const osc = ctx.createOscillator();
+      const gain = ctx.createGain();
+
+      osc.type = 'triangle';
+      osc.frequency.setValueAtTime(note.frequency, now + note.at);
+
+      gain.gain.setValueAtTime(0, now + note.at);
+      gain.gain.linearRampToValueAtTime(note.peak, now + note.at + 0.015);
+      gain.gain.exponentialRampToValueAtTime(0.0001, now + note.at + note.duration);
+
+      osc.connect(gain);
+      gain.connect(ctx.destination);
+
+      osc.start(now + note.at);
+      osc.stop(now + note.at + note.duration);
+    }
+
+    setTimeout(() => {
+      try {
+        ctx.close();
+      } catch {
+        // Safe to ignore
+      }
+    }, 800);
+  } catch (err) {
+    console.warn('Unable to play input-required audio cue:', err);
+  }
+}
+
 /**
  * Checks whether chat completion sound is enabled in user preferences.
  */
@@ -91,6 +145,17 @@ export function triggerChatCompletionSound(appSettings?: Record<string, any>) {
   }
 }
 
+/**
+ * Triggers the input-required cue, gated by the same notification preference as
+ * the completion chime. Reads settings from the primed snapshot: the alert fires
+ * from the app-wide session list, which has no settings props to thread.
+ */
+export function triggerInputRequiredSound() {
+  if (isChatSoundEnabled()) {
+    playInputRequiredSound();
+  }
+}
+
 export function useNotificationSound() {
   const play = useCallback(() => {
     playNotificationSound();

package/src/client/hooks/ui/theme.ts

@@ -1,6 +1,25 @@
 import { useCallback, useEffect, useState } from 'preact/hooks';
 import { useChamberSettingsWriter } from '@/client/hooks/settings/use-chamber-setting';
 
+/** Broadcast on every theme write. Detail is the new theme id; the
+ *  `data-theme` attribute on `<html>` is the durable copy of the same fact. */
+export const THEME_CHANGED_EVENT = 'omp:theme-changed';
+
+/**
+ * Point the document at `theme` and announce it.
+ *
+ * The single writer path for the theme: the navbar toggle and the settings
+ * modal both call this, because a writer that only sets `data-theme` leaves
+ * runtime consumers (the mermaid hydrator re-renders diagrams per theme) on the
+ * previous palette until the next reload. CSS reads the attribute; listeners
+ * watch the attribute too, so this stays correct even if the event is missed.
+ */
+export function applyDocumentTheme(theme: string): void {
+  if (typeof document === 'undefined') return;
+  document.documentElement.dataset.theme = theme;
+  window.dispatchEvent(new CustomEvent(THEME_CHANGED_EVENT, { detail: theme }));
+}
+
 export function useTheme() {
   const writeChamberSettings = useChamberSettingsWriter();
   const [theme, setThemeState] = useState<string>(() => {
@@ -60,12 +79,9 @@ export function useTheme() {
   }, []);
 
   const setTheme = useCallback((newTheme: string) => {
-    if (typeof document !== 'undefined') {
-      document.documentElement.dataset.theme = newTheme;
-      setThemeState(newTheme);
-      writeChamberSettings({ theme: newTheme });
-      window.dispatchEvent(new CustomEvent('omp:theme-changed', { detail: newTheme }));
-    }
+    applyDocumentTheme(newTheme);
+    setThemeState(newTheme);
+    writeChamberSettings({ theme: newTheme });
   }, [writeChamberSettings]);
 
   const toggleTheme = useCallback(() => {

package/src/client/tailwind.css

@@ -318,6 +318,11 @@
   border-radius: 0.5rem;
   background: var(--theme-paper);
   padding: 0.75rem;
+  /* `applySvg` swaps the `.code-block` shell (the positioned ancestor the copy
+     button relied on) for the SVG, so the block owns the anchor itself. */
+  position: relative;
+  /* The block is the door into the zoom/pan viewer. */
+  cursor: zoom-in;
 }
 .prose-content .mermaid-block > svg {
   display: block;
@@ -332,6 +337,27 @@
   color: var(--theme-error);
 }
 
+/* Full-screen mermaid viewer (`common/diagram-viewer/`): a chart opened from
+   the timeline. The stage is the fixed-size pan surface, the canvas child
+   carries the zoom/pan transform, so the SVG keeps its natural pixel size and
+   `100%` on it always means "the size mermaid rendered". */
+.diagram-viewer-stage {
+  touch-action: none;
+  overscroll-behavior: contain;
+}
+.diagram-viewer-canvas {
+  transform-origin: center center;
+  will-change: transform;
+  background: var(--theme-paper);
+  box-shadow: 0 25px 50px -12px color-mix(in srgb, var(--theme-ink) 45%, transparent);
+}
+.diagram-viewer-canvas > svg {
+  display: block;
+  width: 100% !important;
+  height: 100% !important;
+  max-width: none !important;
+}
+
 /* PWA Window Controls Overlay and Native Titlebar Styling */
 .titlebar-drag-region {
   -webkit-app-region: drag;
@@ -344,31 +370,31 @@
 }
 
 
-/* Ask-dialog enter animation — replaces the retired `motion` dependency.
-   Exit is intentionally instant: a 160ms fade-out on a blocking modal is not
-   load-bearing, and keeping the element mounted to animate it out would add
-   state the dialog does not otherwise need. */
-@keyframes ask-dialog-backdrop-in {
+/* Blocking extension-dialog enter animation — replaces the retired `motion`
+   dependency. Exit is intentionally instant: a 160ms fade-out on a blocking
+   modal is not load-bearing, and keeping the element mounted to animate it out
+   would add state the dialog does not otherwise need. */
+@keyframes extension-dialog-backdrop-in {
   from { opacity: 0; }
   to { opacity: 1; }
 }
 
-@keyframes ask-dialog-panel-in {
+@keyframes extension-dialog-panel-in {
   from { opacity: 0; transform: translateY(10px) scale(0.95); }
   to { opacity: 1; transform: none; }
 }
 
-.ask-dialog-backdrop {
-  animation: ask-dialog-backdrop-in 150ms ease-out;
+.extension-dialog-backdrop {
+  animation: extension-dialog-backdrop-in 150ms ease-out;
 }
 
-.ask-dialog-panel {
-  animation: ask-dialog-panel-in 180ms ease-out;
+.extension-dialog-panel {
+  animation: extension-dialog-panel-in 180ms ease-out;
 }
 
 @media (prefers-reduced-motion: reduce) {
-  .ask-dialog-backdrop,
-  .ask-dialog-panel {
+  .extension-dialog-backdrop,
+  .extension-dialog-panel {
     animation: none;
   }
 }

package/src/server/lib/omp/rpc/manager.ts

@@ -102,10 +102,21 @@ export class AgentSessionWrapper {
   }
 
   /** Anything in flight that a process reset would destroy: the current turn,
-   *  a compaction, a shell command, or live subagents — which outlive the turn
-   *  that spawned them, so no other flag here can see them. */
+   *  a compaction, a shell command, live subagents — which outlive the turn that
+   *  spawned them, so no other flag here can see them — or an ask/approval dialog
+   *  omp is BLOCKED on.
+   *
+   *  The dialogs are the load-bearing entry: an ask parks the tool call for as
+   *  long as the user takes to answer, and omp answers RPC handlers one at a
+   *  time, so every probe (`get_state`) queues behind it and times out. Without
+   *  this the timeout path read the session as "idle and unresponsive", killed
+   *  the child, and with it the question the user was still reading. */
   isBusy(): boolean {
-    return this.isRunning() || this.subagents.liveCount(Date.now(), SUBAGENT_STALE_MS) > 0;
+    return (
+      this.isRunning() ||
+      this.pendingUiDialogs.list().length > 0 ||
+      this.subagents.liveCount(Date.now(), SUBAGENT_STALE_MS) > 0
+    );
   }
 
   start(): void {

package/src/server/lib/omp/rpc/session-registry.ts

@@ -72,6 +72,24 @@ export function getRunningRpcSessionIds(): string[] {
   return getRunningRpcSessions().map((s) => s.id);
 }
 
+/**
+ * Sessions whose omp process is parked on a dialog only the user can release —
+ * an `ask` question or an approval gate. Deliberately independent of
+ * `isRunning()`: a blocked dialog leaves every turn flag exactly as it was, so
+ * the pending-dialog registry is the only thing that can tell a session waiting
+ * for an answer from an idle one. Feeds the sidebar's "needs input" badge, which
+ * has to reach clients that never opened the session.
+ */
+export function getAwaitingInputSessionIds(): string[] {
+  const ids = new Set<string>();
+  for (const [sessionId, session] of getRegistry()) {
+    if (session.isAlive() && session.getPendingUiDialogs().length > 0) {
+      ids.add(session.sessionId || sessionId);
+    }
+  }
+  return [...ids];
+}
+
 function getRunningListeners(): Set<(update: RunningSessionUpdate) => void> {
   if (!globalThis.__ompRunningListeners) globalThis.__ompRunningListeners = new Set();
   return globalThis.__ompRunningListeners;

package/src/server/lib/omp/session/sidebar-data.server.ts

@@ -22,7 +22,7 @@ import { isValidSessionSortOption, sortFolders } from '@/shared/lib/workspace/si
 import { loadOmpSidebarData } from '@/server/lib/omp/session/reader';
 import { sessionHasSubagents } from '@/server/lib/omp/session/subagent-presence';
 import { healStaleStreamStatuses, loadStreamStatuses } from '@/shared/lib/omp/session/stream-state.server';
-import { getRunningRpcSessionIds } from '@/server/lib/omp/rpc/session-registry';
+import { getAwaitingInputSessionIds, getRunningRpcSessionIds } from '@/server/lib/omp/rpc/session-registry';
 import type { SessionItemData, SessionSortOption, WorkspaceFolderData } from '@/shared/types';
 import type { OmpSession } from '@/shared/types/omp/session';
 
@@ -115,15 +115,21 @@ export async function loadSidebarData(): Promise<SessionListPayload> {
   // `finish` right here — the authoritative status travels with the same
   // fetch that refreshes the sidebar list.
   const streamStatuses: Record<string, 'stream' | 'finish' | 'abort' | 'error'> = {};
+  // Sessions blocked on a dialog nobody has answered yet. Read live from the
+  // process registry (never persisted): the child that owns the question is the
+  // same thing that owns the flag, so a restart cannot leave a stale badge.
+  const awaitingInput = new Set<string>();
   if (!mock) {
     await healStaleStreamStatuses(new Set(getRunningRpcSessionIds()));
     Object.assign(streamStatuses, await loadStreamStatuses());
+    for (const id of getAwaitingInputSessionIds()) awaitingInput.add(id);
   }
   const foldersWithStatus = groupedFolders.map((folder) => ({
     ...folder,
     sessions: (folder.sessions ?? []).map((s) => ({
       ...s,
       streamStatus: streamStatuses[String(s.id)],
+      ...(awaitingInput.has(String(s.id)) ? { awaitingInput: true } : {}),
     })),
   }));