@schlessera/brain-ui-react 0.34.0 → 0.35.0

package/src/stores/activity-store-types.ts

@@ -0,0 +1,55 @@
+import type {
+  ActivitySpan,
+  ActivitySpanEvent,
+  ServerActivityDelta,
+  ServerActivitySnapshot,
+} from "@schlessera/brain-ui-sdk/protocol";
+import type { ActivityIntent } from "../lib/api-client.js";
+
+export interface ActivityState {
+  /** server_hello said this host records activity. */
+  supported: boolean;
+  /** Session ids this connection has an activity subscription for. */
+  subscribed: Record<string, true>;
+  /** Bumped on every new connection so subscribe effects re-send. */
+  connectionEpoch: number;
+  /** Live span state per run, keyed runId -> spanId. */
+  spans: Record<string, Record<string, ActivitySpan>>;
+  /** Ordered events per span (already sorted by eventIndex). */
+  events: Record<string, ActivitySpanEvent[]>;
+  /** Per-run high-water seq from the snapshot; deltas at or below drop. */
+  highWater: Record<string, number>;
+  /**
+   * Newest APPLIED delta seq per run. Kept apart from `highWater` on
+   * purpose: the snapshot staleness guard compares against the max of both
+   * (a snapshot older than an applied delta must not roll it back), while
+   * the delta gate keeps comparing against the snapshot floor alone so
+   * out-of-order delta delivery stays tolerated (insert-if-absent absorbs it).
+   */
+  deltaSeq: Record<string, number>;
+  /** spanId -> runId reverse index, for timing lookups by toolUseId. */
+  spanRun: Record<string, string>;
+
+  /** Unacknowledged notification intents — the guaranteed-tier inbox. */
+  inbox: ActivityIntent[];
+  loadInbox: () => Promise<void>;
+  acknowledgeIntent: (id: number) => Promise<void>;
+  acknowledgeAllIntents: () => Promise<void>;
+  setSupported: (supported: boolean) => void;
+  /** New connection: server-side subscriptions are gone; re-subscribe lazily. */
+  resetSubscriptions: () => void;
+  bumpConnectionEpoch: () => void;
+  markSubscribed: (sessionId: string) => void;
+  applySnapshot: (msg: ServerActivitySnapshot) => void;
+  applyDelta: (msg: ServerActivityDelta) => void;
+  clear: () => void;
+}
+
+/** The five indexes that make up the mirror, mutated together during merges. */
+export interface MirrorMaps {
+  spans: Record<string, Record<string, ActivitySpan>>;
+  events: Record<string, ActivitySpanEvent[]>;
+  highWater: Record<string, number>;
+  deltaSeq: Record<string, number>;
+  spanRun: Record<string, string>;
+}

package/src/stores/activity-store.ts

@@ -1,19 +1,30 @@
 import { create } from "zustand";
-import type {
-  ActivitySpan,
-  ActivitySpanEvent,
-  ServerActivityDelta,
-  ServerActivitySnapshot,
-} from "@schlessera/brain-ui-sdk/protocol";
-import { api, type ActivityIntent } from "../lib/api-client.js";
+import { api } from "../lib/api-client.js";
 import { registerDevHandle } from "../config.js";
+import type { ActivityState, MirrorMaps } from "./activity-store-types.js";
+import {
+  evictRun,
+  insertEvent,
+  pruneTerminalRuns,
+  rootSpanOf,
+} from "./activity-store-helpers.js";
+
+export {
+  EMPTY_EVENTS,
+  childSpans,
+  eventsFor,
+  narrativeEventsFor,
+  payloadEventsFor,
+  runEvents,
+  runSpans,
+  spanForTool,
+  subagentSpans,
+  timingFor,
+} from "./activity-store-helpers.js";
 
 /** How many finished runs' details are fetched when a session opens. */
 const HISTORY_RUN_LIMIT = 10;
 
-/** Bound on the mirror: how many TERMINAL runs stay held. Live runs never count. */
-const MAX_TERMINAL_RUNS = 50;
-
 /**
  * Client mirror of the server's activity record, fed by the snapshot-then-
  * delta stream. The server computes; this store only holds and indexes what
@@ -34,45 +45,6 @@ const MAX_TERMINAL_RUNS = 50;
  * evicted wholesale (spans, events, high-water, reverse index). Live runs
  * are never evicted; evicted history remains fetchable over REST.
  */
