ompchamber 0.7.0 → 1.0.0

package/src/client/components/mobile/mobile-session-sidebar/List.tsx

@@ -7,7 +7,7 @@ interface MobileSessionListProps {
   activeSessionId: number | string | null;
   expandedFolders: Record<number, boolean>;
   showArchived: boolean;
-  sessionStatus: Record<string, 'stream' | 'finish' | 'abort' | 'error'>;
+  sessionStatus: Record<string, 'stream' | 'finish' | 'abort'>;
   isScrolling: boolean;
   onScroll: () => void;
   onSelectSession: (id: number | string) => void;

package/src/client/components/mobile/mobile-session-sidebar/SessionRow.tsx

@@ -5,7 +5,7 @@ import { useInlineRename } from '@/client/hooks/ui/inline-rename';
 export interface MobileSessionRowProps {
   session: SessionItemData;
   isActive: boolean;
-  status?: 'stream' | 'finish' | 'abort' | 'error';
+  status?: 'stream' | 'finish' | 'abort';
   /** Relative age of the session, or null when no usable timestamp exists. */
   timeAgo: string | null;
   showTreeGlyph?: boolean;
@@ -64,7 +64,7 @@ export function MobileSessionRow({
         <div className="flex items-center space-x-1.5 min-w-0 pr-2">
           <span className="w-4 flex-shrink-0 flex items-center justify-center">
             {status === 'stream' && <Loader2 size={13} className="text-ink/50 animate-spin" />}
-            {(status === 'finish' || status === 'abort' || status === 'error') && <Check size={13} className="text-ink/50" />}
+            {(status === 'finish' || status === 'abort') && <Check size={13} className="text-ink/50" />}
           </span>
           {showTreeGlyph && <span className="text-ink/40 text-xs flex-shrink-0 font-mono">&gt;</span>}
           <span className="text-xs truncate leading-snug">

package/src/client/components/settings/LazyModal.tsx

@@ -24,7 +24,7 @@
  * the stale bootstrap payload.
  *
  * `fallback={null}` matches the other lazy dialog boundary
- * (`tool-renderers/ask-dialog/Lazy.tsx`): the modal is a full-screen overlay
+ * (`tool-renderers/extension-dialog/Lazy.tsx`): the modal is a full-screen overlay
  * that appears on user intent, so a brief absence reads as the click landing
  * rather than as a broken surface.
  */

package/src/client/components/settings/Modal.tsx

@@ -3,6 +3,7 @@ import { Check, ChevronLeft, X } from 'lucide-preact';
 import type { SettingsCategoryId, SettingsState } from '@/shared/types';
 import { mergeChamberSettings } from '@/shared/lib/settings/client';
 import { useChamberSettingsWriter } from '@/client/hooks/settings/use-chamber-setting';
+import { applyDocumentTheme } from '@/client/hooks/ui/theme';
 import { useChamberEvent } from '@/client/hooks/ui/window-event';
 import { SETTINGS_CATEGORIES, SettingsSidebar } from '@/client/components/settings/Sidebar';
 import { AppearanceSettings } from '@/client/components/settings/categories/AppearanceSettings';
@@ -100,7 +101,7 @@ export function SettingsModal({
     setSettings(prev => {
       const next = typeof updater === 'function' ? updater(prev) : { ...prev, ...updater };
       if (typeof document !== 'undefined' && next.theme) {
-        document.documentElement.dataset.theme = next.theme;
+        applyDocumentTheme(next.theme);
       }
       writeChamberSettings(next);
       return next;

package/src/client/components/workspace/chat-timeline/ComposerDock.tsx

@@ -13,7 +13,8 @@ interface ComposerDockProps {
   provider?: string;
   providerNames?: Record<string, string>;
   messageQueue: QueuedMessage[];
-  setMessageQueue: Dispatch<SetStateAction<QueuedMessage[]>>;
+  onRemoveQueueItem: (id: string) => void;
+  onReorderQueue: (orderedIds: string[]) => void;
   onEditQueueItem: (item: QueuedMessage) => void;
   onSendNowQueueItem: (item: QueuedMessage) => void;
   steeringQueue: QueuedMessage[];
@@ -49,7 +50,8 @@ export function ComposerDock({
   provider,
   providerNames,
   messageQueue,
-  setMessageQueue,
+  onRemoveQueueItem,
+  onReorderQueue,
   onEditQueueItem,
   onSendNowQueueItem,
   steeringQueue,
@@ -87,13 +89,18 @@ export function ComposerDock({
         )}
         <QueueList
           queue={messageQueue}
-          setQueue={setMessageQueue}
+          onRemove={onRemoveQueueItem}
+          onReorder={onReorderQueue}
           onEdit={onEditQueueItem}
           onSendNow={onSendNowQueueItem}
         />
         <QueueList
           queue={steeringQueue}
-          setQueue={setSteeringQueue}
+          onRemove={(id) => setSteeringQueue((q) => q.filter((i) => i.id !== id))}
+          onReorder={(orderedIds) => setSteeringQueue((prev) => {
+            const byId = new Map(prev.map((i) => [i.id, i]));
+            return orderedIds.map((id) => byId.get(id)).filter((i): i is QueuedMessage => Boolean(i));
+          })}
           isSteering
         />
         <ChatInput

package/src/client/components/workspace/chat-timeline/QueueList.tsx

@@ -1,4 +1,3 @@
-import type { Dispatch, SetStateAction } from 'preact/compat';
 import { useRef } from 'preact/hooks';
 import { GripVertical, Pencil, Send, X } from 'lucide-preact';
 import type { QueuedMessage } from '@/shared/types';
@@ -7,7 +6,10 @@ export type { QueuedMessage };
 
 interface QueueListProps {
   queue: QueuedMessage[];
-  setQueue: Dispatch<SetStateAction<QueuedMessage[]>>;
+  /** Reorder handler (drag-and-drop): receives the new id order. */
+  onReorder?: (orderedIds: string[]) => void;
+  /** Remove one row by id. */
+  onRemove?: (id: string) => void;
   /** True when every row in this panel is a steering delivery. */
   isSteering?: boolean;
   onEdit?: (item: QueuedMessage) => void;
@@ -20,18 +22,18 @@ const KIND_LABEL: Record<string, string> = {
   followup: 'follow-up',
 };
 
-export function QueueList({ queue, setQueue, isSteering = false, onEdit, onSendNow }: QueueListProps) {
+export function QueueList({ queue, onReorder, onRemove, isSteering = false, onEdit, onSendNow }: QueueListProps) {
   const dragItem = useRef<number | null>(null);
   const dragOverItem = useRef<number | null>(null);
 
   const handleSort = () => {
     if (dragItem.current === null || dragOverItem.current === null) return;
-    const _queue = [...queue];
-    const draggedItemContent = _queue.splice(dragItem.current, 1)[0];
-    _queue.splice(dragOverItem.current, 0, draggedItemContent);
+    const ids = queue.map((i) => i.id);
+    const draggedId = ids.splice(dragItem.current, 1)[0];
+    ids.splice(dragOverItem.current, 0, draggedId);
     dragItem.current = null;
     dragOverItem.current = null;
-    setQueue(_queue);
+    onReorder?.(ids);
   };
 
   if (queue.length === 0) return null;
@@ -80,13 +82,15 @@ export function QueueList({ queue, setQueue, isSteering = false, onEdit, onSendN
               <Pencil size={12} />
             </button>
           )}
-          <button
-            onClick={() => setQueue(q => q.filter(i => i.id !== item.id))}
-            className="text-ink/40 hover:text-error opacity-0 group-hover:opacity-100 transition-opacity"
-            title="Remove"
-          >
-            <X size={14} />
-          </button>
+          {onRemove && (
+            <button
+              onClick={() => onRemove(item.id)}
+              className="text-ink/40 hover:text-error opacity-0 group-hover:opacity-100 transition-opacity"
+              title="Remove"
+            >
+              <X size={14} />
+            </button>
+          )}
         </div>
       ))}
     </div>

package/src/client/components/workspace/chat-timeline/ToolCallCard.tsx

@@ -13,6 +13,7 @@ import { FallbackOutput } from '@/client/components/workspace/chat-timeline/tool
 import { tryParseJson } from '@/shared/lib/code/syntax-highlight';
 import { JsonCodeBlock } from '@/client/components/workspace/chat-timeline/tool-renderers/shared/JsonCodeBlock';
 import { getTodoSummary } from '@/shared/lib/chat/todo-parser';
+import { parseAskQuestions } from '@/shared/lib/chat/ask-questions';
 
 interface ToolCallCardProps {
   tool: ToolCallData;
@@ -199,6 +200,12 @@ export const ToolCallCard = memo(function ToolCallCard({ tool, isOpen, onToggle,
         .join(' · ');
       displaySubtitle = cleaned || sub;
     }
+  } else if (toolKey === 'ask') {
+    // The question itself is the card's body; the header says how many were
+    // asked, matching the summary the same card shows once they are answered.
+    displayTitle = 'Question';
+    const asked = parseAskQuestions(tool).length;
+    if (asked > 0) displaySubtitle = `Asked ${asked} question${asked === 1 ? '' : 's'}`;
   } else if (mcpToolNameOf(tool)) {
     // MCP call: `write xd://mcp__<tool>` (or a direct `mcp__<tool>` name) —
     // the MCP tool names the action, never the transport `write`.
@@ -258,7 +265,7 @@ export const ToolCallCard = memo(function ToolCallCard({ tool, isOpen, onToggle,
       isOpen={isOpen}
       onToggle={onToggle ? handleToggle : undefined}
       defaultExpanded={defaultExpanded}
-      alwaysExpanded={toolKey === 'yield' && hasPanel}
+      alwaysExpanded={hasPanel && (toolKey === 'yield' || toolKey === 'ask')}
     >
       <ToolDetailsPanel tool={tool} />
 

package/src/client/components/workspace/chat-timeline/chat-input/index.tsx

@@ -7,6 +7,7 @@ import { ComposerTextarea } from '@/client/components/common/ComposerTextarea';
 import { AttachmentToolbar } from '@/client/components/workspace/chat-timeline/chat-input/AttachmentToolbar';
 import { selectableThinkingLevels } from '@/shared/lib/models/thinking-levels';
 import { fetchModelsData, subscribeModelsUpdated } from '@/shared/lib/models/client';
+import { resolveThinkingLevel, selectionFor } from '@/client/components/workspace/chat-timeline/chat-input/selection';
 
 export function ChatInput({ 
   value, 
@@ -96,21 +97,11 @@ export function ChatInput({
   const sessionModelRef = useRef<{ provider: string; modelId: string } | null>(sessionModel ?? null);
   sessionModelRef.current = sessionModel ?? null;
 
-  // Preserve the session's last-used thinking level when applying a model
-  // picked from the catalog: the session level is authoritative and an async
-  // fetch resolving later must not reset it to the ladder default.
-  const resolveSessionLevel = (ladder: readonly string[] | undefined, fallback: string): string => {
-    const sessionLevel = sessionThinkingLevelRef.current;
-    if (!sessionLevel) return fallback;
-    const selectable = selectableThinkingLevels(ladder ?? []);
-    return selectable.length === 0 || selectable.includes(sessionLevel) ? sessionLevel : fallback;
-  };
-
   // Adopt the active session's last-used model as the selected model. The
-  // thinking level must fall back to the CURRENT one, never the ladder
-  // default: this effect re-runs right after a spawn (sessionModel changes
-  // while the session's own thinking_level_change entry is not written yet),
-  // and an `off` fallback here is the "thinking resets to off on send" bug.
+  // thinking level must fall back to the CURRENT one, never the ladder default:
+  // this effect re-runs right after a spawn (sessionModel changes while the
+  // session's own thinking_level_change entry is not readable yet), and any
+  // concrete fallback here claims a level the run never used.
   useEffect(() => {
     if (!sessionModel?.provider || !sessionModel.modelId) return;
     let active = true;
@@ -121,14 +112,7 @@ export function ChatInput({
           (m) => m.id === sessionModel.modelId && m.provider === sessionModel.provider
         );
         if (match) {
-          setSelectedModel(prev => ({
-            id: match.id,
-            name: match.name,
-            provider: match.provider,
-            contextWindow: match.contextWindow,
-            thinkingLevels: match.thinkingLevels,
-            thinkingLevel: resolveSessionLevel(match.thinkingLevels, prev?.thinkingLevel ?? match.thinkingLevels?.[0] ?? 'off'),
-          }));
+          setSelectedModel(prev => selectionFor(match, sessionThinkingLevelRef.current, prev));
         }
       })
       .catch(() => {});
@@ -143,14 +127,7 @@ export function ChatInput({
     if (!sessionThinkingLevel) return;
     setSelectedModel(prev => {
       if (!prev) return prev;
-      const selectable = selectableThinkingLevels(prev.thinkingLevels ?? []);
-      // The session level is authoritative (omp recorded it for this model).
-      // Only reject it when the ladder is KNOWN and explicitly excludes it;
-      // an empty ladder (catalog not resolved / model exposes none) must not
-      // fall back to 'off' and erase the session's actual level.
-      const level = selectable.length === 0 || selectable.includes(sessionThinkingLevel)
-        ? sessionThinkingLevel
-        : prev.thinkingLevel;
+      const level = resolveThinkingLevel(prev.thinkingLevels, sessionThinkingLevel, prev.thinkingLevel);
       return level === prev.thinkingLevel ? prev : { ...prev, thinkingLevel: level };
     });
   }, [sessionThinkingLevel]);
@@ -169,13 +146,7 @@ export function ChatInput({
           if (sm?.provider && sm.modelId) {
             const match = data.modelList.find((m: ModelEntry) => m.id === sm.modelId && m.provider === sm.provider);
             if (match) {
-              setSelectedModel(prev => ({
-                id: match.id,
-                name: match.name,
-                provider: match.provider,
-                thinkingLevels: match.thinkingLevels,
-                thinkingLevel: resolveSessionLevel(match.thinkingLevels, prev?.thinkingLevel ?? match.thinkingLevels?.[0] ?? 'off'),
-              }));
+              setSelectedModel(prev => selectionFor(match, sessionThinkingLevelRef.current, prev));
             }
             return;
           }
@@ -184,13 +155,7 @@ export function ChatInput({
           if (persisted?.provider && persisted.id) {
             const match = data.modelList.find((m: ModelEntry) => m.id === persisted.id && m.provider === persisted.provider);
             if (match) {
-              setSelectedModel(prev => ({
-                id: match.id,
-                name: match.name,
-                provider: match.provider,
-                thinkingLevels: match.thinkingLevels,
-                thinkingLevel: resolveSessionLevel(match.thinkingLevels, prev?.thinkingLevel ?? match.thinkingLevels?.[0] ?? 'off'),
-              }));
+              setSelectedModel(prev => selectionFor(match, sessionThinkingLevelRef.current, prev));
               return;
             }
           }
@@ -199,20 +164,14 @@ export function ChatInput({
           if (defaultModel) {
             const match = data.modelList.find((m: ModelEntry) => m.id === defaultModel.modelId && m.provider === defaultModel.provider);
             if (match) {
-              setSelectedModel(prev => ({
-                id: match.id,
-                name: match.name,
-                provider: match.provider,
-                thinkingLevels: match.thinkingLevels,
-                thinkingLevel: resolveSessionLevel(match.thinkingLevels, prev?.thinkingLevel ?? match.thinkingLevels?.[0] ?? 'off'),
-              }));
+              setSelectedModel(prev => selectionFor(match, sessionThinkingLevelRef.current, prev));
             }
           }
         } else if (data.selectedModel) {
           const selected = data.selectedModel;
           setSelectedModel(prev => ({
             ...selected,
-            thinkingLevel: resolveSessionLevel(selected.thinkingLevels, prev?.thinkingLevel ?? selected.thinkingLevel ?? 'off'),
+            thinkingLevel: resolveThinkingLevel(selected.thinkingLevels, sessionThinkingLevelRef.current, prev?.thinkingLevel ?? selected.thinkingLevel),
           }));
         }
       } catch {}

package/src/client/components/workspace/chat-timeline/chat-input/selection.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Catalog → composer mapping for the model/thinking pickers: one definition of
+ * how a catalog entry becomes the selected model, and of which thinking level
+ * that selection is allowed to claim. Shared by every resolution site in
+ * ChatInput so the level rule cannot drift between them.
+ */
+
+import type { AIModelOption, ModelEntry } from '@/shared/types';
+import { selectableThinkingLevels } from '@/shared/lib/models/thinking-levels';
+
+/**
+ * Level reported while none is known. A catalog ladder's first entry is NOT a
+ * fact about the session — every model's ladder starts at `off` — and the send
+ * path pushes any non-`auto` value onto the live session (queue replay), so an
+ * unresolved level must stay indistinguishable from "leave omp alone".
+ */
+export const UNKNOWN_THINKING_LEVEL = 'auto';
+
+/**
+ * Level the composer may select for a model. The session's last-used level is
+ * authoritative whenever the model offers it — an async fetch resolving later
+ * must not reset it to a ladder default. Only a ladder that is KNOWN and
+ * excludes the session level rejects it; an empty ladder (catalog not resolved
+ * / model exposes none) must not erase the session's actual level. With no
+ * session level to go on, the current selection is kept, and a composer that
+ * has none yet reports {@link UNKNOWN_THINKING_LEVEL}.
+ */
+export function resolveThinkingLevel(
+  ladder: readonly string[] | null | undefined,
+  sessionLevel: string | null | undefined,
+  currentLevel: string | null | undefined,
+): string {
+  const selectable = selectableThinkingLevels(ladder ?? []);
+  if (sessionLevel && (selectable.length === 0 || selectable.includes(sessionLevel))) return sessionLevel;
+  return currentLevel ?? UNKNOWN_THINKING_LEVEL;
+}
+
+/** The composer's selection for a catalog model, carrying its thinking level. */
+export function selectionFor(
+  match: ModelEntry,
+  sessionLevel: string | null | undefined,
+  current: AIModelOption | null,
+): AIModelOption {
+  return {
+    id: match.id,
+    name: match.name,
+    provider: match.provider,
+    contextWindow: match.contextWindow,
+    thinkingLevels: match.thinkingLevels,
+    thinkingLevel: resolveThinkingLevel(match.thinkingLevels, sessionLevel, current?.thinkingLevel),
+  };
+}

package/src/client/components/workspace/chat-timeline/index.tsx

@@ -1,6 +1,9 @@
 import { useCallback, useMemo, useState } from 'preact/hooks';
 import { useSearchParams } from '@/client/lib/router/search-params';
-import { AskDialog } from '@/client/components/workspace/chat-timeline/tool-renderers/ask-dialog/Lazy';
+import { ExtensionDialog } from '@/client/components/workspace/chat-timeline/tool-renderers/extension-dialog/Lazy';
+import { AskFramesContext, splitAskFrames, type AskFramesHandle } from '@/client/hooks/chat/timeline/ask-frames';
+import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
+import type { ExtensionDialogResponse } from '@/client/components/workspace/chat-timeline/tool-renderers/extension-dialog/Lazy';
 import { EmptyWorkspacePrompt } from '@/client/components/workspace/chat-timeline/EmptyWorkspacePrompt';
 import { SessionSkeleton } from '@/client/components/workspace/chat-timeline/SessionSkeleton';
 import { UndoConfirmModal } from '@/client/components/workspace/chat-timeline/UndoConfirmModal';
@@ -46,7 +49,8 @@ export function ChatTimeline({ className = '', appSettings = {}, onSessionTitle,
     loadOlder,
     generatingVerb,
     messageQueue,
-    setMessageQueue,
+    removeMessage,
+    reorderMessages,
     steeringQueue,
     setSteeringQueue,
     inputValue,
@@ -71,12 +75,27 @@ export function ChatTimeline({ className = '', appSettings = {}, onSessionTitle,
     accessMode,
     handleAccessModeChange,
     composerModelRef,
-    extensionDialog,
-    closeExtensionDialog,
+    extensionDialogs,
+    resolveExtensionDialog,
     respondToExtensionUi,
   } = useChatTimeline({ folders, appSettings });
   const { toasts, pushToast, dismissToast } = useToasts();
 
+  // Ask dialogs render on their own tool card; anything else omp is blocked on
+  // (an approval gate, an extension picker) has no card and keeps the modal.
+  const { framesByTool, modalRequest } = useMemo(
+    () => splitAskFrames(localMessages, extensionDialogs),
+    [localMessages, extensionDialogs],
+  );
+  const respondToFrame = useCallback((request: ExtensionUiDialogRequest, response: ExtensionDialogResponse) => {
+    void respondToExtensionUi(request, response);
+    resolveExtensionDialog(request.id);
+  }, [respondToExtensionUi, resolveExtensionDialog]);
+  const askFrames = useMemo<AskFramesHandle>(
+    () => ({ framesByTool, respond: respondToFrame }),
+    [framesByTool, respondToFrame],
+  );
+
   const [newChatInitialContent, setNewChatInitialContent] = useState<string | null>(null);
   const { pendingUndo, undoing, requestUndo: handleRequestUndo, closeUndoConfirm, confirmUndo } = useUndoConfirmation(handleUndo);
   const [searchParams, setSearchParams] = useSearchParams();
@@ -170,118 +189,115 @@ export function ChatTimeline({ className = '', appSettings = {}, onSessionTitle,
   }
 
   return (
-    <div className={`flex flex-col h-full min-h-0 overflow-hidden bg-canvas relative ${className}`}>
-      {showFullSkeleton ? (
-        <SessionSkeleton />
-      ) : (
-        <>
-          {/* Main chat container wrapper */}
-          <div className="relative flex-1 min-h-0 flex flex-col">
-            {activeSubagent ? (
-              <SubagentView
-                sessionId={sessionId}
-                subagent={activeSubagent}
-                onBack={handleSubagentBack}
-                provider={sessionProvider}
-                providerNames={providerNames}
-              />
-            ) : (
-              <TimelineBody
+    <AskFramesContext.Provider value={askFrames}>
+      <div className={`flex flex-col h-full min-h-0 overflow-hidden bg-canvas relative ${className}`}>
+        {showFullSkeleton ? (
+          <SessionSkeleton />
+        ) : (
+          <>
+            {/* Main chat container wrapper */}
+            <div className="relative flex-1 min-h-0 flex flex-col">
+              {activeSubagent ? (
+                <SubagentView
+                  sessionId={sessionId}
+                  subagent={activeSubagent}
+                  onBack={handleSubagentBack}
+                  provider={sessionProvider}
+                  providerNames={providerNames}
+                />
+              ) : (
+                <TimelineBody
+                  isMobile={isMobile}
+                  userMessages={userMessages}
+                  onScrollTo={handleScrollTo}
+                  scrollRef={scrollRef}
+                  contentRef={contentRef}
+                  handleScroll={handleScroll}
+                  isScrolling={isScrolling}
+                  loadingOlder={loadingOlder}
+                  hasMore={hasMore}
+                  loadOlderError={loadOlderError}
+                  loadOlder={loadOlder}
+                  messages={localMessages}
+                  isGenerating={isGenerating}
+                  provider={sessionProvider}
+                  providerNames={providerNames}
+                  modelName={sessionModelName}
+                  modelNames={modelNames}
+                  thinkingLevel={sessionData?.thinkingLevel}
+                  onUndo={handleRequestUndo}
+                  onRetry={handleRetry}
+                  onNewChat={handleNewChat}
+                  showScrollBottom={showScrollBottom}
+                  jumpToBottom={jumpToBottom}
+                />
+              )}
+            </div>
+
+            {/* Input Area Footer with Docked Generating Indicator (Seamless & Transparent) */}
+            {!activeSubagent && (
+              <ComposerDock
                 isMobile={isMobile}
-                userMessages={userMessages}
-                onScrollTo={handleScrollTo}
-                scrollRef={scrollRef}
-                contentRef={contentRef}
-                handleScroll={handleScroll}
-                isScrolling={isScrolling}
-                loadingOlder={loadingOlder}
-                hasMore={hasMore}
-                loadOlderError={loadOlderError}
-                loadOlder={loadOlder}
-                messages={localMessages}
                 isGenerating={isGenerating}
+                modelName={sessionModelName}
+                generatingVerb={generatingVerb}
                 provider={sessionProvider}
                 providerNames={providerNames}
-                modelName={sessionModelName}
-                modelNames={modelNames}
-                thinkingLevel={sessionData?.thinkingLevel}
-                onUndo={handleRequestUndo}
-                onRetry={handleRetry}
-                onNewChat={handleNewChat}
-                showScrollBottom={showScrollBottom}
-                jumpToBottom={jumpToBottom}
+                messageQueue={messageQueue}
+                onRemoveQueueItem={removeMessage}
+                onReorderQueue={reorderMessages}
+                onEditQueueItem={handleEditQueueItem}
+                onSendNowQueueItem={handleSendNowQueueItem}
+                steeringQueue={steeringQueue}
+                setSteeringQueue={setSteeringQueue}
+                inputValue={inputValue}
+                setInputValue={setInputValue}
+                rootPath={composerRoot}
+                attachments={inputAttachments}
+                setAttachments={setInputAttachments}
+                onSend={handleSend}
+                onStop={handleStop}
+                appSettings={appSettings}
+                onThinkingLevelChange={handleThinkingLevelChange}
+                onModelChange={handleModelChange}
+                accessMode={accessMode}
+                onAccessModeChange={handleAccessModeChange}
+                composerModelRef={composerModelRef}
+                sessionModel={typeof sessionData?.model === 'object' ? sessionData.model : null}
+                sessionThinkingLevel={sessionData?.thinkingLevel}
+                variant={variant}
               />
             )}
-          </div>
-
-          {/* Input Area Footer with Docked Generating Indicator (Seamless & Transparent) */}
-          {!activeSubagent && (
-            <ComposerDock
-              isMobile={isMobile}
-              isGenerating={isGenerating}
-              modelName={sessionModelName}
-              generatingVerb={generatingVerb}
-              provider={sessionProvider}
-              providerNames={providerNames}
-              messageQueue={messageQueue}
-              setMessageQueue={setMessageQueue}
-              onEditQueueItem={handleEditQueueItem}
-              onSendNowQueueItem={handleSendNowQueueItem}
-              steeringQueue={steeringQueue}
-              setSteeringQueue={setSteeringQueue}
-              inputValue={inputValue}
-              setInputValue={setInputValue}
-              rootPath={composerRoot}
-              attachments={inputAttachments}
-              setAttachments={setInputAttachments}
-              onSend={handleSend}
-              onStop={handleStop}
-              appSettings={appSettings}
-              onThinkingLevelChange={handleThinkingLevelChange}
-              onModelChange={handleModelChange}
-              accessMode={accessMode}
-              onAccessModeChange={handleAccessModeChange}
-              composerModelRef={composerModelRef}
-              sessionModel={typeof sessionData?.model === 'object' ? sessionData.model : null}
-              sessionThinkingLevel={sessionData?.thinkingLevel}
-              variant={variant}
-            />
-          )}
-        </>
-      )}
+          </>
+        )}
 
-      {pendingUndo && (
-        <UndoConfirmModal
-          isOmpSession={Boolean(sessionId) && !sessionId.startsWith('new-') && Number.isNaN(Number(sessionId))}
-          content={pendingUndo.content}
-          undoing={undoing}
-          onClose={closeUndoConfirm}
-          onConfirm={confirmUndo}
-        />
-      )}
-      {newChatInitialContent !== null && (
-        <NewChatModal
-          initialContent={newChatInitialContent}
-          onClose={() => setNewChatInitialContent(null)}
-          onSend={submitNewChat}
-          appSettings={appSettings}
-          accessMode={accessMode}
-          onAccessModeChange={handleAccessModeChange}
-          composerModelRef={composerModelRef}
-        />
-      )}
+        {pendingUndo && (
+          <UndoConfirmModal
+            isOmpSession={Boolean(sessionId) && !sessionId.startsWith('new-') && Number.isNaN(Number(sessionId))}
+            content={pendingUndo.content}
+            undoing={undoing}
+            onClose={closeUndoConfirm}
+            onConfirm={confirmUndo}
+          />
+        )}
+        {newChatInitialContent !== null && (
+          <NewChatModal
+            initialContent={newChatInitialContent}
+            onClose={() => setNewChatInitialContent(null)}
+            onSend={submitNewChat}
+            appSettings={appSettings}
+            accessMode={accessMode}
+            onAccessModeChange={handleAccessModeChange}
+            composerModelRef={composerModelRef}
+          />
+        )}
 
-      {extensionDialog && (
-        <AskDialog
-          request={extensionDialog}
-          onRespond={(request, response) => {
-            void respondToExtensionUi(request, response);
-            closeExtensionDialog();
-          }}
-        />
-      )}
+        {modalRequest && (
+          <ExtensionDialog request={modalRequest} onRespond={respondToFrame} />
+        )}
 
-      <ToastStack toasts={toasts} onDismiss={dismissToast} />
-    </div>
+        <ToastStack toasts={toasts} onDismiss={dismissToast} />
+      </div>
+    </AskFramesContext.Provider>
   );
 }