@adecore/agents-react 0.35.5 → 0.37.0

package/src/chat/chat-client.ts

@@ -42,6 +42,7 @@ export interface ChatSendExtras {
 }
 
 interface Mounted extends ChatOpenOptions, MountedEntry {
+    observerOnly?: boolean;
     // The last place in the chat's stream the store holds, so a reattach asks only for what came after.
     seq?: number;
 }
@@ -66,8 +67,10 @@ export class ChatClient {
     private readonly mounted = new MountedRegistry<Mounted>();
     private readonly unsubscribe: Array<() => void> = [];
     private readonly earlier = new Map<string, Promise<void>>();
+    private readonly observers = new Map<string, number>();
     private readonly inspections = new Map<string, Promise<ChatAttachResult>>();
     private preferences: ChatPreferencesPayload | null = null;
+    private checkpoints = new WeakMap<object, number>();
 
     constructor(transport: ChatTransport, sink: ChatSink, providers: ProviderSink | null = null) {
         this.transport = transport;
@@ -75,10 +78,10 @@ export class ChatClient {
         this.providers = providers;
         this.unsubscribe.push(
             transport.on('chat.event', ({ chatId, event, seq }) => {
+                const previous = this.sequence(chatId);
                 this.sink.apply(chatId, event);
-                const entry = this.mounted.get(chatId);
-                if (entry && seq !== undefined) {
-                    entry.seq = seq;
+                if (previous !== undefined || (!this.sink.historyIdentity && this.mounted.get(chatId)?.attached)) {
+                    this.rememberSequence(chatId, seq);
                 }
             }),
             // Every chat on the machine, attached or not, so a node waiting on a person says so on a view nobody has open.
@@ -109,6 +112,31 @@ export class ChatClient {
         return read;
     }
 
+    /* Shares a live attachment without creating a chat; a visible composer and several ancestors may hold it together. */
+    observe(chatId: string): () => void {
+        this.observers.set(chatId, (this.observers.get(chatId) ?? 0) + 1);
+        if (!this.mounted.has(chatId)) {
+            this.mounted.set(chatId, { attached: false, observerOnly: true });
+            void this.attach(chatId).catch(() => undefined);
+        }
+        let released = false;
+        return () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            const remaining = (this.observers.get(chatId) ?? 1) - 1;
+            if (remaining > 0) {
+                this.observers.set(chatId, remaining);
+                return;
+            }
+            this.observers.delete(chatId);
+            if (this.mounted.get(chatId)?.observerOnly) {
+                void this.detach(chatId);
+            }
+        };
+    }
+
     /* Answers false when the transport is not connected; the chat opens once it is. */
     async open(chatId: string, options: ChatOpenOptions): Promise<boolean> {
         this.mounted.set(chatId, { ...options, attached: false });
@@ -135,7 +163,8 @@ export class ChatClient {
         }
         // The account belonged to the CLI the chat leaves, and the seq to its stream: the new chat's
         // stream starts over, so offering it the old seq would read as nothing missed and reset nothing.
-        const { attached: _attached, account: _account, seq: _seq, ...options } = entry;
+        const { attached: _attached, account: _account, seq: _seq, observerOnly: _observerOnly, ...options } = entry;
+        this.rememberSequence(chatId, undefined);
         this.mounted.delete(chatId);
         await this.transport.request('chat.kill', { chatId });
         try {
@@ -157,6 +186,10 @@ export class ChatClient {
 
     async detach(chatId: string): Promise<void> {
         const entry = this.mounted.get(chatId);
+        if (entry && this.observers.has(chatId)) {
+            entry.observerOnly = true;
+            return;
+        }
         this.mounted.delete(chatId);
         if (!entry?.attached) {
             return;
@@ -268,13 +301,17 @@ export class ChatClient {
         }
         const read = this.transport
             .request('chat.history', { chatId, cursor, limit: HISTORY_PAGE })
-            .then((page) => this.sink.prepend(chatId, cursor, page))
+            .then((page) => {
+                const seq = this.sequence(chatId);
+                this.sink.prepend(chatId, cursor, page);
+                this.rememberSequence(chatId, seq);
+            })
             .catch(async (e: unknown) => {
                 const entry = this.mounted.get(chatId);
                 if (errorCode(e) !== 'history-expired' || !entry) {
                     throw e;
                 }
-                delete entry.seq;
+                this.rememberSequence(chatId, undefined);
                 await this.attach(chatId);
             })
             .finally(() => this.earlier.delete(chatId));
@@ -292,6 +329,8 @@ export class ChatClient {
             off();
         }
         this.unsubscribe.length = 0;
+        this.observers.clear();
+        this.checkpoints = new WeakMap();
         for (const chatId of [...this.mounted.keys()]) {
             void this.detach(chatId);
         }
@@ -307,20 +346,22 @@ export class ChatClient {
         if (!entry) {
             return;
         }
-        await this.transport.request('chat.create', {
-            chatId,
-            provider: entry.provider,
-            account: entry.account,
-            cwd: entry.cwd,
-            resume: entry.resume,
-            selection: entry.selection,
-            runtimeMode: entry.runtimeMode
-        });
+        if (!entry.observerOnly) {
+            await this.transport.request('chat.create', {
+                chatId,
+                provider: entry.provider,
+                account: entry.account,
+                cwd: entry.cwd,
+                resume: entry.resume,
+                selection: entry.selection,
+                runtimeMode: entry.runtimeMode
+            });
+        }
         // Closed or opened again in the meantime: an opening that is still there attaches itself.
         if (this.mounted.get(chatId) !== entry) {
             return;
         }
-        const since = entry.seq;
+        const since = this.sequence(chatId);
         const result = await this.transport.request('chat.attach', { chatId, historyLimit: HISTORY_PAGE, ...(since === undefined ? {} : { since }) });
         const current = this.mounted.get(chatId);
         if (current !== entry) {
@@ -330,24 +371,54 @@ export class ChatClient {
             }
             return;
         }
-        entry.attached = true;
-        if (result.seq !== undefined) {
-            entry.seq = result.seq;
+        // A cache eviction while the request was in flight also invalidates its replay base.
+        if (result.events && since !== undefined && this.sequence(chatId) === undefined) {
+            await this.attach(chatId);
+            return;
         }
+        entry.attached = true;
         if (result.events && since !== undefined) {
-            for (const event of result.events) {
-                this.sink.apply(chatId, event);
+            if (this.sink.replay) {
+                this.sink.replay(chatId, result.events);
+            } else {
+                for (const event of result.events) {
+                    this.sink.apply(chatId, event);
+                }
             }
         } else {
             const page =
                 result.history === undefined ? undefined : { history: result.history, pending: result.pending ?? [], subagents: result.subagents ?? [] };
             this.sink.reset(chatId, result.info, result.items, page);
         }
+        this.rememberSequence(chatId, result.seq);
         // A host without bookmarks or visuals sends none, and then this chat has none.
         this.sink.bookmarks(chatId, result.bookmarks ?? []);
         this.sink.visuals(chatId, result.visuals ?? []);
     }
 
+    private sequence(chatId: string): number | undefined {
+        if (!this.sink.historyIdentity) {
+            return this.mounted.get(chatId)?.seq;
+        }
+        const identity = this.sink.historyIdentity(chatId);
+        return identity === undefined ? undefined : this.checkpoints.get(identity);
+    }
+
+    private rememberSequence(chatId: string, seq: number | undefined): void {
+        const entry = this.mounted.get(chatId);
+        if (entry) {
+            entry.seq = seq;
+        }
+        const identity = this.sink.historyIdentity?.(chatId);
+        if (identity !== undefined) {
+            if (seq === undefined) {
+                this.checkpoints.delete(identity);
+            } else {
+                this.checkpoints.set(identity, seq);
+            }
+        }
+    }
+
     private sendPreferences(): void {
         if (this.preferences === null) {
             return;

package/src/chat/index.ts

@@ -78,3 +78,5 @@ export {
 } from './subagent-view';
 export { stepTimelineMessage, jumpToTimelineItem, type TurnTarget, registerTurnJumper, jumpToTimelineTurn, type ItemJumpOptions } from './timeline-scroll';
 export { type StatusWord, statusLookOf, taskStatusWord, type StatusLook, type TaskState } from '../agents/status-look';
+
+export { ChatPromptFeed } from './pending-prompts';

package/src/chat/logic/picker-entries.ts

@@ -1,4 +1,5 @@
 import type { AgentKind, ModelInfo, ProviderInfo } from '@adecore/agent-contracts';
+import { nameCollator } from '@adecore/ui/format';
 
 /*
  * A provider with more live models than this keeps the list short: the model that is picked and the default,
@@ -21,6 +22,8 @@ export interface PickerCurrent {
 export type FavoritesOf = (kind: AgentKind) => ReadonlySet<string>;
 
 const NO_FAVORITES: FavoritesOf = () => new Set();
+const VENDOR_ORDER: Intl.CollatorOptions = { sensitivity: 'base' };
+const MODEL_ORDER: Intl.CollatorOptions = { sensitivity: 'base', numeric: true };
 
 function matches(model: ModelInfo, query: string): boolean {
     return model.name.toLowerCase().includes(query) || model.slug.toLowerCase().includes(query) || (model.vendor?.toLowerCase().includes(query) ?? false);
@@ -34,14 +37,13 @@ export function modelsByVendor(models: ModelInfo[]): ModelInfo[] {
     if (!models.some((model) => model.vendor !== undefined)) {
         return models;
     }
+    const vendorOrder = nameCollator(VENDOR_ORDER).compare;
+    const modelOrder = nameCollator(MODEL_ORDER).compare;
     return [...models].sort((a, b) => {
         if (a.vendor === undefined || b.vendor === undefined) {
             return a.vendor === b.vendor ? 0 : a.vendor === undefined ? 1 : -1;
         }
-        return (
-            a.vendor.localeCompare(b.vendor, undefined, { sensitivity: 'base' }) ||
-            a.name.localeCompare(b.name, undefined, { sensitivity: 'base', numeric: true })
-        );
+        return vendorOrder(a.vendor, b.vendor) || modelOrder(a.name, b.name);
     });
 }
 

package/src/chat/logic/scrubber.ts

@@ -207,14 +207,16 @@ function lastIndexAtOrBelow(length: number, valueAt: (index: number) => number,
     return found;
 }
 
+type MessageStarts = Pick<readonly number[], 'length' | 'at'>;
+
 /* The last index whose start lies at or above a line, or -1. */
-function lastAtOrAbove(starts: readonly number[], line: number): number {
-    return lastIndexAtOrBelow(starts.length, (index) => starts[index]!, line);
+function lastAtOrAbove(starts: MessageStarts, line: number): number {
+    return lastIndexAtOrBelow(starts.length, (index) => starts.at(index)!, line);
 }
 
 export interface ReadingPosition {
     /* Where each message's row starts in the thread, in the virtualizer's measurements. */
-    starts: readonly number[];
+    starts: MessageStarts;
     scrollTop: number;
     /* The height of the thread a person can read, without what the composer covers. */
     visibleHeight: number;
@@ -231,13 +233,13 @@ export interface MessageRange {
  */
 export function messagesInView({ starts, scrollTop, visibleHeight }: ReadingPosition): MessageRange | null {
     const bottom = scrollTop + visibleHeight;
-    if (starts.length === 0 || visibleHeight <= 0 || starts[0]! >= bottom) {
+    if (starts.length === 0 || visibleHeight <= 0 || starts.at(0)! >= bottom) {
         return null;
     }
     const first = Math.max(0, lastAtOrAbove(starts, scrollTop));
     let last = lastAtOrAbove(starts, bottom);
     // A row that starts on the very last line has not a pixel on screen yet.
-    if (starts[last]! >= bottom) {
+    if (starts.at(last)! >= bottom) {
         last--;
     }
     return { first, last: Math.max(first, last) };
@@ -253,7 +255,7 @@ export function slotInView(slot: TickSlot, range: MessageRange | null): boolean
  * message's start at the top, so back from there is the one before it, and back from the middle of
  * a long answer is the question it belongs to. A pixel of slack absorbs rounding in the scroller.
  */
-export function stepMessage(starts: readonly number[], eligible: (index: number) => boolean, scrollTop: number, direction: -1 | 1): number | null {
+export function stepMessage(starts: MessageStarts, eligible: (index: number) => boolean, scrollTop: number, direction: -1 | 1): number | null {
     if (direction === -1) {
         for (let i = lastAtOrAbove(starts, scrollTop - 1.5); i >= 0; i--) {
             if (eligible(i)) {

package/src/chat/pending-prompts.ts

@@ -0,0 +1,108 @@
+import { CHAT_REQUEST_LIMITS, type ChatInfo } from '@adecore/agent-contracts';
+import type { PromptSubject } from '../prompts/logic/subjects';
+import type { PendingPrompt } from '../prompts/logic/prompts';
+import type { ChatScope } from '../scope';
+import { useChats, waitingRequestsOf } from '../state/chats';
+import { subagentTitle } from './subagent-list';
+
+type ChatPromptSubject = Extract<PromptSubject, { kind: 'chat' }>;
+
+function stillWaiting(item: PendingPrompt, info: ChatInfo): boolean {
+    return (
+        info.status === 'needs-you' &&
+        (info.requests === undefined ||
+            info.requests.length >= CHAT_REQUEST_LIMITS.perChat ||
+            info.requests.some((request) => request.requestId === item.requestId))
+    );
+}
+
+/* Follows descendant requests while the main chat is open, including children discovered in later events or older history pages. */
+export class ChatPromptFeed {
+    private readonly scope: ChatScope;
+    private readonly chatId: string;
+    private readonly changed: (subjects: PromptSubject[]) => void;
+    private readonly children = new Map<string, () => void>();
+    private unsubscribe: (() => void) | undefined;
+    private current: ChatPromptSubject[] | null = null;
+    private disposed = false;
+
+    constructor(scope: ChatScope, chatId: string, changed: (subjects: PromptSubject[]) => void) {
+        this.scope = scope;
+        this.chatId = chatId;
+        this.changed = changed;
+    }
+
+    start(): void {
+        this.unsubscribe = useChats.subscribe(() => this.update());
+        this.update();
+    }
+
+    dispose(): void {
+        this.disposed = true;
+        this.unsubscribe?.();
+        for (const release of this.children.values()) {
+            release();
+        }
+        this.children.clear();
+    }
+
+    private update(): void {
+        if (this.disposed) {
+            return;
+        }
+        const store = useChats.getState();
+        const subjects = new Map<string, ChatPromptSubject>();
+        const seen = new Set<string>();
+        const visit = (chatId: string, source?: ChatPromptSubject['source']): void => {
+            if (seen.has(chatId)) {
+                return;
+            }
+            seen.add(chatId);
+            const key = this.scope.keyOf(chatId);
+            const row = store.byKey[key];
+            const info = store.statusByKey[key]?.info ?? row?.info;
+            for (const item of waitingRequestsOf(row)) {
+                if (info !== undefined && (chatId === this.chatId || stillWaiting(item, info))) {
+                    subjects.set(`${chatId}:${item.requestId}`, { kind: 'chat', nodeId: chatId, item, ...(source === undefined ? {} : { source }) });
+                }
+            }
+            for (const item of Object.values(row?.structure ?? {})) {
+                if (item.kind !== 'subagent' || item.childId === undefined || seen.has(item.childId)) {
+                    continue;
+                }
+                const childInfo = store.statusByKey[this.scope.keyOf(item.childId)]?.info;
+                if (item.status !== 'running' && childInfo?.status !== 'needs-you') {
+                    continue;
+                }
+                if (!this.children.has(item.childId)) {
+                    this.children.set(item.childId, this.scope.chats.observe(item.childId));
+                }
+                visit(item.childId, { label: subagentTitle(item), provider: childInfo?.provider });
+            }
+        };
+        visit(this.chatId);
+        for (const [chatId, release] of this.children) {
+            if (!seen.has(chatId)) {
+                this.children.delete(chatId);
+                release();
+            }
+        }
+        const next = [...subjects.values()];
+        if (
+            this.current === null ||
+            next.length !== this.current.length ||
+            next.some((subject, index) => {
+                const previous = this.current?.[index];
+                return (
+                    subject.nodeId !== previous?.nodeId ||
+                    subject.item !== previous.item ||
+                    subject.source?.label !== previous.source?.label ||
+                    subject.source?.provider !== previous.source?.provider
+                );
+            })
+        ) {
+            this.current = next;
+            this.changed(next);
+        }
+    }
+}

package/src/chat/reading-width.ts

@@ -24,10 +24,17 @@ export function readingMeasure(width: ChatReadingWidth): number {
     return MEASURES[width];
 }
 
-/* What `.chat-column-content` and `.chat-composer-content` read their width from. */
+/* A wide visual outgrows the reading column, but only a full-width chat lets it run past this. */
+const WIDE_MEASURE = 1200;
+
+/* What `.chat-column-content`, `.chat-wide-content` and `.chat-composer-content` read their width from. */
 export function readingWidthStyle(width: ChatReadingWidth): CSSProperties {
     const measure = MEASURES[width];
-    return { '--chat-measure': Number.isFinite(measure) ? `${measure}px` : '100%' } as CSSProperties;
+    const bounded = Number.isFinite(measure);
+    return {
+        '--chat-measure': bounded ? `${measure}px` : '100%',
+        '--chat-wide-measure': bounded ? `${WIDE_MEASURE}px` : '100%'
+    } as CSSProperties;
 }
 
 export function readingWidthLabel(width: ChatReadingWidth): string {

package/src/chat/ui/Pickers.tsx

@@ -13,15 +13,12 @@ import { ModelMarks } from './ModelMarks';
 import { pickerEntriesOf, type PickerEntry } from '../logic/picker-entries';
 import { favoriteModelsOf, toggleFavoriteModel, useChatPreferences } from '../preferences';
 import { forgetStashed, STASH_SHORTCUT, useStash, type StashedPrompt } from '../stash';
-import { Icon, IconButton, Menu, Popover, Tooltip } from '@adecore/ui';
+import { Button, Icon, IconButton, Menu, Popover, Tooltip } from '@adecore/ui';
 import { useHostMachineLabel } from '../../host-hooks';
 
 const triggerClass =
     'flex h-7 shrink-0 items-center gap-1 whitespace-nowrap rounded-md px-2 text-xs text-text-muted hover:bg-surface-hover hover:text-text data-[popup-open]:bg-surface-active data-[popup-open]:text-text';
 
-const chipClass =
-    'flex h-6 min-w-0 shrink items-center gap-1.5 whitespace-nowrap rounded-md bg-surface-hover px-2 text-xs text-text hover:bg-surface-active data-[popup-open]:bg-surface-active';
-
 interface ModelPickerProps {
     /* Whose models may be picked: every installed chat CLI before the first message, the chat's own after it. */
     providers: ProviderInfo[];
@@ -35,7 +32,7 @@ interface ModelPickerProps {
     kbd?: string | null;
     /* Where the popup opens: over the composer by default, below the trigger in a form. */
     side?: 'top' | 'bottom';
-    /* `chip` names the provider beside the model, on a ground of its own, for a picker that sits in a card or a form. */
+    /* `chip` names the provider beside the model on a secondary button, for a picker that sits in a card or a form. */
     trigger?: 'plain' | 'chip';
     /* Where the focus goes when the popup closes; by default back to the trigger. */
     finalFocus?: RefObject<HTMLElement | null>;
@@ -149,7 +146,7 @@ export function ModelPicker({
         <Popover.Root open={open} onOpenChange={setOpen}>
             <Tooltip label={owner ? `${owner.name} · ${current}` : t('pickers.model.choose')} kbd={kbd ?? undefined}>
                 {trigger === 'chip' ? (
-                    <Popover.Trigger className={chipClass}>
+                    <Popover.Trigger render={<Button variant="secondary" size="sm" className="min-w-0 shrink gap-1.5" />}>
                         {chip.mark === 'logo' ? <ProviderLogo provider={provider as UsageProvider} size={12} /> : <AgentIcon kind={provider} size={12} />}
                         <span className="truncate">{chip.name}</span>
                         <span className="max-w-32 truncate text-text-muted">{chip.model}</span>

package/src/chat/ui/PromptComposer.tsx

@@ -3,7 +3,7 @@ import { useTranslation } from 'react-i18next';
 import { ArrowDown, Hand, MessageCircleQuestionMark } from 'lucide-react';
 import type { HoldRelease } from '../prompt-hold';
 import { focusPromptHeading, focusPromptStart } from '../../prompts/logic/focus';
-import { orderPrompts, type PendingPrompt } from '../../prompts/logic/prompts';
+import { orderPrompts } from '../../prompts/logic/prompts';
 import { answerPrompt, isBlockingSubject, promptCreatedAt, promptIdOf, type PromptSubject } from '../../prompts/logic/subjects';
 import { useFocusAfterAnswer } from '../../prompts/logic/useFocusAfterAnswer';
 import { usePromptSession } from '../../prompts/logic/usePromptSession';
@@ -12,6 +12,7 @@ import { useChatHost } from '../../host';
 import { useChatScope } from '../../scope';
 import { useChatActions } from '../actions';
 import { Button, Icon } from '@adecore/ui';
+import { useProviders } from '../../state/providers';
 import { useHostExtraPrompts } from '../../host-hooks';
 
 /* Keeps a prompt card behind the draft while the person types; `released` says what lifted the hold last. */
@@ -39,7 +40,7 @@ export function PromptComposer({
     children
 }: {
     chatId: string;
-    pending: PendingPrompt[];
+    pending: PromptSubject[];
     focused: boolean;
     /* Set where the prompts are answered somewhere else; the composer only says where they went, and this goes there. */
     onShowElsewhere?: () => void;
@@ -56,13 +57,11 @@ export function PromptComposer({
     const { id } = useChatScope();
     const host = useChatHost();
     const actions = useChatActions();
+    const providers = useProviders((row) => row.providers);
     const elsewhere = onShowElsewhere !== undefined;
     // A card the app raises itself waits in the chat beside the CLI's own requests.
     const extra = useHostExtraPrompts(id, chatId);
-    const subjects: PromptSubject[] = [
-        ...pending.map((item): PromptSubject => ({ kind: 'chat', nodeId: chatId, item })),
-        ...extra.map((prompt): PromptSubject => ({ kind: 'host', nodeId: chatId, prompt }))
-    ];
+    const subjects: PromptSubject[] = [...pending, ...extra.map((prompt): PromptSubject => ({ kind: 'host', nodeId: chatId, prompt }))];
     const session = usePromptSession({ prompts: subjects, idOf: promptIdOf, pick: pickSubject, disabled });
     const ref = useRef<HTMLDivElement>(null);
     const { active, activeId: activeKey } = session;
@@ -125,7 +124,11 @@ export function PromptComposer({
                         }}
                         more={session.waiting.length - 1}
                         hasDraft={hasDraft}
-                        denyReason={denyReason}
+                        denyReason={
+                            active.kind === 'chat' && active.source?.provider !== undefined
+                                ? providers.find((provider) => provider.kind === active.source?.provider)?.capabilities.denyReason === true
+                                : denyReason
+                        }
                         disabled={disabled}
                         sending={session.sending}
                         error={session.errorOf(promptIdOf(active))}

package/src/chat/ui/RunSettings.tsx

@@ -312,7 +312,7 @@ export function RunSettings({
                     disabled={disabled}
                     className={clsx(
                         'flex h-8 min-w-0 items-center gap-2 rounded-full border pr-3 pl-2.5 text-xs whitespace-nowrap text-text-muted @max-xl/composer:gap-1.5 @max-sm/composer:pr-2.5',
-                        open ? 'border-accent bg-accent-soft' : 'border-border hover:bg-surface-hover'
+                        open ? 'border-accent bg-accent-soft' : 'border-border hover:bg-surface-hover-edged'
                     )}
                 >
                     <AgentIcon kind={provider} size={14} className="shrink-0" />
@@ -665,7 +665,7 @@ function OptionRow({ option, selection, onChange }: { option: ModelOptionDescrip
                 value={value}
                 onValueChange={(next: string) => onChange(next)}
                 aria-label={option.label}
-                className="flex gap-0.5 rounded-md bg-surface-sunken p-0.5"
+                className="flex gap-0.5 rounded-md bg-surface-sunken p-0.5 dark:bg-surface-idle"
             >
                 {option.choices.map((choice) => (
                     <Menu.RadioItem

package/src/chat/ui/SubagentTimeline.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useLayoutEffect, useRef, useState, useSyncExternalStore } from 'react';
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Bot, LoaderCircle } from 'lucide-react';
 import { deriveTimelineRows } from '../logic/timeline';
@@ -9,8 +9,6 @@ import { EMPTY_TARGET, readTimelineTarget, type TimelineTarget } from '../logic/
 import { openBelow, useSubagentTrail, type SubagentStep } from '../subagent-view';
 import { Row } from './rows/Rows';
 import { ReplyContext } from './reply-context';
-import { PromptComposer } from './PromptComposer';
-import { useProviders } from '../../state/providers';
 import { SubagentInfo } from './SubagentInfo';
 import { TimelineMenuPopup } from './TimelineMenu';
 import { FOLLOW_THRESHOLD_PX, rowRhythm } from './rows/row-rhythm';
@@ -33,14 +31,8 @@ export function SubagentTimeline({ chatId, toolUseId }: { chatId: string; toolUs
     const { t } = useTranslation('agent-chat');
     const scope = useChatScope();
     const { commandLooks } = useChatHost();
-    const connected = useSyncExternalStore(
-        (changed) => scope.transport.subscribeStatus(changed),
-        () => scope.transport.status === 'open',
-        () => false
-    );
     const { trail, show } = useSubagentTrail(chatId);
     const [state, setState] = useState<SubagentConversationState>(INITIAL_CONVERSATION);
-    const denyReason = useProviders((row) => row.providers.find((provider) => provider.kind === state.context?.provider)?.capabilities.denyReason === true);
     const controller = useRef<SubagentConversation | null>(null);
     const scrollRef = useRef<HTMLDivElement>(null);
     const threadRef = useRef<HTMLDivElement>(null);
@@ -183,21 +175,6 @@ export function SubagentTimeline({ chatId, toolUseId }: { chatId: string; toolUs
                     </ReplyContext.Provider>
                 </FileLinkContext.Provider>
             )}
-            {state.context?.chatId !== undefined && state.pending.length > 0 && (
-                <div className="chat-column-content shrink-0">
-                    <PromptComposer
-                        key={state.context.chatId}
-                        chatId={state.context.chatId}
-                        pending={state.pending}
-                        focused={false}
-                        disabled={!connected}
-                        hasDraft={false}
-                        denyReason={denyReason}
-                    >
-                        {null}
-                    </PromptComposer>
-                </div>
-            )}
         </div>
     );
 }