mu-coding 0.15.0 → 0.16.1

package/src/tui/chat/useSessionPersistence.ts

@@ -1,84 +0,0 @@
-import type { ChatMessage } from 'mu-core';
-import { useCallback, useEffect, useRef, useState } from 'react';
-import type { SessionPathHolder } from '../../runtime/createRegistry';
-import { generateSessionPath, loadSession, saveSession } from '../../sessions/index';
-
-export interface SessionPersistenceState {
-  inputHistory: string[];
-  appendHistory: (text: string) => void;
-  sessionPathRef: React.RefObject<string>;
-  /** Persist the given transcript to the current session file. */
-  saveCurrent: (messages: ChatMessage[]) => void;
-  /** Reset to a brand-new session: rotates the file path. */
-  resetForNew: () => void;
-  /**
-   * Load a transcript from disk and adopt its path. Returns the loaded
-   * messages so the caller can hand them to the session.
-   */
-  loadFromPath: (path: string) => ChatMessage[];
-  /** Replace history (used after resume / load). */
-  setHistory: (history: string[]) => void;
-}
-
-function userPromptsFrom(messages: ChatMessage[]): string[] {
-  return messages.filter((m) => m.role === 'user').map((m) => m.content);
-}
-
-/**
- * Side-channel persistence: history bookkeeping, on-disk save, and session
- * file path management. Does NOT own the transcript — `Session` is the
- * single source of truth in the new architecture, this hook only writes to
- * disk and tracks the current target path.
- *
- * Save errors are logged to stderr and do not surface to the chat error
- * channel — they're considered non-fatal (next save attempt may succeed).
- */
-export function useSessionPersistence(
-  initialMessages?: ChatMessage[],
-  sessionPathHolder?: SessionPathHolder,
-): SessionPersistenceState {
-  const [inputHistory, setInputHistory] = useState<string[]>(userPromptsFrom(initialMessages ?? []));
-  const sessionPathRef = useRef(generateSessionPath());
-
-  // Mirror the live path into the cross-plugin holder so mu-agents can read
-  // it lazily when dispatching a subagent. Using a useEffect keeps the
-  // holder write off the React render path.
-  useEffect(() => {
-    if (sessionPathHolder) sessionPathHolder.current = sessionPathRef.current;
-  }, [sessionPathHolder]);
-
-  const appendHistory = useCallback((text: string) => {
-    setInputHistory((prev) => [...prev, text]);
-  }, []);
-
-  const saveCurrent = useCallback((finalMessages: ChatMessage[]) => {
-    saveSession(sessionPathRef.current, finalMessages).catch((err) => {
-      console.error('Failed to save session:', err);
-    });
-  }, []);
-
-  const resetForNew = useCallback(() => {
-    sessionPathRef.current = generateSessionPath();
-    if (sessionPathHolder) sessionPathHolder.current = sessionPathRef.current;
-    setInputHistory([]);
-  }, [sessionPathHolder]);
-
-  const loadFromPath = useCallback(
-    (path: string): ChatMessage[] => {
-      const msgs = loadSession(path);
-      if (msgs.length > 0) {
-        sessionPathRef.current = path;
-        if (sessionPathHolder) sessionPathHolder.current = sessionPathRef.current;
-        setInputHistory(userPromptsFrom(msgs));
-      }
-      return msgs;
-    },
-    [sessionPathHolder],
-  );
-
-  const setHistory = useCallback((history: string[]) => {
-    setInputHistory(history);
-  }, []);
-
-  return { inputHistory, appendHistory, sessionPathRef, saveCurrent, resetForNew, loadFromPath, setHistory };
-}

package/src/tui/chat/useStatusSegments.ts

