zidane-ui 9.0.4 → 9.1.3

package/src/palette/PaletteDialog.tsx

@@ -1,186 +0,0 @@
-/**
- * The Cmd+K palette in the app's modal slot (`zidane-ui/app` `ModalProvider`,
- * so the usual guards apply: inert background, Esc, `modal.isOpen`).
- *
- * `usePaletteModalSlot` bridges the palette's `isOpen` to the slot: it opens
- * the surface when asked, keeps the extension providers' live updates on
- * while open, and tells the palette when another modal took the slot (an
- * action opened Settings). `PaletteDialog` is the surface: `CommandPalette`
- * with the app rows (`createPaletteRows`), and matches inside conversations
- * appended as "In conversations" after the ranked groups (the header spinner
- * turns while that scan is out).
- */
-import type { PaletteContext, PaletteItem } from 'zidane/chat/pure';
-import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, type CSSProperties, type ReactNode } from 'react';
-
-import { useModal } from '../app/ModalProvider';
-import type { PaletteRowData } from '../components/palette/PaletteList';
-import { CommandPalette } from './CommandPalette';
-import {
-  paletteRecentIdOf,
-  SESSIONS_SOURCE_ID,
-  sessionKeyOfItem,
-  type PaletteSession,
-} from './headless/session-sources';
-import { paletteVerbOf, type PaletteRows } from './PaletteRows';
-import { usePalette, usePaletteHost, usePaletteLabels } from './PaletteProvider';
-import { usePaletteController } from './usePaletteController';
-import { ConversationHitsContext, useConversationSearch } from './useConversationSearch';
-
-/** The palette's modal-slot id (`modal.open({ id })`), shared by the slot bridge and the surface. */
-export const PALETTE_MODAL_ID = 'palette';
-
-const NO_SESSIONS: readonly PaletteSession[] = [];
-
-/** Props for {@link PaletteDialog}. */
-export interface PaletteDialogProps {
-  /** The snapshot handed to every source. Keep it stable while nothing in it changed. */
-  context: PaletteContext;
-  /** Every loaded session, for the matches inside conversations. Absent: no "In conversations" group. */
-  sessions?: readonly PaletteSession[];
-  /** Which sessions `sessions` was loaded with. */
-  archive?: 'active' | 'archived' | 'all';
-  /** The app rows, from `createPaletteRows` (module scope). Absent: the surface's default rows. */
-  rows?: PaletteRows;
-  /** Receives an `insert` result's text. */
-  onInsert?: (text: string) => void;
-  /** Receives a `prompt` result's text. */
-  onPrompt?: (text: string) => void;
-  /** Classes merged on the surface's root. */
-  className?: string;
-  /** Inline styles on the surface's root. */
-  style?: CSSProperties;
-}
-
-/**
- * Renders the palette surface in the modal slot `usePaletteModalSlot` opened. Esc and the backdrop tell the palette;
- * the palette closing (Cmd+K again, an item ran) closes the slot.
- *
- * @param props - {@link PaletteDialogProps}.
- */
-export function PaletteDialog({
-  context,
-  sessions = NO_SESSIONS,
-  archive,
-  rows,
-  onInsert,
-  onPrompt,
-  className,
-  style,
-}: PaletteDialogProps) {
-  const { close, isOpen } = usePalette();
-  const labels = usePaletteLabels();
-  const modal = useModal();
-
-  // Replacement by another modal is detected by the slot bridge through `modal.activeId`, never from an unmount:
-  // StrictMode simulates unmounts in development.
-  const closeRef = useRef(close);
-  useLayoutEffect(() => {
-    closeRef.current = close;
-  });
-  const setDismissHandler = modal.setDismissHandler;
-  useEffect(() => {
-    setDismissHandler(() => closeRef.current());
-    return () => setDismissHandler(null);
-  }, [setDismissHandler]);
-  const modalClose = modal.close;
-  useEffect(() => {
-    // Our slot only: an action that opened Settings already replaced us.
-    if (!isOpen) modalClose(PALETTE_MODAL_ID);
-  }, [isOpen, modalClose]);
-
-  const controller = usePaletteController({ context, onInsert, onPrompt, recentIdOf: paletteRecentIdOf });
-  const { ranked, query, nested } = controller;
-
-  // Content matches: every loaded session, minus those a title match already lists.
-  const listed = useMemo(
-    () => new Set(ranked.flatMap((r) => (r.item.source === SESSIONS_SOURCE_ID ? [sessionKeyOfItem(r.item.id)] : []))),
-    [ranked],
-  );
-  const conversations = useConversationSearch(query, { enabled: !nested, sessions, listed, archive });
-  const extraGroups = useMemo(
-    () =>
-      conversations.rows.length > 0
-        ? [{ title: labels.paletteConversationsGroup, rows: conversations.rows }]
-        : undefined,
-    [conversations.rows, labels],
-  );
-  const verb = useCallback((row: PaletteRowData<PaletteItem>) => paletteVerbOf(row, labels), [labels]);
-
-  return (
-    <ConversationHitsContext.Provider value={conversations.hits}>
-      <CommandPalette
-        controller={controller}
-        extraGroups={extraGroups}
-        busy={conversations.searching}
-        verb={verb}
-        {...(rows ?? {})}
-        className={className}
-        style={style}
-      />
-    </ConversationHitsContext.Provider>
-  );
-}
-
-/** Options of {@link usePaletteModalSlot}. */
-export interface PaletteModalSlotOptions {
-  /** The snapshot the surface opens with (reopening picks up a new one). */
-  context: PaletteContext;
-  /** The project folder: the extension providers' live updates stay on for it while open. */
-  cwd?: string;
-  /** The surface, usually a `PaletteDialog`. */
-  render: (context: PaletteContext) => ReactNode;
-}
-
-/**
- * Opens the palette surface in the modal slot while the palette is open, and closes the palette when another modal
- * takes the slot. Mount it once, under `ModalProvider` and `PaletteProvider`.
- *
- * @param options - {@link PaletteModalSlotOptions}.
- */
-export function usePaletteModalSlot({ context, cwd, render }: PaletteModalSlotOptions): void {
-  const palette = usePalette();
-  const host = usePaletteHost();
-  const modal = useModal();
-  const renderRef = useRef(render);
-  useLayoutEffect(() => {
-    renderRef.current = render;
-  });
-
-  const { isOpen, close } = palette;
-  const unwatch = useRef<(() => void) | null>(null);
-  useEffect(() => {
-    if (isOpen) {
-      modal.open(renderRef.current(context), { id: PALETTE_MODAL_ID, scrim: 'dim' });
-      if (cwd) unwatch.current = host?.extensions?.watch?.(cwd) ?? null;
-      return;
-    }
-    if (unwatch.current) {
-      unwatch.current();
-      unwatch.current = null;
-    }
-    // `context`/`cwd` on purpose: reopening picks up the new snapshot; while open the
-    // palette refetches on `version` bumps, so a stale snapshot is at most one emit old.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [isOpen, modal.open]);
-
-  // Replacement detection: while we are open and the slot stops being ours, another modal took it. Our own close
-  // resets the flag first, so a Cmd+K that lands while the previous surface is still unmounting does not read the
-  // transient empty slot as a replacement.
-  const wasOurs = useRef(false);
-  const { activeId } = modal;
-  useEffect(() => {
-    if (!isOpen) {
-      wasOurs.current = false;
-      return;
-    }
-    if (activeId === PALETTE_MODAL_ID) {
-      wasOurs.current = true;
-      return;
-    }
-    if (wasOurs.current) {
-      wasOurs.current = false;
-      close();
-    }
-  }, [activeId, isOpen, close]);
-}

package/src/palette/PaletteProvider.tsx

@@ -1,149 +0,0 @@
-/**
- * The command palette's state and source registry in React. Sources
- * register with `usePaletteSource` from wherever the state they read lives;
- * `CommandPalette` only ever sees the merged item list, so adding a source
- * never touches the UI.
- *
- * Two contexts: `usePaletteActions` (open, close, toggle, register: stable,
- * never re-renders its caller) and `usePalette` (the state as well).
- */
-import type { PaletteContext, PaletteItem, PaletteProvider as PaletteSource, PaletteRunResult } from 'zidane/chat/pure';
-import {
-  createContext,
-  useContext,
-  useEffect,
-  useLayoutEffect,
-  useMemo,
-  useRef,
-  useState,
-  useSyncExternalStore,
-  type ReactNode,
-} from 'react';
-
-import type { PaletteHost } from './headless/host';
-import { DEFAULT_PALETTE_LABELS, type PaletteLabels } from './headless/labels';
-import { createPaletteStore, type PaletteState } from './headless/store';
-import { PaletteSetupContext, usePaletteSetup, type PaletteSetup } from './setup';
-
-export type { PaletteContext, PaletteItem, PaletteRunResult, PaletteSource };
-
-/** What never changes: callers that only open the palette or register a source never re-render with it. */
-export interface PaletteActions {
-  /** Opens the palette. */
-  open: () => void;
-  /** Closes the palette. */
-  close: () => void;
-  /** Opens a closed palette, closes an open one (the Cmd+K entry point). */
-  toggle: () => void;
-  /** Registers a source for as long as the caller wants it; returns the unregister. */
-  registerSource: (source: PaletteSource) => () => void;
-}
-
-/** The palette's state and actions, from {@link usePalette}. */
-export interface PaletteApi extends PaletteActions, PaletteState {
-  /** Puts an item id first in the recents. */
-  markRecent: (id: string) => void;
-}
-
-const PaletteApiContext = createContext<PaletteApi | null>(null);
-const PaletteActionsContext = createContext<PaletteActions | null>(null);
-
-/** Props for {@link PaletteProvider}. */
-export interface PaletteProviderProps {
-  /** The data the built-in sources read and where recents persist. Read once, at mount. */
-  host?: PaletteHost;
-  /** Overrides for the palette area's strings. Keys you leave out keep the default English label. */
-  labels?: Partial<PaletteLabels>;
-  /**
-   * Starts a worker running `zidane-ui/palette/rank.worker`, so a big catalog
-   * (a project's files) is ranked off the main thread. Without one, every
-   * query ranks in place.
-   */
-  createRankWorker?: () => Worker;
-  /** The app's components. */
-  children: ReactNode;
-}
-
-/**
- * Holds the palette's state (open, sources, recents) for the components below it.
- *
- * @param props - The `host`, optional `labels` and `createRankWorker`, and the `children`.
- */
-export function PaletteProvider({ host, labels, createRankWorker, children }: PaletteProviderProps) {
-  const [store] = useState(() => createPaletteStore(host?.recents ? { recents: host.recents } : {}));
-  const state = useSyncExternalStore(store.state.subscribe, store.state.get, store.state.get);
-  const actions = useMemo<PaletteActions>(
-    () => ({ open: store.open, close: store.close, toggle: store.toggle, registerSource: store.registerSource }),
-    [store],
-  );
-  const value = useMemo<PaletteApi>(
-    () => ({ ...actions, ...state, markRecent: store.markRecent }),
-    [actions, state, store],
-  );
-  const setup = useMemo<PaletteSetup>(
-    () => ({
-      host,
-      labels: labels ? { ...DEFAULT_PALETTE_LABELS, ...labels } : DEFAULT_PALETTE_LABELS,
-      createRankWorker,
-    }),
-    [host, labels, createRankWorker],
-  );
-  return (
-    <PaletteSetupContext.Provider value={setup}>
-      <PaletteActionsContext.Provider value={actions}>
-        <PaletteApiContext.Provider value={value}>{children}</PaletteApiContext.Provider>
-      </PaletteActionsContext.Provider>
-    </PaletteSetupContext.Provider>
-  );
-}
-
-/** The palette's state and actions. Re-renders on every state change. Throws outside a {@link PaletteProvider}. */
-export function usePalette(): PaletteApi {
-  const ctx = useContext(PaletteApiContext);
-  if (!ctx) throw new Error('usePalette must be used within PaletteProvider');
-  return ctx;
-}
-
-/** The palette's stable actions. Never re-renders its caller. Throws outside a {@link PaletteProvider}. */
-export function usePaletteActions(): PaletteActions {
-  const ctx = useContext(PaletteActionsContext);
-  if (!ctx) throw new Error('usePaletteActions must be used within PaletteProvider');
-  return ctx;
-}
-
-/** The {@link PaletteHost} given to the nearest {@link PaletteProvider}, if any. */
-export function usePaletteHost(): PaletteHost | undefined {
-  return usePaletteSetup().host;
-}
-
-/** The palette area's strings, with the provider's overrides. */
-export function usePaletteLabels(): PaletteLabels {
-  return usePaletteSetup().labels;
-}
-
-/**
- * Registers a source for the component's lifetime. `source` is read through
- * a ref, so callers can pass a fresh object every render without churning
- * the registry; it registers again only when its id changes. `null`
- * registers nothing.
- *
- * @param source - The source, or `null`.
- */
-export function usePaletteSource(source: PaletteSource | null): void {
-  const { registerSource } = usePaletteActions();
-  const latest = useRef(source);
-  useLayoutEffect(() => {
-    latest.current = source;
-  });
-  const id = source?.id ?? null;
-  useEffect(() => {
-    if (!id) return;
-    const proxy: PaletteSource = {
-      id,
-      items: (ctx) => latest.current?.items(ctx) ?? [],
-      run: (itemId, ctx) => latest.current?.run(itemId, ctx),
-      subscribe: (emit) => latest.current?.subscribe?.(emit) ?? (() => {}),
-    };
-    return registerSource(proxy);
-  }, [id, registerSource]);
-}

package/src/palette/PaletteRows.tsx

@@ -1,208 +0,0 @@
-/**
- * The app rows of the command palette: a session with its live status, a
- * match inside a conversation with its highlighted excerpt, a file with its
- * type badge, keycaps in the binding grammar, and the footer's verbs for
- * those kinds. Every other row is the surface's default.
- *
- * What a session's status is and how its dot looks are the app's: hand them
- * to {@link createPaletteRows} once, at module scope.
- */
-import type { PaletteItem } from 'zidane/chat/pure';
-import { ageString } from 'zidane/chat/pure';
-import { memo, type ComponentType, type ReactNode } from 'react';
-
-import { MetaChip } from '../components/Form';
-import {
-  MatchedTitle,
-  PaletteIcon,
-  PaletteOption,
-  type PaletteKeys,
-  type PaletteRowData,
-  type PaletteRowProps,
-} from '../components/palette/PaletteList';
-import { chipForPath } from '../chat/headless/file-chip';
-import { FileBadgeIcon } from '../chat/transcript/badges';
-import { KeyHint } from '../keybindings/KeyHint';
-import { FILES_SOURCE_ID, GO_TO_FILE_ID } from './headless/sources';
-import {
-  CONVERSATIONS_SOURCE_ID,
-  conversationTargetOf,
-  SESSION_ITEM_PREFIX,
-  SESSIONS_SOURCE_ID,
-  sessionKeyOfItem,
-} from './headless/session-sources';
-import type { PaletteLabels } from './headless/labels';
-import { usePaletteLabels } from './PaletteProvider';
-import { useConversationHit } from './useConversationSearch';
-
-/** A half-open `[start, end)` range of a text. */
-export type PaletteTextRange = readonly [start: number, end: number];
-
-/** A session's status as its palette row words it; quiet states say nothing. */
-export type PaletteSessionStatus = 'running' | 'pending' | 'attention' | 'error';
-
-/** What the rows read from the app. Every member is optional. */
-export interface PaletteRowsOptions {
-  /** A session's live status dot, in the row's icon slot. */
-  StatusDot?: ComponentType<{ sessionId: string }>;
-  /** A session's live status (a hook, called once per session row). */
-  useSessionStatus?: (sessionId: string) => PaletteSessionStatus | string | undefined;
-  /** A loaded session's last update and whether it is the one on show (a hook, called once per session row). */
-  useSession?: (sessionId: string) => { updatedAt: number; current: boolean } | undefined;
-  /** Cuts a conversation excerpt around its first match and marks the query's terms in it. Absent: plain excerpt. */
-  highlight?: (excerpt: string, query: string) => { text: string; ranges: readonly PaletteTextRange[] };
-}
-
-/** The renderers {@link createPaletteRows} returns, for `CommandPalette`. */
-export interface PaletteRows {
-  /** A session or a conversation match; any other row is the surface's (`undefined`). */
-  renderRow: (props: PaletteRowProps<PaletteItem>) => ReactNode;
-  /** A file's type badge, else the item's own glyph. */
-  renderIcon: (row: PaletteRowData<PaletteItem>) => ReactNode;
-  /** Keycaps for binding specs that may list alternatives (`ctrl+w | cmd+w`). */
-  renderKeys: PaletteKeys;
-}
-
-const isSession = (item: PaletteItem) => item.source === SESSIONS_SOURCE_ID && item.id.startsWith(SESSION_ITEM_PREFIX);
-const isConversationHit = (item: PaletteItem) => item.source === CONVERSATIONS_SOURCE_ID;
-const isFile = (item: PaletteItem) =>
-  item.source === FILES_SOURCE_ID && item.id.startsWith('file:') && item.id !== GO_TO_FILE_ID;
-
-const STATUS_TONE: Record<PaletteSessionStatus, string> = {
-  running: 'text-[var(--zg-accent)]',
-  pending: 'text-zg-warn',
-  attention: 'text-zg-warn',
-  error: 'text-zg-danger',
-};
-
-/**
- * What Enter does to a session, a conversation match or a file; the surface names the rest.
- *
- * @param row - The row under the cursor.
- * @param labels - The palette labels.
- */
-export function paletteVerbOf(row: PaletteRowData<PaletteItem>, labels: PaletteLabels): string | undefined {
-  if (isSession(row.item)) return labels.paletteSwitchToSession;
-  if (isConversationHit(row.item)) return labels.paletteOpenAndFind;
-  if (isFile(row.item)) return labels.paletteOpenFile;
-  return undefined;
-}
-
-const noStatus = (): undefined => undefined;
-const shortAge = (at: number) => ageString(at).replace(/ ago$/, '');
-
-/** `text` with `ranges` marked the way a matched title is (`.zg-palette-match`). */
-function MarkedText({ text, ranges }: { text: string; ranges: readonly PaletteTextRange[] }) {
-  const out: ReactNode[] = [];
-  let from = 0;
-  for (const [start, end] of ranges) {
-    if (start > from) out.push(text.slice(from, start));
-    out.push(
-      <mark key={start} className="zg-palette-match">
-        {text.slice(start, end)}
-      </mark>,
-    );
-    from = end;
-  }
-  if (from < text.length) out.push(text.slice(from));
-  return <>{out}</>;
-}
-
-/**
- * Builds the palette's app rows over what the app knows about its sessions. Call it once, at module scope: the
- * hooks it is handed run inside the rows.
- *
- * @param options - {@link PaletteRowsOptions}.
- */
-export function createPaletteRows(options: PaletteRowsOptions = {}): PaletteRows {
-  const { StatusDot, useSessionStatus = noStatus, useSession = noStatus, highlight } = options;
-
-  /**
-   * A session: its live status dot in the icon slot, a status word when it matters, the folder and age on the
-   * right. Live while the palette is open (the dot and word follow the run; the order is set at open).
-   */
-  const SessionPaletteRow = memo(function SessionPaletteRow(props: PaletteRowProps<PaletteItem>) {
-    const { row, terms } = props;
-    const labels = usePaletteLabels();
-    const id = sessionKeyOfItem(row.item.id);
-    const state = useSessionStatus(id);
-    const status = state && state in STATUS_TONE ? (state as PaletteSessionStatus) : undefined;
-    const session = useSession(id);
-    return (
-      <PaletteOption
-        {...props}
-        icon={StatusDot ? <StatusDot sessionId={id} /> : undefined}
-        title={<MatchedTitle text={row.item.title} indices={row.titleMatches} terms={terms} />}
-        description={
-          status && (
-            <span className={`font-medium ${STATUS_TONE[status]}`} data-testid="session-status">
-              {labels.paletteSessionStatus[status]}
-            </span>
-          )
-        }
-        trailing={
-          <>
-            {session?.current && <MetaChip>{labels.paletteSessionCurrent}</MetaChip>}
-            {/* The folder gives way; the age stays whole. */}
-            <span className="zg-meta max-w-[12rem] truncate">{row.item.description}</span>
-            {session && <MetaChip>{shortAge(session.updatedAt)}</MetaChip>}
-          </>
-        }
-      />
-    );
-  });
-
-  /**
-   * A match inside a conversation: the session's live dot, its title, then the excerpt around the match with every
-   * query term marked, and how many turns matched · folder · age.
-   */
-  const ConversationHitRow = memo(function ConversationHitRow(props: PaletteRowProps<PaletteItem>) {
-    const { row } = props;
-    const labels = usePaletteLabels();
-    const target = conversationTargetOf(row.item.id);
-    const hit = useConversationHit(row.item.id);
-    const excerpt = row.item.description ?? '';
-    const focused = highlight ? highlight(excerpt, target?.query ?? '') : { text: excerpt, ranges: [] };
-    const folder = row.item.keywords?.[0];
-    return (
-      <PaletteOption
-        {...props}
-        icon={target && StatusDot ? <StatusDot sessionId={target.sessionId} /> : undefined}
-        title={row.item.title}
-        description={
-          <span data-testid="conversation-excerpt">
-            <MarkedText text={focused.text} ranges={focused.ranges} />
-          </span>
-        }
-        trailing={
-          <>
-            {hit && hit.matchCount > 1 && <MetaChip>{labels.paletteMatchCount(hit.matchCount)}</MetaChip>}
-            {folder && <span className="zg-meta max-w-[8rem] truncate">{folder}</span>}
-            {hit?.updatedAt !== undefined && <MetaChip>{shortAge(hit.updatedAt)}</MetaChip>}
-          </>
-        }
-      />
-    );
-  });
-
-  return {
-    renderRow: (props) => {
-      if (isSession(props.row.item)) return <SessionPaletteRow {...props} />;
-      if (isConversationHit(props.row.item)) return <ConversationHitRow {...props} />;
-      return undefined;
-    },
-    // A file's type badge (the one chat and the composer show), else the item's own glyph.
-    renderIcon: (row) => {
-      const { item } = row;
-      if (isFile(item)) {
-        return (
-          <span className="zg-palette-icon zg-palette-file inline-flex">
-            <FileBadgeIcon chip={chipForPath(item.id.slice('file:'.length))} />
-          </span>
-        );
-      }
-      return <PaletteIcon icon={item.icon?.gui} />;
-    },
-    renderKeys: (spec) => <KeyHint spec={spec} size="sm" />,
-  };
-}

package/src/palette/app-sources.ts

@@ -1,62 +0,0 @@
-/**
- * The palette sources every app on the kit mounts the same way:
- *
- *   - `useActionsPaletteSource`: the key command registry's actions
- *     (`zidane-ui/keybindings`, `useKeyCommands`) as palette rows, with their
- *     live chords. Whatever has a shortcut is in the palette.
- *   - `useSessionRank`: how a session's row ranks (it needs you, it runs,
- *     the rest), from the pending approvals and questions, presence and the
- *     app's running flag.
- */
-import { useCallback, useMemo } from 'react';
-
-import { usePendingApprovals } from '../approvals/ApprovalsProvider';
-import { useAllInteractions } from '../chat/interactions/hooks';
-import { getMergedKeybindings } from '../keybindings/headless/overrides';
-import { useKeyCommandActions, useKeyCommandRegistry } from '../keybindings/KeyCommands';
-import { useKeybindingsHost } from '../keybindings/KeybindingsProvider';
-import { usePresenceMap } from '../machines/MachinesProvider';
-import { actionsSource } from './headless/app-sources';
-import type { SessionRank } from './headless/session-sources';
-import { usePaletteLabels, usePaletteSource } from './PaletteProvider';
-
-/**
- * Registers the key command registry's actions as a palette source. Registers again only when the set of bound
- * actions changes: the rows run the handlers in effect when picked.
- */
-export function useActionsPaletteSource(): void {
-  const registry = useKeyCommandRegistry();
-  const bound = useKeyCommandActions();
-  const host = useKeybindingsHost();
-  const labels = usePaletteLabels();
-  usePaletteSource(
-    useMemo(
-      () => (registry ? actionsSource(registry.get, () => getMergedKeybindings(host), labels) : null),
-      // `bound`: a new set of actions lists again.
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-      [registry, host, labels, bound],
-    ),
-  );
-}
-
-/**
- * A session's palette rank: 0 when it needs the user (attention, a pending approval or question), 1 while it runs,
- * else 2.
- *
- * @param peekRunning - Whether the app sees the session running now (read when ranking, not subscribed).
- */
-export function useSessionRank(peekRunning: (sessionId: string) => boolean): (sessionId: string) => SessionRank {
-  const approvals = usePendingApprovals();
-  const interactions = useAllInteractions();
-  const presence = usePresenceMap();
-  return useCallback(
-    (id: string): SessionRank => {
-      const p = presence.get(id);
-      if (p?.attention || approvals.some((a) => a.sessionId === id) || interactions.some((e) => e.sessionId === id)) {
-        return 0;
-      }
-      return peekRunning(id) || p?.running ? 1 : 2;
-    },
-    [approvals, interactions, presence, peekRunning],
-  );
-}