ompchamber 1.2.1 → 2.0.1

package/src/client/components/workspace/git-panel/index.tsx

@@ -10,8 +10,8 @@ import { GitChangesList } from '@/client/components/workspace/git-panel/ChangesL
 import { ToastStack } from '@/client/components/common/ToastStack';
 import { useToasts } from '@/client/hooks/ui/toasts';
 import { useSessionState } from '@/client/hooks/workspace/session-state';
+import { resolveRepoForPanel, useRepoList, useRepoScope } from '@/client/hooks/workspace/repo-scope';
 import { usePanelRefresh, useFileMutationRefresh } from '@/client/hooks/workspace/panel-refresh';
-import { REPO_DISCOVERY_POLL_MS } from '@/shared/lib/workspace/refresh-cadence';
 import { useOnClickOutside } from '@/client/hooks/ui/on-click-outside';
 
 interface GitPanelProps {
@@ -22,15 +22,46 @@ interface GitPanelProps {
 }
 
 export function GitPanel({ className = '', enabled = true, rootPath, refreshKey = 0 }: GitPanelProps) {
-  const fetcher = useFetcher<{ changes: GitChange[], branch: string, branches: string[], remoteBranches?: string[], repos: string[], reposPending?: boolean, activeRepo: string, syncCount?: { ahead: number, behind: number } }>();
+  const fetcher = useFetcher<{ changes: GitChange[], branch: string, branches: string[], remoteBranches?: string[], syncCount?: { ahead: number, behind: number } }>();
   const actionFetcher = useFetcher<{ success: boolean, type?: string, data?: any, error?: string }>();
 
-  const [storedActiveRepo, setStoredActiveRepo, activeRepoReady] = useSessionState<string>('git.activeRepo', '.');
-  const activeRepo = fetcher.data?.activeRepo || storedActiveRepo || '.';
+  const { activeRepo: pickedRepo, setActiveRepo, ready: activeRepoReady } = useRepoScope(rootPath, 'git.activeRepo');
+  const { repos, scanning: reposScanning, rescan: refreshRepos } = useRepoList(rootPath, enabled);
+  // When the user has picked nothing and the workspace root is not itself a
+  // repo, git falls back to the first repo discovery found — the same choice
+  // the loader makes for a request that names no repo. Resolving it here rather
+  // than reading it back from the response is what keeps the header label, the
+  // picker's checkmark and the requests describing one repo: the response
+  // arrives a render later, and by then it may belong to a workspace the user
+  // has already left.
+  const activeRepo = resolveRepoForPanel(pickedRepo, repos);
+  const activeRepoRef = useRef(activeRepo);
+  activeRepoRef.current = activeRepo;
+
+  // `root\0repo` — the working tree the panel is showing right now.
+  const scopeRef = useRef('');
+  scopeRef.current = `${rootPath ?? ''}\u0000${activeRepo}`;
+  // The scope the in-flight read was asked for, and the scope the payload
+  // currently in `fetcher.data` was asked for. Only one read is ever in flight
+  // (the fetcher aborts its predecessor), so the former is what the latter
+  // becomes when a new payload arrives.
+  const requestedScopeRef = useRef('');
+  const payloadScopeRef = useRef('');
+  const lastPayloadRef = useRef<unknown>(undefined);
+  if (fetcher.data !== lastPayloadRef.current) {
+    lastPayloadRef.current = fetcher.data;
+    payloadScopeRef.current = requestedScopeRef.current;
+  }
+  // A switch leaves the previous repo's branch, changes and branch list in
+  // `fetcher.data` until the new read lands. Rendering those under the new
+  // repo's header would claim the new working tree is on the old branch with
+  // the old changes, so the payload is used only while it describes the scope
+  // on screen.
+  const data = payloadScopeRef.current === scopeRef.current ? fetcher.data : undefined;
 
   const loadRepo = (repo?: string) => {
     if (!enabled) return;
-    const targetRepo = repo !== undefined ? repo : storedActiveRepo;
+    const targetRepo = repo ?? activeRepoRef.current;
     const params = new URLSearchParams();
     if (rootPath) params.set('root', rootPath);
     if (targetRepo && targetRepo !== '.') params.set('repo', targetRepo);
@@ -39,6 +70,11 @@ export function GitPanel({ className = '', enabled = true, rootPath, refreshKey
     // numbers describe origin rather than the last fetch.
     params.set('sync', '1');
     params.set('t', String(Date.now()));
+    // Tag the response with the scope it was asked for: a switch leaves the
+    // previous repo's branch, changes and branch list in `fetcher.data` until
+    // the new read lands, and rendering those under the new repo's header
+    // claims the new working tree is on the old branch with the old changes.
+    requestedScopeRef.current = scopeRef.current;
     fetcher.load(`/api/fs/git?${params.toString()}`);
   };
   
@@ -66,70 +102,26 @@ export function GitPanel({ className = '', enabled = true, rootPath, refreshKey
 
   const { toasts, pushToast, dismissToast } = useToasts();
 
-  // Background nested-repo discovery polling: the loader returns immediately
-  // with the root status and `reposPending`; we poll the lightweight
-  // `?reposOnly=1` endpoint until the discoverer finishes, then refresh.
-  const [extraRepos, setExtraRepos] = useState<string[] | null>(null);
-  const [pollingRepos, setPollingRepos] = useState(false);
-  const [rescanningRepos, setRescanningRepos] = useState(false);
-
   useEffect(() => {
     setMounted(true);
   }, []);
 
+  // `activeRepo` is a dependency, not just the root: the repo list that
+  // resolves the root-level fallback arrives after the first render, and a
+  // workspace switch re-resolves it to '.'.
   useEffect(() => {
     if (!activeRepoReady) return;
-    loadRepo(storedActiveRepo);
-  }, [refreshKey, rootPath, enabled, activeRepoReady]);
+    loadRepo();
+  }, [refreshKey, rootPath, enabled, activeRepoReady, activeRepo]);
 
   // Auto refresh: keep the change list in step with external mutations
   // (terminal commits, agent edits) that never bump `refreshKey`. `loadRepo`
   // re-reads via `fetcher.load`, whose `t` param busts the cache; a load
   // already in flight is ignored by the loader so polls cannot pile up.
-  usePanelRefresh(() => loadRepo(storedActiveRepo), enabled && activeRepoReady);
+  usePanelRefresh(() => loadRepo(), enabled && activeRepoReady);
   // Agent edits/commits land between poll ticks: re-read right after a
   // file-mutating tool finishes so the change list tracks the AI's work.
-  useFileMutationRefresh(() => loadRepo(storedActiveRepo), enabled && activeRepoReady);
-
-  useEffect(() => {
-    if (fetcher.data?.activeRepo && fetcher.data.activeRepo !== storedActiveRepo) {
-      setStoredActiveRepo(fetcher.data.activeRepo);
-    }
-  }, [fetcher.data?.activeRepo, storedActiveRepo, setStoredActiveRepo]);
-
-  useEffect(() => {
-    if (fetcher.data?.reposPending) setPollingRepos(true);
-  }, [fetcher.data]);
-
-  // A forced rescan may finish before the polling interval kicks in; when that
-  // happens the loader returns the fresh repo list synchronously.
-  useEffect(() => {
-    if (
-      rescanningRepos &&
-      fetcher.data &&
-      !fetcher.data.reposPending &&
-      Array.isArray(fetcher.data.repos)
-    ) {
-      setExtraRepos(fetcher.data.repos);
-      setRescanningRepos(false);
-    }
-  }, [fetcher.data, rescanningRepos]);
-
-  useEffect(() => {
-    if (!pollingRepos) return;
-    const params = new URLSearchParams({ reposOnly: '1' });
-    if (rootPath) params.set('root', rootPath);
-    const id = setInterval(async () => {
-      const data = await fetch(`/api/fs/git?${params.toString()}`).then(r => r.json()).catch(() => null);
-      if (data && !data.reposPending && Array.isArray(data.repos)) {
-        setExtraRepos(data.repos);
-        setPollingRepos(false);
-        setRescanningRepos(false);
-        loadRepo(storedActiveRepo);
-      }
-    }, REPO_DISCOVERY_POLL_MS);
-    return () => clearInterval(id);
-  }, [pollingRepos, rootPath, storedActiveRepo]);
+  useFileMutationRefresh(() => loadRepo(), enabled && activeRepoReady);
 
   // Focus input when branch prompt opens
   useEffect(() => {
@@ -146,7 +138,7 @@ export function GitPanel({ className = '', enabled = true, rootPath, refreshKey
       } else if (actionFetcher.data.type === 'graph') {
         setViewingOutput({ title: 'Git Graph', data: actionFetcher.data.data || [] });
       } else if (actionFetcher.data.success) {
-        loadRepo(activeRepo);
+        loadRepo();
       } else {
         pushToast(actionFetcher.data.error || 'Git operation failed');
       }
@@ -188,11 +180,10 @@ export function GitPanel({ className = '', enabled = true, rootPath, refreshKey
     }
   };
 
-  const branch = fetcher.data?.branch || 'main';
-  const branches = fetcher.data?.branches || ['main'];
-  const remoteBranches = fetcher.data?.remoteBranches || [];
-  const repos = extraRepos ?? (fetcher.data?.repos || ['.']);
-  const changes = fetcher.data?.changes || [];
+  const branch = data?.branch || 'main';
+  const branches = data?.branches || ['main'];
+  const remoteBranches = data?.remoteBranches || [];
+  const changes = data?.changes || [];
   const isLoading = fetcher.state === 'loading' || actionFetcher.state !== 'idle';
 
   const stagedChanges = changes.filter(c => {
@@ -200,17 +191,6 @@ export function GitPanel({ className = '', enabled = true, rootPath, refreshKey
     return status && status[0] !== ' ' && status[0] !== '?';
   });
 
-  const refreshRepos = () => {
-    if (!enabled || pollingRepos || rescanningRepos) return;
-    setExtraRepos(repos);
-    setRescanningRepos(true);
-    const params = new URLSearchParams({ rescan: '1', sync: '1' });
-    if (rootPath) params.set('root', rootPath);
-    if (activeRepo !== '.') params.set('repo', activeRepo);
-    params.set('t', String(Date.now()));
-    fetcher.load(`/api/fs/git?${params.toString()}`);
-  };
-
   if (!enabled) {
     return (
       <div className={`flex flex-col h-full bg-paper items-center justify-center text-ink/40 ${className}`}>
@@ -276,12 +256,14 @@ export function GitPanel({ className = '', enabled = true, rootPath, refreshKey
         repos={repos}
         isLoading={isLoading}
         rootPath={rootPath}
-        reposScanning={pollingRepos || rescanningRepos}
+        reposScanning={reposScanning}
         onSelectRepo={(r) => {
-          setStoredActiveRepo(r);
-          loadRepo(r);
+          // The reload is the scope effect's job: it fires on the resolved
+          // `activeRepo` change, so selecting here would fetch the same repo
+          // twice.
+          if (r !== activeRepo) setActiveRepo(r);
         }}
-        onRefresh={() => loadRepo(activeRepo)}
+        onRefresh={() => loadRepo()}
         onRefreshRepos={refreshRepos}
       />
       
@@ -303,7 +285,7 @@ export function GitPanel({ className = '', enabled = true, rootPath, refreshKey
         viewMode={viewMode}
         setViewMode={setViewMode}
         isBusy={isLoading}
-        syncCount={fetcher.data?.syncCount}
+        syncCount={data?.syncCount}
         onSync={() => executeAction('sync')}
       />
 

package/src/client/components/workspace/terminal-panel/Header.tsx

@@ -8,6 +8,11 @@ interface TerminalHeaderProps {
   rootPath?: string;
   activeRepo: string;
   onSelectRepo: (repo: string) => void;
+  /** Discovered repos of the active root; the panel owns discovery. */
+  repos: string[];
+  /** Discovery or a forced rescan is in flight. */
+  reposScanning: boolean;
+  onRefreshRepos: () => void;
   /** Working directory the shell actually runs in. */
   cwd?: string;
   shell?: string;
@@ -35,6 +40,9 @@ export function TerminalHeader({
   rootPath,
   activeRepo,
   onSelectRepo,
+  repos,
+  reposScanning,
+  onRefreshRepos,
   cwd,
   shell,
   gitBranch,
@@ -60,7 +68,14 @@ export function TerminalHeader({
           <span>{status === 'exited' && exitCode !== null ? `EXIT ${exitCode}` : STATUS_LABEL[status]}</span>
         </span>
 
-        <GitRepoDropdown rootPath={rootPath} activeRepo={activeRepo} onSelectRepo={onSelectRepo} />
+        <GitRepoDropdown
+          rootPath={rootPath}
+          activeRepo={activeRepo}
+          onSelectRepo={onSelectRepo}
+          repos={repos}
+          scanning={reposScanning}
+          onRefreshRepos={onRefreshRepos}
+        />
 
         <button
           type="button"

package/src/client/components/workspace/terminal-panel/RealtimeXtermView.tsx

@@ -40,7 +40,7 @@ interface RealtimeXtermViewProps {
  */
 export const RealtimeXtermView = forwardRef<RealtimeXtermHandle, RealtimeXtermViewProps>(
   ({ onInput, onBinaryInput, onGridChange, onReady }, ref) => {
-    const { isDark } = useTheme();
+    const { theme } = useTheme();
     const containerRef = useRef<HTMLDivElement>(null);
     const mountRef = useRef<XtermMount | null>(null);
     const [isScrolledUp, setIsScrolledUp] = useState(false);
@@ -53,15 +53,15 @@ export const RealtimeXtermView = forwardRef<RealtimeXtermHandle, RealtimeXtermVi
     gridChangeRef.current = onGridChange;
     const readyRef = useRef(onReady);
     readyRef.current = onReady;
-    const themeRef = useRef(isDark);
-    themeRef.current = isDark;
+    const themeRef = useRef(theme);
+    themeRef.current = theme;
 
     useEffect(() => {
       const term = mountRef.current?.term;
       if (!term) return;
-      term.options.theme = getXtermTheme(isDark);
+      term.options.theme = getXtermTheme(theme);
       term.refresh(0, term.rows - 1);
-    }, [isDark]);
+    }, [theme]);
 
     useImperativeHandle(ref, () => ({
       write(bytes: Uint8Array) {

package/src/client/components/workspace/terminal-panel/index.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useRef } from 'preact/hooks';
 import { useTerminal } from '@/client/hooks/workspace/terminal';
-import { useSessionState } from '@/client/hooks/workspace/session-state';
+import { useRepoList, useRepoScope } from '@/client/hooks/workspace/repo-scope';
 import { useTheme } from '@/client/hooks/ui/theme';
 import { TerminalHeader } from '@/client/components/workspace/terminal-panel/Header';
 import { TerminalQuickActions } from '@/client/components/workspace/terminal-panel/QuickActions';
@@ -18,7 +18,8 @@ const encoder = new TextEncoder();
 export function TerminalPanel({ className = '', enabled = true, rootPath, showHeader = true }: TerminalPanelProps) {
   const xtermRef = useRef<RealtimeXtermHandle>(null);
   const { isDark } = useTheme();
-  const [activeRepo, setActiveRepo] = useSessionState<string>('terminal.activeRepo', '.');
+  const { activeRepo, setActiveRepo } = useRepoScope(rootPath, 'terminal.activeRepo');
+  const { repos, scanning: reposScanning, rescan: rescanRepos } = useRepoList(rootPath, enabled);
   const gridRef = useRef<{ cols: number; rows: number } | null>(null);
 
   const handleOutput = useCallback((bytes: Uint8Array) => {
@@ -105,6 +106,9 @@ export function TerminalPanel({ className = '', enabled = true, rootPath, showHe
           rootPath={rootPath}
           activeRepo={activeRepo}
           onSelectRepo={setActiveRepo}
+          repos={repos}
+          reposScanning={reposScanning}
+          onRefreshRepos={rescanRepos}
           cwd={cwd}
           shell={shell}
           gitBranch={systemInfo.gitBranch}

package/src/client/components/workspace/terminal-panel/mount.ts

@@ -71,7 +71,7 @@ export interface XtermMount {
  */
 export async function mountXterm(
   container: HTMLElement,
-  isDark: boolean,
+  themeId: string,
   callbacks: XtermMountCallbacks,
   isCancelled: () => boolean,
 ): Promise<XtermMount | null> {
@@ -93,7 +93,7 @@ export async function mountXterm(
     fontSize: 12,
     lineHeight: 1.25,
     fontFamily: XTERM_FONT_FAMILY,
-    theme: getXtermTheme(isDark),
+    theme: getXtermTheme(themeId),
     // No `convertEol`: the PTY already emits CRLF, and converting a lone LF
     // would re-introduce the line-feed doubling a real terminal avoids.
     scrollback: 10000,

package/src/client/data/theme/terminal.ts

@@ -1,58 +1,56 @@
-export const XTERM_LIGHT_THEME = {
-  background: '#f4f1ea',
-  foreground: '#141310',
-  cursor: '#141310',
-  cursorAccent: '#f4f1ea',
-  selectionBackground: '#ded8ce',
-  selectionForeground: '#141310',
-  black: '#141310',
-  red: '#c8321e',
-  green: '#047857',
-  yellow: '#b45309',
-  blue: '#1d4ed8',
-  magenta: '#9333ea',
-  cyan: '#0284c7',
-  white: '#faf8f3',
-  brightBlack: '#78716c',
-  brightRed: '#dc2626',
-  brightGreen: '#059669',
-  brightYellow: '#d97706',
-  brightBlue: '#2563eb',
-  brightMagenta: '#a855f7',
-  brightCyan: '#0ea5e9',
-  brightWhite: '#292524',
-};
+import { mixHex } from '@/shared/lib/theme/color';
+import { resolveTheme } from '@/shared/lib/theme/catalog';
 
-export const XTERM_DARK_THEME = {
-  background: '#21252b',
-  foreground: '#abb2bf',
-  cursor: '#528bff',
-  cursorAccent: '#21252b',
-  selectionBackground: '#3e4451',
-  selectionForeground: '#abb2bf',
-  black: '#282c34',
-  red: '#e06c75',
-  green: '#98c379',
-  yellow: '#e5c07b',
-  blue: '#61afef',
-  magenta: '#c678dd',
-  cyan: '#56b6c2',
-  white: '#abb2bf',
-  brightBlack: '#5c6370',
-  brightRed: '#e06c75',
-  brightGreen: '#98c379',
-  brightYellow: '#e5c07b',
-  brightBlue: '#61afef',
-  brightMagenta: '#c678dd',
-  brightCyan: '#56b6c2',
-  brightWhite: '#ffffff',
-};
+/**
+ * The terminal palette for a theme, derived from the same eight colors the rest
+ * of the app paints with.
+ *
+ * xterm parses its own colors and understands only literal notations (hex,
+ * `rgb()`, `hsl()`, named) — `color-mix()` is not among them in either the DOM
+ * or the WebGL renderer — so every blend is computed here in hex instead of
+ * being left to CSS. The result follows the active theme rather than a fixed
+ * light/dark pair: a Nord terminal is Nord, and switching themes repaints the
+ * scrollback instead of leaving the previous palette on screen.
+ *
+ * ANSI slots map onto the semantic colors the palette does carry (red=error,
+ * green=success, yellow=warning, blue=info, magenta=accent); `cyan` has no
+ * counterpart, so it is a deterministic mix of info and success, and the
+ * grayscale slots are mixes of ink over canvas. "Bright" variants mix 20% toward
+ * the foreground, which is lighter on a dark theme and darker on a light one —
+ * the direction that increases contrast on both.
+ */
+export function getXtermTheme(themeId: string) {
+  const palette = resolveTheme(themeId);
+  const { canvas, ink } = palette;
 
-export function getXtermTheme(isDark: boolean) {
-  return isDark ? XTERM_DARK_THEME : XTERM_LIGHT_THEME;
-}
+  const towardInk = (color: string) => mixHex(color, ink, 0.2);
+  const grayscale = (ratio: number) => mixHex(canvas, ink, ratio);
 
-export const XTERM_THEME = XTERM_DARK_THEME;
+  return {
+    background: canvas,
+    foreground: ink,
+    cursor: palette.meta,
+    cursorAccent: canvas,
+    selectionBackground: grayscale(0.28),
+    selectionForeground: ink,
+    black: grayscale(0.2),
+    red: palette.error,
+    green: palette.success,
+    yellow: palette.warning,
+    blue: palette.info,
+    magenta: palette.meta,
+    cyan: mixHex(palette.info, palette.success, 0.5),
+    white: grayscale(0.75),
+    brightBlack: grayscale(0.5),
+    brightRed: towardInk(palette.error),
+    brightGreen: towardInk(palette.success),
+    brightYellow: towardInk(palette.warning),
+    brightBlue: towardInk(palette.info),
+    brightMagenta: towardInk(palette.meta),
+    brightCyan: towardInk(mixHex(palette.info, palette.success, 0.5)),
+    brightWhite: grayscale(0.92),
+  };
+}
 
 /**
  * Font stack for the terminal canvas.

package/src/client/hooks/chat/btw/index.ts

@@ -15,18 +15,50 @@
  */
 
 import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
-import type { AgentImage, BtwState, StreamTransport } from '@/shared/types';
-import { BtwRequestError, abortBtwQuestion, askBtwQuestion, connectBtwStream, deleteBtwTopic, fetchBtwState, promoteBtwTopic } from '@/shared/lib/chat/btw/client';
+import type { AgentImage, Attachment, BtwState, ChatMessageData, StreamTransport } from '@/shared/types';
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import { attachmentImage, readTextAttachments } from '@/shared/lib/chat/attachments';
+import {
+  BtwRequestError,
+  abortBtwQuestion,
+  askBtwQuestion,
+  connectBtwStream,
+  deleteBtwTopic,
+  fetchBtwState,
+  promoteBtwTopic,
+  respondBtwDialog,
+  setBtwAccessMode,
+  setBtwModel,
+  setBtwThinkingLevel,
+} from '@/shared/lib/chat/btw/client';
 import type { StreamConnection } from '@/shared/lib/chat/omp/transport';
 
 /** Images the side session accepts, already read as base64. */
 export type BtwImage = AgentImage;
 
-/** The turn streaming right now; `text` accumulates its deltas. */
+/**
+ * The turn streaming right now. `messages` is the turn's conversation in the
+ * chat's own shape, upserted by `message.id` exactly as the chat stream does —
+ * so the panel renders a live side answer through the same components the chat
+ * uses, tool calls included.
+ */
 export interface BtwLiveAnswer {
   topicId: string;
   turnIndex: number;
-  text: string;
+  messages: ChatMessageData[];
+  /** Activity phrase for the panel's indicator, from the side child's frames. */
+  activity: string;
+}
+
+/**
+ * Composer picks for a topic's FIRST question. A topic that does not exist yet
+ * has no row to write them to, so they ride the ask and reach the spawn; later
+ * questions address an existing topic through the dedicated setters.
+ */
+export interface BtwFirstQuestionPicks {
+  model?: { provider: string; id: string };
+  thinkingLevel?: string;
+  approvalMode?: ApprovalMode;
 }
 
 export interface BtwSessionHandle {
@@ -37,8 +69,12 @@ export interface BtwSessionHandle {
   busy: boolean;
   /** Resolves with the canonical state the command produced, or null when it
    *  was refused (the reason is then in `error`). */
-  ask: (question: string, images?: BtwImage[], topicId?: string) => Promise<BtwState | null>;
+  ask: (question: string, attachments?: Attachment[], topicId?: string, picks?: BtwFirstQuestionPicks) => Promise<BtwState | null>;
   abort: (topicId: string) => Promise<void>;
+  setModel: (topicId: string, provider: string, modelId: string) => Promise<void>;
+  setThinkingLevel: (topicId: string, level: string) => Promise<void>;
+  setAccessMode: (topicId: string, mode: ApprovalMode) => Promise<void>;
+  respondToDialog: (topicId: string, id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => Promise<void>;
   /** Returns the new session id to open, or null when it was refused. */
   promote: (topicId: string) => Promise<string | null>;
   remove: (topicId: string) => Promise<void>;
@@ -74,20 +110,39 @@ export function useBtwSession(sessionId: string | null, options: BtwSessionOptio
         switch (frame.type) {
           case 'btw_state':
             setState(frame.state);
-            // A settled turn's text is in the snapshot now; holding the live
-            // buffer any longer would keep painting the partial answer.
+            // The snapshot carries the running turn's conversation, so a client
+            // attaching mid-turn (a reload, a second tab) shows the answer the
+            // child already produced instead of an empty bubble. A snapshot with
+            // no live turn ends the local buffer — the persisted rows own it now.
+            setLive(frame.state.live
+              ? {
+                  topicId: frame.state.live.topicId,
+                  turnIndex: frame.state.live.turnIndex,
+                  messages: frame.state.live.messages,
+                  activity: frame.state.live.activity,
+                }
+              : null);
+            break;
+          case 'btw_message':
+            // Same upsert the chat stream performs: omp emits one frame per
+            // segment carrying that segment's full accumulated content, so a
+            // same-id frame replaces in place and a new id appends.
             setLive((current) => {
-              if (!current) return null;
-              const topic = frame.state.topics.find((candidate) => candidate.id === current.topicId);
-              const turn = topic?.turns.find((candidate) => candidate.index === current.turnIndex);
-              return turn && turn.status === 'running' ? current : null;
+              const base =
+                current && current.topicId === frame.topicId && current.turnIndex === frame.turnIndex
+                  ? current
+                  : { topicId: frame.topicId, turnIndex: frame.turnIndex, messages: [], activity: '' };
+              const existing = base.messages.findIndex((message) => message.id === frame.message.id);
+              const messages =
+                existing === -1
+                  ? [...base.messages, frame.message]
+                  : [...base.messages.slice(0, existing), frame.message, ...base.messages.slice(existing + 1)];
+              return { ...base, messages };
             });
             break;
-          case 'btw_delta':
+          case 'btw_activity':
             setLive((current) =>
-              current && current.topicId === frame.topicId && current.turnIndex === frame.turnIndex
-                ? { ...current, text: current.text + frame.text }
-                : { topicId: frame.topicId, turnIndex: frame.turnIndex, text: frame.text },
+              current && current.topicId === frame.topicId ? { ...current, activity: frame.verb } : current,
             );
             break;
           case 'btw_error':
@@ -127,9 +182,29 @@ export function useBtwSession(sessionId: string | null, options: BtwSessionOptio
   );
 
   const ask = useCallback(
-    async (question: string, images?: BtwImage[], topicId?: string): Promise<BtwState | null> => {
+    async (
+      question: string,
+      attachments: Attachment[] = [],
+      topicId?: string,
+      picks?: BtwFirstQuestionPicks,
+    ): Promise<BtwState | null> => {
       setError(null);
-      const next = await run((id) => askBtwQuestion(id, { question, images, topicId }));
+      // Same split the chat send path makes: images travel as provider payloads,
+      // text files are inlined into the prompt. Both are read here, from the
+      // attachments the composer already filled in at attach time.
+      const images = attachments
+        .map((attachment) => attachmentImage(attachment))
+        .filter((image): image is NonNullable<typeof image> => image !== null);
+      const textFiles = (await readTextAttachments(attachments)).filter((file) => !file.missing);
+      const next = await run((id) => askBtwQuestion(id, {
+        question,
+        topicId,
+        ...(images.length ? { images } : {}),
+        ...(textFiles.length ? { textFiles } : {}),
+        // Only a first question carries picks; a follow-up addresses a topic
+        // that already owns them.
+        ...(topicId ? {} : picks ?? {}),
+      }));
       setLive(null);
       if (next && !next.runningTopicId) {
         setError('The side question was accepted but did not start running.');
@@ -147,6 +222,38 @@ export function useBtwSession(sessionId: string | null, options: BtwSessionOptio
     [run],
   );
 
+  const setModel = useCallback(
+    async (topicId: string, provider: string, modelId: string) => {
+      setError(null);
+      await run((id) => setBtwModel(id, topicId, provider, modelId));
+    },
+    [run],
+  );
+
+  const setThinkingLevel = useCallback(
+    async (topicId: string, level: string) => {
+      setError(null);
+      await run((id) => setBtwThinkingLevel(id, topicId, level));
+    },
+    [run],
+  );
+
+  const setAccessMode = useCallback(
+    async (topicId: string, mode: ApprovalMode) => {
+      setError(null);
+      await run((id) => setBtwAccessMode(id, topicId, mode));
+    },
+    [run],
+  );
+
+  const respondToDialog = useCallback(
+    async (topicId: string, id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => {
+      setError(null);
+      await run((requestId) => respondBtwDialog(requestId, topicId, id, response));
+    },
+    [run],
+  );
+
   const remove = useCallback(
     async (topicId: string) => {
       setError(null);
@@ -176,5 +283,19 @@ export function useBtwSession(sessionId: string | null, options: BtwSessionOptio
 
   const clearError = useCallback(() => setError(null), []);
 
-  return { state, live, error, busy, ask, abort, promote, remove, clearError };
+  return {
+    state,
+    live,
+    error,
+    busy,
+    ask,
+    abort,
+    setModel,
+    setThinkingLevel,
+    setAccessMode,
+    respondToDialog,
+    promote,
+    remove,
+    clearError,
+  };
 }