@@ -1,85 +0,0 @@
-import type { StatusSegment } from 'mu-core';
-import type { StatusBarSegment } from '../components/statusBar';
-import { useSpinner } from '../hooks/useUI';
-
-const ERROR_PREVIEW_LEN = 40;
-
-interface StatusSegmentOptions {
-  streaming: boolean;
-  abortWarning: boolean;
-  quitWarning: boolean;
-  error: string | null;
-  modelError: string | null;
-  totalTokens: number;
-  /** Input tokens sent to the model for the current turn (prompt size). Used
-   *  for the context window percentage calculation. */
-  promptTokens: number;
-  /** Tokens served from server-side prompt cache. Rendered as `(N cached)`
-   *  next to the total when > 0. Omit (or pass 0) to hide the suffix. */
-  cachedTokens?: number;
-  /** Model context window (input + output) reported by the provider; when
-   *  set, the tokens segment is rendered as `used/limit tokens`. */
-  contextLimit?: number;
-  pluginStatus?: StatusSegment[];
-}
-
-function truncate(text: string, max: number): string {
-  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
-}
-
-const tokenFormatter = new Intl.NumberFormat('en-US');
-function formatTokens(n: number): string {
-  if (n >= 1_000_000) {
-    const v = n / 1_000_000;
-    return `${v >= 10 ? v.toFixed(0) : v.toFixed(1)}M`;
-  }
-  if (n >= 1000) {
-    const v = n / 1000;
-    return `${v >= 10 ? v.toFixed(0) : v.toFixed(1)}k`;
-  }
-  return tokenFormatter.format(n);
-}
-
-export function useStatusSegments(options: StatusSegmentOptions): StatusBarSegment[] {
-  const spinner = useSpinner(options.streaming);
-  const segments: StatusBarSegment[] = [];
-
-  if (options.streaming) {
-    segments.push({ text: spinner, color: 'yellow', align: 'left' });
-  }
-  if (options.totalTokens > 0) {
-    const cached = options.cachedTokens ?? 0;
-    const used = formatTokens(options.promptTokens);
-    let head: string;
-    if (options.contextLimit) {
-      const pct = (options.promptTokens / options.contextLimit) * 100;
-      const pctStr = pct >= 10 ? pct.toFixed(0) : pct.toFixed(1);
-      head = `${used} (${pctStr}%)`;
-    } else {
-      head = used;
-    }
-    if (cached > 0) {
-      segments.push({ text: `${head} · ${formatTokens(cached)} cached`, dim: true });
-    } else {
-      segments.push({ text: head, dim: true });
-    }
-  }
-  if (options.abortWarning) {
-    segments.push({ text: 'Esc again to stop', color: 'yellow' });
-  } else if (options.quitWarning) {
-    segments.push({ text: 'Ctrl+C again to quit', color: 'yellow' });
-  } else if (options.streaming) {
-    segments.push({ text: 'Esc to stop', dim: true });
-  }
-  if (options.error) {
-    segments.push({ text: `⚠ ${truncate(options.error, ERROR_PREVIEW_LEN)}`, color: 'red' });
-  }
-  if (options.modelError) {
-    segments.push({ text: `⚠ ${truncate(options.modelError, ERROR_PREVIEW_LEN)}`, color: 'red' });
-  }
-  if (options.pluginStatus) {
-    segments.push(...options.pluginStatus);
-  }
-
-  return segments;
-}

package/src/tui/chat/useSubagentBrowser.ts