-interface ActivityState {
-  /** server_hello said this host records activity. */
-  supported: boolean;
-  /** Session ids this connection has an activity subscription for. */
-  subscribed: Record<string, true>;
-  /** Bumped on every new connection so subscribe effects re-send. */
-  connectionEpoch: number;
-  /** Live span state per run, keyed runId -> spanId. */
-  spans: Record<string, Record<string, ActivitySpan>>;
-  /** Ordered events per span (already sorted by eventIndex). */
-  events: Record<string, ActivitySpanEvent[]>;
-  /** Per-run high-water seq from the snapshot; deltas at or below drop. */
-  highWater: Record<string, number>;
-  /**
-   * Newest APPLIED delta seq per run. Kept apart from `highWater` on
-   * purpose: the snapshot staleness guard compares against the max of both
-   * (a snapshot older than an applied delta must not roll it back), while
-   * the delta gate keeps comparing against the snapshot floor alone so
-   * out-of-order delta delivery stays tolerated (insert-if-absent absorbs it).
-   */
-  deltaSeq: Record<string, number>;
-  /** spanId -> runId reverse index, for timing lookups by toolUseId. */
-  spanRun: Record<string, string>;
-
-  /** Unacknowledged notification intents — the guaranteed-tier inbox. */
-  inbox: ActivityIntent[];
-  loadInbox: () => Promise<void>;
-  acknowledgeIntent: (id: number) => Promise<void>;
-  acknowledgeAllIntents: () => Promise<void>;
-  setSupported: (supported: boolean) => void;
-  /** New connection: server-side subscriptions are gone; re-subscribe lazily. */
-  resetSubscriptions: () => void;
-  bumpConnectionEpoch: () => void;
-  markSubscribed: (sessionId: string) => void;
-  applySnapshot: (msg: ServerActivitySnapshot) => void;
-  applyDelta: (msg: ServerActivityDelta) => void;
-  clear: () => void;
-}
-
 export const useActivityStore = create<ActivityState>((set, get) => ({
   supported: false,
   subscribed: {},
@@ -309,174 +281,6 @@ export async function loadSpanPayloads(spanId: string): Promise<void> {
   }
 }
 
-/** The four indexes that make up the mirror, mutated together during merges. */
-interface MirrorMaps {
-  spans: Record<string, Record<string, ActivitySpan>>;
-  events: Record<string, ActivitySpanEvent[]>;
-  highWater: Record<string, number>;
-  deltaSeq: Record<string, number>;
-  spanRun: Record<string, string>;
-}
-
-function rootSpanOf(byId: Record<string, ActivitySpan>): ActivitySpan | undefined {
-  return Object.values(byId).find((span) => span.parentSpanId === undefined);
-}
-
-/** Drop a whole run from the mirror — spans, events, high-water, reverse index. */
-function evictRun(maps: MirrorMaps, runId: string): void {
-  for (const spanId of Object.keys(maps.spans[runId] ?? {})) {
-    delete maps.events[spanId];
-    delete maps.spanRun[spanId];
-  }
-  delete maps.spans[runId];
-  delete maps.highWater[runId];
-  delete maps.deltaSeq[runId];
-}
-
-/**
- * Enforce the terminal-run bound in place. Returns whether anything was
- * evicted. Runs whose root span is still open (or unknown) are never touched.
- */
-function pruneTerminalRuns(maps: MirrorMaps): boolean {
-  const terminal: Array<{ runId: string; startedAt: number }> = [];
-  for (const [runId, byId] of Object.entries(maps.spans)) {
-    const root = rootSpanOf(byId);
-    if (root && root.outcome !== undefined) {
-      terminal.push({ runId, startedAt: root.startedAt });
-    }
-  }
-  if (terminal.length <= MAX_TERMINAL_RUNS) return false;
-  terminal.sort((a, b) => a.startedAt - b.startedAt);
-  for (const { runId } of terminal.slice(0, terminal.length - MAX_TERMINAL_RUNS)) {
-    evictRun(maps, runId);
-  }
-  return true;
-}
-
-function insertEvent(
-  list: ActivitySpanEvent[] | undefined,
-  event: ActivitySpanEvent
-): ActivitySpanEvent[] {
-  const existing = list ?? [];
-  if (existing.some((e) => e.eventIndex === event.eventIndex)) return existing;
-  const next = [...existing, event];
-  next.sort((a, b) => a.eventIndex - b.eventIndex);
-  return next;
-}
-
-// --- Selectors (plain functions over the state, like activeChat) ---
-
-/** All spans of a run, roots first, then by start time. */
-export function runSpans(state: ActivityState, runId: string): ActivitySpan[] {
-  const byId = state.spans[runId];
-  if (!byId) return [];
-  return Object.values(byId).sort(
-    (a, b) =>
-      (a.parentSpanId ? 1 : 0) - (b.parentSpanId ? 1 : 0) || a.startedAt - b.startedAt
-  );
-}
-
-/** Direct children of a span (e.g. the tool calls inside a subagent). */
-export function childSpans(state: ActivityState, parentSpanId: string): ActivitySpan[] {
-  const runId = state.spanRun[parentSpanId];
-  if (!runId) return [];
-  return Object.values(state.spans[runId] ?? {})
-    .filter((s) => s.parentSpanId === parentSpanId)
-    .sort((a, b) => a.startedAt - b.startedAt);
-}
-
-/** The subagent spans spawned by a turn's Agent tool calls, live status included. */
-export function subagentSpans(state: ActivityState, sessionId: string): ActivitySpan[] {
-  const out: ActivitySpan[] = [];
-  for (const byId of Object.values(state.spans)) {
-    for (const span of Object.values(byId)) {
-      if (span.kind === "subagent" && span.sessionId === sessionId) out.push(span);
-    }
-  }
-  return out.sort((a, b) => a.startedAt - b.startedAt);
-}
-
-/** Stable empty result for `eventsFor` — a fresh `[]` per call would defeat
- *  reference-equality checks in zustand selectors. */
-export const EMPTY_EVENTS: ActivitySpanEvent[] = Object.freeze(
-  [] as ActivitySpanEvent[]
-) as ActivitySpanEvent[];
-
-/** Ordered events of a span; the shared frozen empty array when none. */
-export function eventsFor(state: ActivityState, spanId: string): ActivitySpanEvent[] {
-  return state.events[spanId] ?? EMPTY_EVENTS;
-}
-
-/** Payload event types the tool expander owns — every OTHER type belongs to
- *  the narrative stream (`narrativeEventsFor`) so nothing recorded is
- *  rendered nowhere. */
-const TOOL_PAYLOAD_TYPES = new Set(["tool_input", "tool_output"]);
-
-/**
- * The recorded input/output payload events of a tool span (AE7). Returns a
- * fresh array per call — subscribe through `useShallow` (like `childSpans`).
- */
-export function payloadEventsFor(state: ActivityState, spanId: string): ActivitySpanEvent[] {
-  const events = state.events[spanId];
-  if (!events) return EMPTY_EVENTS;
-  const payloads = events.filter((e) => TOOL_PAYLOAD_TYPES.has(e.eventType));
-  return payloads.length > 0 ? payloads : EMPTY_EVENTS;
-}
-
-/**
- * Everything recorded against a span that is NOT a tool input/output payload:
- * transcript excerpts, job output, and any span-sink event type a producer
- * invents. Rendered as the span's narrative so an unknown type degrades to a
- * labelled block rather than to invisibility.
- */
-export function narrativeEventsFor(
-  state: ActivityState,
-  spanId: string
-): ActivitySpanEvent[] {
-  const events = state.events[spanId];
-  if (!events) return EMPTY_EVENTS;
-  const rest = events.filter((e) => !TOOL_PAYLOAD_TYPES.has(e.eventType));
-  return rest.length > 0 ? rest : EMPTY_EVENTS;
-}
-
-/** Every event recorded under a run, ordered by time — the run detail's
- *  narrative stream and the raw-trace dump both read through this. */
-export function runEvents(state: ActivityState, runId: string): ActivitySpanEvent[] {
-  const byId = state.spans[runId];
-  if (!byId) return EMPTY_EVENTS;
-  const out: ActivitySpanEvent[] = [];
-  for (const spanId of Object.keys(byId)) {
-    const events = state.events[spanId];
-    if (events) out.push(...events);
-  }
-  if (out.length === 0) return EMPTY_EVENTS;
-  return out.sort((a, b) => a.ts - b.ts || a.eventIndex - b.eventIndex);
-}
-
-/** The span behind one tool call (span ids ARE toolUseIds), if streamed. */
-export function spanForTool(state: ActivityState, toolUseId: string): ActivitySpan | null {
-  const runId = state.spanRun[toolUseId];
-  return runId ? (state.spans[runId]?.[toolUseId] ?? null) : null;
-}
-
-/**
- * Server-stamped timing for a tool call. One clock for live and reloaded
- * views: when the activity stream carries the span, its timestamps win over
- * client stamps (AE2 — live and revisit must render identical timings).
- * `waitUntil` marks the approval-wait/execution boundary.
- */
-export function timingFor(
-  state: ActivityState,
-  toolUseId: string
-): { startedAt: number; endedAt?: number } | null {
-  const span = spanForTool(state, toolUseId);
-  if (!span) return null;
-  return {
-    startedAt: span.waitUntil ?? span.startedAt,
-    ...(span.endedAt !== undefined ? { endedAt: span.endedAt } : {}),
-  };
-}
-
 registerDevHandle(() => {
   if (typeof window === "undefined") return;
   (window as unknown as { __activityStore?: typeof useActivityStore }).__activityStore =

package/src/stores/connection-store.ts

@@ -1,7 +1,7 @@
 import { create } from "zustand";
 
-type WsStatus = "connecting" | "connected" | "disconnected";
-type VpnStatus =
+export type WsStatus = "connecting" | "connected" | "disconnected";
+export type VpnStatus =
   | "connected"
   | "forbidden"
   | "unauthorized"
@@ -27,9 +27,21 @@ export interface ConnectionError {
 interface ConnectionState {
   wsStatus: WsStatus;
   vpnStatus: VpnStatus;
+  handshakeFailures: number;
+  lastCloseCode: number | null;
+  /**
+   * Monotonic count of sockets that reached `open`. A probe started before a
+   * socket opened compares this to decide whether its answer is still the
+   * newest evidence — comparing wsStatus twice cannot see a drop and a
+   * replacement open that both land inside one probe.
+   */
+  socketOpens: number;
   lastError: ConnectionError | null;
   setWsStatus: (status: WsStatus) => void;
   setVpnStatus: (status: VpnStatus) => void;
+  recordWsClose: (opened: boolean, code: number) => void;
+  /** A socket reached `open`: the refusal evidence so far is spent. */
+  noteSocketOpen: () => void;
   reportError: (code: string, message: string) => void;
   clearError: () => void;
 }
@@ -37,9 +49,28 @@ interface ConnectionState {
 export const useConnectionStore = create<ConnectionState>((set) => ({
   wsStatus: "disconnected",
   vpnStatus: "checking",
+  handshakeFailures: 0,
+  lastCloseCode: null,
+  socketOpens: 0,
   lastError: null,
   setWsStatus: (wsStatus) => set({ wsStatus }),
   setVpnStatus: (vpnStatus) => set({ vpnStatus }),
+  recordWsClose: (opened, lastCloseCode) =>
+    set((state) => ({
+      lastCloseCode,
+      handshakeFailures: opened
+        ? state.handshakeFailures
+        : state.handshakeFailures + 1,
+    })),
+  noteSocketOpen: () =>
+    set((state) => ({
+      handshakeFailures: 0,
+      // Cleared here, not on the next close: the server accepts the upgrade and
+      // THEN closes with 4008 when it is at its connection cap, so the code
+      // must survive an open to be read, and must not outlive the next one.
+      lastCloseCode: null,
+      socketOpens: state.socketOpens + 1,
+    })),
   reportError: (code, message) => set({ lastError: { code, message, at: Date.now() } }),
   clearError: () => set({ lastError: null }),
 }));

package/src/stores/file-store.ts

@@ -86,8 +86,8 @@ async function fetchTree(path: string): Promise<FileEntry[]> {
   return data.entries;
 }
 
-async function fetchContent(path: string): Promise<FileContentResponse> {
-  const res = await fetch(`${apiBase()}/files/content?path=${encodeURIComponent(path)}`);
+async function fetchContent(path: string, signal: AbortSignal): Promise<FileContentResponse> {
+  const res = await fetch(`${apiBase()}/files/content?path=${encodeURIComponent(path)}`, { signal });
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: res.statusText }));
     const err = new Error(body.error || `HTTP ${res.status}`);
@@ -98,8 +98,8 @@ async function fetchContent(path: string): Promise<FileContentResponse> {
   return res.json();
 }
 
-async function fetchResolve(path: string): Promise<FileResolveResponse> {
-  const res = await fetch(`${apiBase()}/files/resolve?path=${encodeURIComponent(path)}`);
+async function fetchResolve(path: string, signal: AbortSignal): Promise<FileResolveResponse> {
+  const res = await fetch(`${apiBase()}/files/resolve?path=${encodeURIComponent(path)}`, { signal });
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: res.statusText }));
     throw new Error(body.error || `HTTP ${res.status}`);
@@ -116,6 +116,10 @@ async function fetchWikilinks(): Promise<WikilinkMapResponse> {
   return res.json();
 }
 
+let fileRequest: AbortController | null = null;
+let directoryRequest: AbortController | null = null;
+let cacheEpoch = 0;
+
 export const useFileStore = create<FileState>((set, get) => ({
   dirCache: {},
   loadingDirs: new Set(),
@@ -135,6 +139,7 @@ export const useFileStore = create<FileState>((set, get) => ({
   wikilinkLoading: false,
 
   loadDir: async (path) => {
+    const epoch = cacheEpoch;
     const { dirCache, loadingDirs } = get();
     if (dirCache[path] || loadingDirs.has(path)) return;
     const next = new Set(loadingDirs);
@@ -142,6 +147,7 @@ export const useFileStore = create<FileState>((set, get) => ({
     set({ loadingDirs: next });
     try {
       const entries = await fetchTree(path);
+      if (epoch !== cacheEpoch) return;
       set((s) => {
         const loading = new Set(s.loadingDirs);
         loading.delete(path);
@@ -154,6 +160,7 @@ export const useFileStore = create<FileState>((set, get) => ({
         };
       });
     } catch (err) {
+      if (epoch !== cacheEpoch) return;
       set((s) => {
         const loading = new Set(s.loadingDirs);
         loading.delete(path);
@@ -189,13 +196,19 @@ export const useFileStore = create<FileState>((set, get) => ({
   },
 
   openFile: async (path) => {
+    fileRequest?.abort();
+    directoryRequest?.abort();
+    const request = new AbortController();
+    fileRequest = request;
+    const ownsRequest = () => fileRequest === request && !request.signal.aborted;
     const normalized = path.replace(/^\/+/, "").replace(/\\/g, "/");
     set({ currentPath: normalized, contentLoading: true, contentError: null, currentContent: null, treeExpanded: false });
 
     // Fire-and-await: load ancestor chain then content in parallel
     const ancestorsPromise = (async () => {
       try {
-        const r = await fetchResolve(normalized);
+        const r = await fetchResolve(normalized, request.signal);
+        if (!ownsRequest()) return;
         // Expand each ancestor and root, load their contents
         const dirsToLoad = ["", ...r.ancestors];
         set((s) => {
@@ -210,12 +223,12 @@ export const useFileStore = create<FileState>((set, get) => ({
     })();
 
     try {
-      const content = await fetchContent(normalized);
+      const content = await fetchContent(normalized, request.signal);
       // Drop a response the user has already navigated away from. Two rapid
       // clicks race, and without this the SLOWER fetch wins: the viewer showed
       // the newer file's path with the older file's content, which reads as
       // corruption rather than as a stale load.
-      if (get().currentPath !== normalized) return;
+      if (!ownsRequest()) return;
       set({ currentContent: content, contentLoading: false });
       // Default mode: prefer preview when available; persist otherwise
       const { viewMode } = get();
@@ -233,7 +246,7 @@ export const useFileStore = create<FileState>((set, get) => ({
       else if (e.message === "invalid_path") msg = "Invalid path.";
       // Same guard: a failure for a file the user already left must not
       // replace the file they are now looking at with an error.
-      if (get().currentPath !== normalized) return;
+      if (!ownsRequest()) return;
       set({ contentError: msg, contentLoading: false });
     } finally {
       await ancestorsPromise;
@@ -241,10 +254,15 @@ export const useFileStore = create<FileState>((set, get) => ({
   },
 
   closeFile: () => {
-    set({ currentPath: null, currentContent: null, contentError: null, treeExpanded: true });
+    fileRequest?.abort();
+    fileRequest = null;
+    set({ currentPath: null, currentContent: null, contentError: null, contentLoading: false, treeExpanded: true });
   },
 
   openDir: async (path) => {
+    directoryRequest?.abort();
+    const request = new AbortController();
+    directoryRequest = request;
     const normalized = path
       .replace(/^\/+/, "")
       .replace(/\\/g, "/")
@@ -258,7 +276,8 @@ export const useFileStore = create<FileState>((set, get) => ({
     set({ treeExpanded: true, highlightedDir: normalized });
 
     try {
-      const r = await fetchResolve(normalized);
+      const r = await fetchResolve(normalized, request.signal);
+      if (directoryRequest !== request || request.signal.aborted) return;
       const dirs = ["", ...r.ancestors, normalized];
       set((s) => {
         const next = new Set(s.expandedDirs);
@@ -278,11 +297,13 @@ export const useFileStore = create<FileState>((set, get) => ({
   setHighlightedDir: (path) => set({ highlightedDir: path }),
 
   ensureWikilinks: async () => {
+    const epoch = cacheEpoch;
     const { wikilinkLoaded, wikilinkLoading } = get();
     if (wikilinkLoaded || wikilinkLoading) return;
     set({ wikilinkLoading: true });
     try {
       const data = await fetchWikilinks();
+      if (epoch !== cacheEpoch) return;
       set({
         wikilinkMap: data.slugs,
         wikilinkLoaded: true,
@@ -290,6 +311,7 @@ export const useFileStore = create<FileState>((set, get) => ({
       });
     } catch {
       // Soft-fail — leave the map empty; wikilinks will render as plain text
+      if (epoch !== cacheEpoch) return;
       set({ wikilinkLoading: false });
     }
   },
@@ -304,15 +326,23 @@ export const useFileStore = create<FileState>((set, get) => ({
       return { frontmatterCollapsed: next };
     }),
 
-  reset: () =>
+  reset: () => {
+    fileRequest?.abort();
+    directoryRequest?.abort();
+    fileRequest = null;
+    directoryRequest = null;
+    cacheEpoch++;
     set({
+      dirCache: {}, loadingDirs: new Set(), dirErrors: {}, expandedDirs: new Set([""]),
+      highlightedDir: null, wikilinkMap: {}, wikilinkLoaded: false, wikilinkLoading: false,
       currentPath: null,
       currentContent: null,
       contentLoading: false,
       contentError: null,
       viewMode: "preview",
       treeExpanded: true,
-    }),
+    });
+  },
 }));
 
 /**

package/src/stores/principal-store.ts

@@ -0,0 +1,38 @@
+import { create } from "zustand";
+import { api, type MintedAgent } from "../lib/api-client.js";
+
+interface PrincipalState {
+  mintPending: boolean;
+  mintError: string | null;
+  oneTimeCredential: MintedAgent | null;
+  mintAgent: (label: string, ttlDays: number) => Promise<void>;
+  acknowledgeAgentCredential: () => void;
+}
+
+/**
+ * Mint state lives above Settings because the response contains an
+ * unrecoverable, one-time value. Closing a panel or changing views must not
+ * discard either the request in flight or the value it eventually returns.
+ */
+export const usePrincipalStore = create<PrincipalState>((set, get) => ({
+  mintPending: false,
+  mintError: null,
+  oneTimeCredential: null,
+
+  mintAgent: async (label, ttlDays) => {
+    if (get().mintPending || get().oneTimeCredential) return;
+    set({ mintPending: true, mintError: null });
+    try {
+      const oneTimeCredential = await api.principalMint(label, ttlDays);
+      set({ mintPending: false, oneTimeCredential });
+    } catch (error) {
+      set({
+        mintPending: false,
+        mintError:
+          error instanceof Error ? error.message : "Could not create agent access",
+      });
+    }
+  },
+
+  acknowledgeAgentCredential: () => set({ oneTimeCredential: null }),
+}));

package/src/stores/ui-store.ts

@@ -1,7 +1,7 @@
 import { create } from "zustand";
 
 /** Which tab the settings panel opens on. */
-export type SettingsTab = "models" | "skills" | "security";
+export type SettingsTab = "models" | "skills" | "security" | "devices";
 
 /** Full-screen surface currently shown inside the AppShell. */
 export type ActiveView = "chat" | "graph" | "activity";