@@ -1,133 +0,0 @@
-/**
- * Subagent browser state machine.
- *
- * Exposes:
- *  - the live list of `SubagentRun`s (subscribed to the registry)
- *  - the current `viewMode` (chat vs browsing a specific run)
- *  - keyboard handlers wired through `useChordKeyboard`:
- *      Ctrl+X ↓        — enter browser at the most recent run
- *      Ctrl+X →        — next run (loops)
- *      Ctrl+X ←        — previous run (loops)
- *      Ctrl+X ↑ or Esc — back to chat
- *
- * Returning to chat happens via the `Esc` handler the panel registers
- * directly (kept outside the chord so it's reachable without the prefix).
- */
-
-import { useInput } from 'ink';
-import type { SubagentRun, SubagentRunRegistry } from 'mu-agents';
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useChordKeyboard } from '../hooks/useChordKeyboard';
-
-export type SubagentViewMode = { kind: 'chat' } | { kind: 'subagent'; runId: string };
-
-export interface SubagentBrowserState {
-  mode: SubagentViewMode;
-  runs: SubagentRun[];
-  currentRun: SubagentRun | undefined;
-  /** 1-based position of the current run (for UI labels like "i / N"). */
-  position: { index: number; total: number } | null;
-  enterLatest: () => void;
-  next: () => void;
-  prev: () => void;
-  exit: () => void;
-}
-
-const NOOP = (): void => {
-  // Intentional: returned by the empty-registry shape so call sites can
-  // wire handlers up without null-checking each invocation.
-};
-
-const EMPTY_BROWSER: SubagentBrowserState = {
-  mode: { kind: 'chat' },
-  runs: [],
-  currentRun: undefined,
-  position: null,
-  enterLatest: NOOP,
-  next: NOOP,
-  prev: NOOP,
-  exit: NOOP,
-};
-
-export function useSubagentBrowser(registry: SubagentRunRegistry | undefined): SubagentBrowserState {
-  const [runs, setRuns] = useState<SubagentRun[]>(() => registry?.list() ?? []);
-  const [mode, setMode] = useState<SubagentViewMode>({ kind: 'chat' });
-
-  // Subscribe to registry events; the listener fires immediately on
-  // subscribe with the current snapshot, so the initial state is correct
-  // even when the registry already has runs from a resumed session.
-  useEffect(() => {
-    if (!registry) return;
-    return registry.subscribe((next) => setRuns(next));
-  }, [registry]);
-
-  // If the run we're showing disappears (registry cleared on /new), bounce
-  // back to chat so the user isn't stuck on a phantom run.
-  useEffect(() => {
-    if (mode.kind !== 'subagent') return;
-    if (!runs.some((r) => r.id === mode.runId)) setMode({ kind: 'chat' });
-  }, [runs, mode]);
-
-  const exit = useCallback(() => setMode({ kind: 'chat' }), []);
-
-  const enterLatest = useCallback(() => {
-    if (runs.length === 0) return;
-    const last = runs[runs.length - 1];
-    setMode({ kind: 'subagent', runId: last.id });
-  }, [runs]);
-
-  const cycle = useCallback(
-    (direction: 1 | -1) => {
-      if (runs.length === 0) return;
-      const currentId = mode.kind === 'subagent' ? mode.runId : runs[runs.length - 1].id;
-      const idx = runs.findIndex((r) => r.id === currentId);
-      const start = idx === -1 ? runs.length - 1 : idx;
-      const len = runs.length;
-      // Wrap-around — `(start + direction + len) % len` is the canonical
-      // modulo trick that handles negative results in JS (`%` keeps sign).
-      const nextIdx = (start + direction + len) % len;
-      setMode({ kind: 'subagent', runId: runs[nextIdx].id });
-    },
-    [mode, runs],
-  );
-
-  const next = useCallback(() => cycle(1), [cycle]);
-  const prev = useCallback(() => cycle(-1), [cycle]);
-
-  // Ctrl+X chord is always armed, but the follow-ups are no-ops while no
-  // subagent run exists (so the user gets terminal-bell silence rather
-  // than an unexpected mode switch).
-  useChordKeyboard({
-    prefix: ({ key, input }) => key.ctrl === true && input === 'x',
-    followUps: [
-      { match: ({ key }) => key.downArrow === true, handler: enterLatest },
-      { match: ({ key }) => key.rightArrow === true, handler: next },
-      { match: ({ key }) => key.leftArrow === true, handler: prev },
-      { match: ({ key }) => key.upArrow === true, handler: exit },
-    ],
-  });
-
-  // Esc returns to chat from the browser. Active only while we're actually
-  // showing a run; otherwise we'd intercept Esc clearing modal/picker UIs.
-  useInput(
-    (_input, key) => {
-      if (key.escape) exit();
-    },
-    { isActive: mode.kind === 'subagent' },
-  );
-
-  const currentRun = useMemo(
-    () => (mode.kind === 'subagent' ? runs.find((r) => r.id === mode.runId) : undefined),
-    [mode, runs],
-  );
-  const position = useMemo(() => {
-    if (mode.kind !== 'subagent') return null;
-    const i = runs.findIndex((r) => r.id === mode.runId);
-    if (i === -1) return null;
-    return { index: i + 1, total: runs.length };
-  }, [mode, runs]);
-
-  if (!registry) return EMPTY_BROWSER;
-
-  return { mode, runs, currentRun, position, enterLatest, next, prev, exit };
-}

package/src/tui/components/chat/ChatPanel.tsx

@@ -1,54 +0,0 @@
-import type { SubagentRunRegistry } from 'mu-agents';
-import type { ChatMessage, PluginRegistry, ProviderConfig } from 'mu-core';
-import type { ShutdownFn } from '../../../app/shutdown';
-import type { SessionPathHolder } from '../../../runtime/createRegistry';
-import type { HostMessageBus } from '../../../runtime/messageBus';
-import { ChatContext } from '../../chat/ChatContext';
-import { MessageRendererProvider, useRegistryRenderers } from '../../chat/MessageRendererContext';
-import { ToolDisplayProvider, useToolDisplayMap } from '../../chat/ToolDisplayContext';
-import { useChatPanel } from '../../chat/useChatPanel';
-import type { InkUIService } from '../../plugins/InkUIService';
-import { ChatPanelBody } from './ChatPanelBody';
-
-export function ChatPanel({
-  config,
-  initialMessages,
-  registry,
-  messageBus,
-  uiService,
-  shutdown,
-  sessionPathHolder,
-  subagentRuns,
-}: {
-  config: ProviderConfig;
-  initialMessages?: ChatMessage[];
-  registry: PluginRegistry;
-  messageBus?: HostMessageBus;
-  uiService?: InkUIService;
-  shutdown?: ShutdownFn;
-  sessionPathHolder?: SessionPathHolder;
-  subagentRuns?: SubagentRunRegistry;
-}) {
-  const { ctx, bodyProps } = useChatPanel({
-    config,
-    initialMessages,
-    registry,
-    messageBus,
-    uiService,
-    shutdown,
-    sessionPathHolder,
-    subagentRuns,
-  });
-  const toolDisplays = useToolDisplayMap(registry);
-  const renderers = useRegistryRenderers(registry);
-
-  return (
-    <ChatContext.Provider value={ctx}>
-      <ToolDisplayProvider value={toolDisplays}>
-        <MessageRendererProvider value={renderers}>
-          <ChatPanelBody {...bodyProps} />
-        </MessageRendererProvider>
-      </ToolDisplayProvider>
-    </ChatContext.Provider>
-  );
-}

package/src/tui/components/chat/ChatPanelBody.tsx

@@ -1,86 +0,0 @@
-import { Box, type DOMElement as InkDOMElement } from 'ink';
-import type { ChatMessage } from 'mu-core';
-import type { StreamState } from '../../chat/useChatSession';
-import type { SubagentBrowserState } from '../../chat/useSubagentBrowser';
-import { useInputInfoSegments } from '../../hooks/useInputInfoSegments';
-import { InputBox } from '../../input/InputBox';
-import type { InkUIService } from '../../plugins/InkUIService';
-import { MessageView } from '../messageView';
-import { type Toast, ToastContainer } from '../primitives/toast';
-import type { StatusBarSegment } from '../statusBar';
-import { StatusBar } from '../statusBar';
-import { DialogLayer } from '../ui/dialogLayer';
-import { Pickers } from './Pickers';
-import { SubagentBrowserPanel } from './SubagentBrowserPanel';
-
-export interface ChatPanelBodyProps {
-  width: number;
-  height: number;
-  viewRef: React.RefObject<InkDOMElement | null>;
-  contentRef: React.RefObject<InkDOMElement | null>;
-  scrollOffset: number;
-  viewHeight: number;
-  contentHeight: number;
-  isActive: boolean;
-  onScrollUp: () => void;
-  onScrollDown: () => void;
-  uiService?: InkUIService;
-  messages: ChatMessage[];
-  streaming: boolean;
-  stream: StreamState;
-  error: string | null;
-  onSubmit: (text: string) => void;
-  model: string;
-  history: string[];
-  statusSegments: StatusBarSegment[];
-  toasts: Toast[];
-  onDismissToast: (id: number) => void;
-  /** Subagent browser state — when in subagent mode the chat body is replaced. */
-  browser?: SubagentBrowserState;
-}
-
-export function ChatPanelBody(props: ChatPanelBodyProps) {
-  const infoSegments = useInputInfoSegments();
-
-  // Browser mode: replace the entire chat body with the subagent panel.
-  // Modals (dialog layer, toasts) still render so an `ask` triggered by a
-  // subagent dispatch can still surface to the user.
-  if (props.browser?.mode.kind === 'subagent' && props.browser.currentRun) {
-    return (
-      <Box flexDirection="column" height={props.height} width={props.width}>
-        <SubagentBrowserPanel run={props.browser.currentRun} position={props.browser.position} />
-        {props.uiService && <DialogLayer service={props.uiService} />}
-        <ToastContainer toasts={props.toasts} onDismiss={props.onDismissToast} />
-      </Box>
-    );
-  }
-
-  return (
-    <Box flexDirection="column" height={props.height} width={props.width}>
-      <MessageView
-        viewRef={props.viewRef}
-        contentRef={props.contentRef}
-        messages={props.messages}
-        streaming={props.streaming}
-        stream={props.stream}
-        error={props.error}
-        scrollOffset={props.scrollOffset}
-        viewHeight={props.viewHeight}
-        contentHeight={props.contentHeight}
-      />
-      <InputBox
-        onSubmit={props.onSubmit}
-        onScrollUp={props.onScrollUp}
-        onScrollDown={props.onScrollDown}
-        isActive={props.isActive}
-        model={props.model}
-        history={props.history}
-        infoSegments={infoSegments}
-      />
-      <StatusBar segments={props.statusSegments} />
-      <Pickers />
-      {props.uiService && <DialogLayer service={props.uiService} />}
-      <ToastContainer toasts={props.toasts} onDismiss={props.onDismissToast} />
-    </Box>
-  );
-}

package/src/tui/components/chat/Pickers.tsx

@@ -1,44 +0,0 @@
-import { useMemo } from 'react';
-import { useChatContext } from '../../chat/ChatContext';
-import { PickerModal } from '../primitives/pickerModal';
-
-export function Pickers() {
-  const { toggles, models, sessions, session } = useChatContext();
-  const sessionItems = useMemo(
-    () =>
-      sessions.map((s) => ({
-        label: s.preview,
-        value: s.path,
-        description: `${s.messageCount} msgs`,
-      })),
-    [sessions],
-  );
-
-  return (
-    <>
-      <PickerModal
-        visible={toggles.showModelPicker}
-        title="Select model"
-        items={models.models.map((m) => ({ label: m.id, value: m.id }))}
-        placeholder="Search models..."
-        onSelect={(id) => {
-          models.selectModel(id);
-          toggles.onTogglePicker();
-        }}
-        onCancel={toggles.onTogglePicker}
-      />
-      <PickerModal
-        visible={toggles.showSessionPicker}
-        title={`Sessions · ${sessions[0]?.project ?? 'project'}`}
-        items={sessionItems}
-        placeholder="Search sessions..."
-        emptyMessage="No sessions found for this project"
-        onSelect={(p) => {
-          session.onLoadSession(p);
-          toggles.onToggleSessionPicker();
-        }}
-        onCancel={toggles.onToggleSessionPicker}
-      />
-    </>
-  );
-}

package/src/tui/components/chat/SubagentBrowserPanel.tsx

@@ -1,145 +0,0 @@
-/**
- * SubagentBrowserPanel — read-only view of a single subagent run.
- *
- * Replaces the chat body when `viewMode.kind === 'subagent'`:
- *  - Top banner: session title · agent name · status (agent colour).
- *  - Body: full-fidelity `MessageView` over the run's transcript so every
- *    nested tool call / reasoning block / output renders identically to
- *    the parent chat.
- *  - Status bar: subagent-specific segments (i/N, tool calls, elapsed).
- *  - No input box — the panel is read-only; the user navigates via
- *    `Ctrl+X →/←` or returns to chat with `Esc` / `Ctrl+X ↑`.
- */
-
-import { Box, type DOMElement as InkDOMElement, Text } from 'ink';
-import type { SubagentRun } from 'mu-agents';
-import type { ChatMessage } from 'mu-core';
-import { type RefObject, useEffect, useMemo, useRef, useState } from 'react';
-import { useTheme } from '../../context/ThemeContext';
-import { useScroll } from '../../hooks/useScroll';
-import { useMeasure, useTerminalSize } from '../../hooks/useTerminal';
-import { MessageView } from '../messageView';
-import { StatusBar, type StatusBarSegment } from '../statusBar';
-
-interface SubagentBrowserPanelProps {
-  run: SubagentRun;
-  position: { index: number; total: number } | null;
-  /** Display title for the parent session (e.g. session file stem). */
-  sessionTitle?: string;
-}
-
-const STATUS_LABEL: Record<SubagentRun['status'], string> = {
-  running: 'running…',
-  done: 'done',
-  error: 'error',
-  aborted: 'aborted',
-};
-
-function statusColor(status: SubagentRun['status']): string | undefined {
-  switch (status) {
-    case 'running':
-      return 'cyan';
-    case 'done':
-      return 'green';
-    case 'error':
-      return 'red';
-    case 'aborted':
-      return 'yellow';
-    default:
-      return undefined;
-  }
-}
-
-function formatElapsed(run: SubagentRun): string {
-  const end = run.finishedAt ?? Date.now();
-  const ms = Math.max(0, end - run.startedAt);
-  if (ms < 1000) return `${ms}ms`;
-  const s = Math.round(ms / 1000);
-  if (s < 60) return `${s}s`;
-  const m = Math.floor(s / 60);
-  const rs = s % 60;
-  return `${m}m${rs.toString().padStart(2, '0')}s`;
-}
-
-function countToolCalls(messages: ChatMessage[]): number {
-  let n = 0;
-  for (const m of messages) {
-    if (m.toolCalls?.length) n += m.toolCalls.length;
-  }
-  return n;
-}
-
-/**
- * Subscribe to elapsed time so the live "running…" status keeps updating
- * even when no new tokens arrive. Refreshes every second; the timer
- * shuts off as soon as the run has a `finishedAt`.
- */
-function useTickWhileRunning(run: SubagentRun): void {
-  const [, force] = useState(0);
-  useEffect(() => {
-    if (run.finishedAt) return;
-    const id = setInterval(() => force((n) => n + 1), 1000);
-    return () => clearInterval(id);
-  }, [run.finishedAt]);
-}
-
-export function SubagentBrowserPanel({ run, position, sessionTitle }: SubagentBrowserPanelProps) {
-  const theme = useTheme();
-  const { width, height } = useTerminalSize();
-  const viewRef = useRef<InkDOMElement>(null);
-  const contentRef = useRef<InkDOMElement>(null);
-  const measureKey = useMemo(
-    () => `${run.id}|${run.messages.length}|${run.status}`,
-    [run.id, run.messages.length, run.status],
-  );
-  const { viewHeight, contentHeight } = useMeasure(viewRef, contentRef, measureKey);
-  const { scrollOffset } = useScroll(contentHeight, viewHeight);
-
-  useTickWhileRunning(run);
-
-  const segments: StatusBarSegment[] = [
-    ...(position ? [{ text: `subagent ${position.index}/${position.total}`, align: 'left' as const, dim: true }] : []),
-    { text: `tool calls: ${countToolCalls(run.messages)}`, dim: true },
-    { text: formatElapsed(run), dim: true },
-    { text: 'Esc · chat | Ctrl+X →/← cycle', dim: true },
-  ];
-
-  const banner = (
-    <Box flexShrink={0} paddingX={1} borderStyle="single" borderColor={run.agentColor ?? theme.status.separator}>
-      <Box flexGrow={1}>
-        <Text color={run.agentColor} bold={true}>
-          ↳ {run.agentName}
-        </Text>
-        <Text dimColor={true}>{sessionTitle ? `  ·  ${sessionTitle}` : ''}</Text>
-        <Text dimColor={true}>{`  ·  ${run.id}`}</Text>
-      </Box>
-      <Text color={statusColor(run.status)} bold={true}>
-        {STATUS_LABEL[run.status]}
-      </Text>
-    </Box>
-  );
-
-  return (
-    <Box flexDirection="column" height={height} width={width}>
-      {banner}
-      <MessageView
-        viewRef={viewRef}
-        contentRef={contentRef}
-        messages={run.messages}
-        streaming={run.status === 'running'}
-        stream={{ text: '', reasoning: '', totalTokens: 0, cachedTokens: 0 }}
-        error={run.error ?? null}
-        scrollOffset={scrollOffset}
-        viewHeight={viewHeight}
-        contentHeight={contentHeight}
-      />
-      <StatusBar segments={segments} />
-    </Box>
-  );
-}
-
-/** Helper type used by `ChatPanelBody` when constructing the panel. */
-export type SubagentBrowserPanelComponent = typeof SubagentBrowserPanel;
-
-/** Wrap a `RefObject<DOMElement>` cast for callers that need it. */
-export type _SubagentBrowserRef = RefObject<InkDOMElement | null>;