@adecore/agents-react 0.21.2 → 0.22.0

package/dist/agents/model-requirement.d.ts

@@ -0,0 +1,6 @@
+import type { ModelInfo, ProviderInfo } from '@adecore/agent-contracts';
+export interface ModelRequirement {
+    cli: string;
+    minVersion: string;
+}
+export declare function modelRequirementOf(model: ModelInfo, provider: ProviderInfo, reported: ReadonlySet<string>): ModelRequirement | null;

package/dist/agents/model-requirement.js

@@ -0,0 +1,26 @@
+function partsOf(version, strict) {
+    const found = (strict ? /^(\d+)\.(\d+)(?:\.(\d+))?$/ : /(\d+)\.(\d+)\.(\d+)/).exec(version);
+    return found === null ? null : [Number(found[1]), Number(found[2]), Number(found[3] ?? 0)];
+}
+/* Whether the model's reported name is this model: its slug, the slug with a suffix such as `[1m]`. */
+function isReported(slug, reported) {
+    return [...reported].some((name) => name === slug || name.startsWith(`${slug}[`));
+}
+/*
+ * What a model asks of the CLI that is too old for it, or null when nothing blocks it: no minimum is
+ * known, the CLI's version is not a readable x.y.z (so an unknown version invents no requirement), the
+ * CLI is new enough, or a chat of this provider already reported running the model.
+ */
+export function modelRequirementOf(model, provider, reported) {
+    const minimum = model.minCliVersion === undefined ? null : partsOf(model.minCliVersion, true);
+    const installed = provider.version === null ? null : partsOf(provider.version, false);
+    if (minimum === null || installed === null || isReported(model.slug, reported)) {
+        return null;
+    }
+    for (let i = 0; i < 3; i++) {
+        if (installed[i] !== minimum[i]) {
+            return (installed[i] ?? 0) > (minimum[i] ?? 0) ? null : { cli: provider.name, minVersion: model.minCliVersion ?? '' };
+        }
+    }
+    return null;
+}

package/dist/chat/chat-client.d.ts

@@ -1,4 +1,4 @@
-import type { AgentKind, ChatAttachmentUpload, ChatAttachResult, ChatBookmark, ChatPreferencesPayload, ChatSkill, ChatVisual, ModelSelection, ProviderInfo, RuntimeMode } from '@adecore/agent-contracts';
+import type { AgentKind, ChatAttachmentUpload, ChatAttachResult, ChatBookmark, ChatPreferencesPayload, ChatQuoteSource, ChatSkill, ChatVisual, ModelSelection, ProviderInfo, RuntimeMode } from '@adecore/agent-contracts';
 import type { ChatSink } from '../state/chats.js';
 import { type ChatTransport } from '../transport.js';
 interface ChatOpenOptions {
@@ -14,6 +14,7 @@ export interface ChatSendExtras {
     mentions?: string[];
     skills?: string[];
     chats?: string[];
+    quoteSource?: ChatQuoteSource;
     attachments?: ChatAttachmentUpload[];
 }
 interface ProviderSink {

package/dist/chat/chat-client.js

@@ -113,9 +113,11 @@ export class ChatClient {
         return this.transport.request('chat.send', {
             chatId,
             text,
+            delivery: extras.delivery,
             mentions: extras.mentions,
             skills: extras.skills,
             chats: extras.chats,
+            quoteSource: extras.quoteSource,
             attachments: extras.attachments
         });
     }

package/dist/chat/drafts.d.ts

@@ -6,6 +6,7 @@ export interface ChatDraft {
     chats: string[];
     attachments: ChatAttachmentUpload[];
     quote: string;
+    quoteSource: string | null;
 }
 export declare const EMPTY_DRAFT: ChatDraft;
 export declare function isEmptyDraft(draft: ChatDraft): boolean;
@@ -16,7 +17,7 @@ export declare function useHasDraft(chatId: string): boolean;
 export declare function readDraft(chatId: string): ChatDraft;
 export declare function writeDraft(chatId: string, draft: ChatDraft): void;
 export declare function joinDraftText(current: string, added: string): string;
-export declare function takeBackIntoDraft(current: ChatDraft, taken: Omit<ChatDraft, 'quote'>): {
+export declare function takeBackIntoDraft(current: ChatDraft, taken: Omit<ChatDraft, 'quote' | 'quoteSource'>): {
     draft: ChatDraft;
     rejected: Array<{
         name: string;

package/dist/chat/drafts.js

@@ -2,7 +2,7 @@ import { chatStorageKey, chatStorageLegacyKeys, createChatStore } from '../stora
 import { checkAttachmentLimits, uploadBytes } from './attachments.js';
 import { persistedJson } from './persisted-json.js';
 const storageKey = () => chatStorageKey('drafts');
-export const EMPTY_DRAFT = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '' };
+export const EMPTY_DRAFT = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '', quoteSource: null };
 const storage = persistedJson(storageKey, (raw) => (raw ? JSON.parse(raw) : {}), {}, () => chatStorageLegacyKeys('drafts'));
 export function isEmptyDraft(draft) {
     return draft.text.trim() === '' && draft.attachments.length === 0 && draft.quote === '';
@@ -32,7 +32,8 @@ export function readDraft(chatId) {
             skills: record.skills ?? [],
             chats: record.chats ?? [],
             attachments: record.attachments ?? [],
-            quote: record.quote ?? ''
+            quote: record.quote ?? '',
+            quoteSource: record.quoteSource ?? null
         }
         : EMPTY_DRAFT;
 }
@@ -50,13 +51,21 @@ export function writeDraft(chatId, draft) {
         skills: draft.skills,
         chats: draft.chats,
         attachments: draft.attachments,
-        quote: draft.quote
+        quote: draft.quote,
+        ...(draft.quoteSource === null ? {} : { quoteSource: draft.quoteSource })
     };
     if (storage.write(drafts)) {
         return;
     }
     // A file can outgrow the storage quota; the text is the part worth keeping then.
-    drafts[chatId] = { text: draft.text, mentions: draft.mentions, skills: draft.skills, chats: draft.chats, quote: draft.quote };
+    drafts[chatId] = {
+        text: draft.text,
+        mentions: draft.mentions,
+        skills: draft.skills,
+        chats: draft.chats,
+        quote: draft.quote,
+        ...(draft.quoteSource === null ? {} : { quoteSource: draft.quoteSource })
+    };
     storage.write(drafts);
 }
 /* Text handed to a draft from outside the composer goes under what was already typed, never over it. */
@@ -80,7 +89,8 @@ export function takeBackIntoDraft(current, taken) {
             skills: union(taken.skills, current.skills),
             chats: union(taken.chats, current.chats),
             attachments: [...checked.accepted.map((entry) => entry.upload), ...current.attachments],
-            quote: current.quote
+            quote: current.quote,
+            quoteSource: current.quoteSource
         },
         rejected: checked.rejected
     };

package/dist/chat/logic/picker-entries.d.ts

@@ -0,0 +1,10 @@
+import type { ModelInfo, ProviderInfo } from '@adecore/agent-contracts';
+export type PickerEntry = {
+    kind: 'model';
+    provider: ProviderInfo;
+    model: ModelInfo;
+} | {
+    kind: 'legacy';
+    count: number;
+};
+export declare function pickerEntriesOf(providers: readonly ProviderInfo[], query: string, legacyOpen: boolean): PickerEntry[];

package/dist/chat/logic/picker-entries.js

@@ -0,0 +1,19 @@
+function matches(model, query) {
+    return model.name.toLowerCase().includes(query) || model.slug.toLowerCase().includes(query);
+}
+/*
+ * The rows of the model list. A model an old CLI cannot run is a row like any other, so a search for
+ * only that model still finds the row that explains why it cannot be picked.
+ */
+export function pickerEntriesOf(providers, query, legacyOpen) {
+    const rows = providers.flatMap((entry) => entry.models.map((model) => ({ kind: 'model', provider: entry, model })));
+    if (query !== '') {
+        return rows.filter((row) => matches(row.model, query));
+    }
+    const live = rows.filter((row) => !row.model.legacy);
+    const legacy = rows.filter((row) => row.model.legacy);
+    if (legacy.length === 0) {
+        return live;
+    }
+    return legacyOpen ? [...live, { kind: 'legacy', count: legacy.length }, ...legacy] : [...live, { kind: 'legacy', count: legacy.length }];
+}

package/dist/chat/logic/timeline.d.ts

@@ -74,6 +74,7 @@ export type TimelineRow = {
     tools: ChatToolItem[];
     diff: ChatCheckpointDiff | null;
     checkpoint: boolean;
+    baseMoved?: BaseMoved;
 } | {
     kind: 'turn-fold';
     id: string;
@@ -115,5 +116,9 @@ export declare function findSubagentBranch(rows: readonly TimelineRow[], toolUse
     index: number;
     branch: SubagentBranch;
 } | null;
+export interface BaseMoved {
+    from: string;
+    to: string;
+}
 export declare function deriveTimelineRows(items: ChatItem[], options: TimelineOptions): TimelineRow[];
 export {};

package/dist/chat/logic/timeline.js

@@ -253,7 +253,16 @@ function changedFilesRow(turn, items) {
     if (empty) {
         return null;
     }
-    return { kind: 'changed-files', id: `files-${turn.id}`, turnId: turn.id, tools: edits, diff, checkpoint: turn.checkpoint !== undefined };
+    const moved = turn.checkpointHead !== undefined && turn.checkpointHeadAfter !== undefined && turn.checkpointHead !== turn.checkpointHeadAfter;
+    return {
+        kind: 'changed-files',
+        id: `files-${turn.id}`,
+        turnId: turn.id,
+        tools: edits,
+        diff,
+        checkpoint: turn.checkpoint !== undefined,
+        ...(moved ? { baseMoved: { from: turn.checkpointHead, to: turn.checkpointHeadAfter } } : {})
+    };
 }
 function lastAssistantRow(rows) {
     for (let i = rows.length - 1; i >= 0; i--) {

package/dist/chat/prompt-hold.d.ts

@@ -0,0 +1,8 @@
+export declare const PROMPT_HOLD_PAUSE_MS = 2000;
+export interface HoldInput {
+    typedAt: number | null;
+    composing: boolean;
+}
+export type HoldRelease = 'pause' | 'send' | 'blur' | 'show';
+export declare function holdsPrompt(input: HoldInput, now: number): boolean;
+export declare function holdLiftsIn(input: HoldInput, now: number): number | null;

package/dist/chat/prompt-hold.js

@@ -0,0 +1,16 @@
+/* How long a person must stop typing before a waiting prompt card takes the composer's place. */
+export const PROMPT_HOLD_PAUSE_MS = 2000;
+/* A card waits while the person is composing, or typed less than the pause ago. */
+export function holdsPrompt(input, now) {
+    if (input.composing) {
+        return true;
+    }
+    return input.typedAt !== null && now - input.typedAt < PROMPT_HOLD_PAUSE_MS;
+}
+/* The milliseconds until the hold lifts by itself; null when it holds until something else lifts it, or does not hold. */
+export function holdLiftsIn(input, now) {
+    if (input.composing || input.typedAt === null) {
+        return null;
+    }
+    return Math.max(0, input.typedAt + PROMPT_HOLD_PAUSE_MS - now);
+}

package/dist/chat/quote.d.ts

@@ -1,2 +1,6 @@
 export declare function quoteOf(selected: string): string | null;
 export declare function withQuote(quote: string, message: string): string;
+export declare function splitQuote(text: string): {
+    quote: string;
+    rest: string;
+} | null;

package/dist/chat/quote.js

@@ -23,3 +23,22 @@ export function withQuote(quote, message) {
         .join('\n');
     return message === '' ? block : `${block}\n\n${message}`;
 }
+/*
+ * The inverse of `withQuote`: the quote a message opens with and what follows it. Null when the text
+ * does not open with a blockquote that ends on a blank line or the end of the text.
+ */
+export function splitQuote(text) {
+    const lines = text.split('\n');
+    let end = 0;
+    while (end < lines.length && (lines[end] === '>' || lines[end].startsWith('> '))) {
+        end += 1;
+    }
+    if (end === 0 || (end < lines.length && lines[end] !== '')) {
+        return null;
+    }
+    const quote = lines
+        .slice(0, end)
+        .map((line) => line.slice(2))
+        .join('\n');
+    return { quote, rest: lines.slice(end + 1).join('\n') };
+}

package/dist/chat/stash.d.ts

@@ -12,13 +12,19 @@ export interface StashedPrompt {
     mentions: string[];
     skills: string[];
     attachments: StashedAttachment[];
+    quote?: StashedQuote;
     createdAt: number;
 }
+export interface StashedQuote {
+    text: string;
+    chatId: string;
+    itemId: string;
+}
 export declare function parseStash(raw: string | null): StashedPrompt[];
 export declare function withStashed(prompts: StashedPrompt[], entry: StashedPrompt): StashedPrompt[];
-export declare function stashedFrom(draft: ChatDraft, id: string, now: number): StashedPrompt | null;
+export declare function stashedFrom(draft: ChatDraft, id: string, now: number, chatId: string): StashedPrompt | null;
 export declare const useStash: import("zustand").UseBoundStore<import("zustand").StoreApi<{
     prompts: StashedPrompt[];
 }>>;
-export declare function stashDraft(draft: ChatDraft): boolean;
+export declare function stashDraft(draft: ChatDraft, chatId: string): boolean;
 export declare function forgetStashed(id: string): void;

package/dist/chat/stash.js

@@ -23,6 +23,16 @@ function attachments(value) {
         size: typeof entry.size === 'number' ? entry.size : 0
     }));
 }
+function stashedQuote(value) {
+    if (!isRecord(value) || typeof value.text !== 'string' || typeof value.chatId !== 'string' || typeof value.itemId !== 'string') {
+        return undefined;
+    }
+    return { text: value.text, chatId: value.chatId, itemId: value.itemId };
+}
+function stashedQuoteField(value) {
+    const quote = stashedQuote(value);
+    return quote === undefined ? {} : { quote };
+}
 /* Only the fields we know today, so anything an older or a broken write left behind falls away here. */
 export function parseStash(raw) {
     if (raw === null) {
@@ -42,6 +52,7 @@ export function parseStash(raw) {
             mentions: strings(entry.mentions),
             skills: strings(entry.skills),
             attachments: attachments(entry.attachments),
+            ...stashedQuoteField(entry.quote),
             createdAt: typeof entry.createdAt === 'number' ? entry.createdAt : 0
         }))
             .slice(0, STASH_LIMIT);
@@ -54,14 +65,19 @@ export function parseStash(raw) {
 export function withStashed(prompts, entry) {
     return [entry, ...prompts].slice(0, STASH_LIMIT);
 }
-/* What a draft looks like on the shelf, its quote folded into the text; null when there is nothing worth putting there. */
-export function stashedFrom(draft, id, now) {
+/*
+ * What a draft looks like on the shelf; null when there is nothing worth putting there. A quote that
+ * knows its reply stays apart, since it leads back to that reply in `chatId`; any other is folded into the text.
+ */
+export function stashedFrom(draft, id, now, chatId) {
     if (isEmptyDraft(draft)) {
         return null;
     }
+    const kept = draft.quote !== '' && draft.quoteSource !== null;
     return {
         id,
-        text: withQuote(draft.quote, draft.text),
+        text: kept ? draft.text : withQuote(draft.quote, draft.text),
+        ...(kept ? { quote: { text: draft.quote, chatId, itemId: draft.quoteSource } } : {}),
         mentions: [...draft.mentions],
         skills: [...draft.skills],
         attachments: draft.attachments.map((attachment) => ({ name: attachment.name, mime: attachment.mime, size: uploadBytes(attachment) })),
@@ -76,8 +92,8 @@ function write(prompts) {
     storage.write(prompts);
 }
 /* Puts a draft on the shelf; false when the composer held nothing to put there. */
-export function stashDraft(draft) {
-    const entry = stashedFrom(draft, `stash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, Date.now());
+export function stashDraft(draft, chatId) {
+    const entry = stashedFrom(draft, `stash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, Date.now(), chatId);
     if (!entry) {
         return false;
     }

package/dist/chat/subagent-list.d.ts

@@ -7,11 +7,17 @@ export declare function taskIdOf(item: ChatSubagentItem): string | null;
 export declare function statusWordOf(item: ChatSubagentItem, task: SubagentTask | null): StatusWord;
 export type TaskRowState = StatusWord | 'waiting';
 export declare function taskRowStateOf(item: ChatSubagentItem, task: SubagentTask | null, child: ChatInfo | undefined): TaskRowState;
+export declare function progressOf(states: readonly TaskRowState[]): {
+    done: number;
+    total: number;
+    waiting: number;
+    active: number;
+};
 export declare function flyoutSubagents(order: readonly string[], structure: Readonly<Record<string, ChatItem>>): ChatSubagentItem[];
 export declare function summaryWordOf(words: readonly StatusWord[]): StatusWord;
 export declare function badgeCountOf(words: readonly StatusWord[]): number;
 export declare function entryTimeOf(item: ChatSubagentItem, task: SubagentTask | null, now: number): string;
-export type SubagentStop = 'task' | 'mark';
+export type SubagentStop = 'task' | 'native' | 'mark';
 export declare function stopOf(item: ChatSubagentItem, turnRunning: boolean): SubagentStop | null;
 export declare function stopLabel(stop: SubagentStop): string;
 export type ComposerStop = 'turn' | 'turn-and-subagents';

package/dist/chat/subagent-list.js

@@ -36,6 +36,15 @@ export function taskRowStateOf(item, task, child) {
     }
     return word;
 }
+/* How far delegated work is: what settled as done, what still runs or waits, and how many of those wait on a person. */
+export function progressOf(states) {
+    return {
+        done: states.filter((state) => state === 'done').length,
+        total: states.length,
+        waiting: states.filter((state) => state === 'waiting').length,
+        active: states.filter((state) => state === 'running' || state === 'paused' || state === 'waiting').length
+    };
+}
 /*
  * What the flyout over the composer lists: every sub-agent still at work, and the ones that settled
  * since the last message, so a finished batch stays until the next message is sent. That includes an
@@ -93,10 +102,13 @@ export function stopOf(item, turnRunning) {
     if (item.origin === 'ruimte') {
         return item.childId === undefined ? null : 'task';
     }
+    if (item.native?.agentId) {
+        return 'native';
+    }
     return turnRunning ? null : 'mark';
 }
 export function stopLabel(stop) {
-    return stop === 'task' ? i18next.t('agent-chat:subagents.stop.task') : i18next.t('agent-chat:subagents.stop.mark');
+    return i18next.t(`agent-chat:subagents.stop.${stop}`);
 }
 export function composerStopOf(shiftKey) {
     return shiftKey ? 'turn-and-subagents' : 'turn';

package/dist/chat/timeline-scroll.d.ts

@@ -11,8 +11,12 @@ export declare function scrollTimelineToEnd(chatId: string, behavior?: ScrollBeh
 export declare function pageTimeline(chatId: string, direction: -1 | 1): boolean;
 export declare function registerMessageStepper(key: string, step: (direction: -1 | 1) => boolean): () => void;
 export declare function stepTimelineMessage(key: string, direction: -1 | 1): boolean;
-export declare function registerItemJumper(key: string, jump: (itemId: string) => void): () => void;
-export declare function jumpToTimelineItem(key: string, itemId: string): boolean;
+export interface ItemJumpOptions {
+    flash?: boolean;
+    onMissing?(): void;
+}
+export declare function registerItemJumper(key: string, jump: (itemId: string, options: ItemJumpOptions) => void): () => void;
+export declare function jumpToTimelineItem(key: string, itemId: string, options?: ItemJumpOptions): boolean;
 export type TurnTarget = 'prompt' | 'changes';
 type TurnJump = (turnId: string, target: TurnTarget) => void;
 export declare function registerTurnJumper(key: string, jump: TurnJump): () => void;

package/dist/chat/timeline-scroll.js

@@ -1,5 +1,7 @@
 // A page is a screen minus a little, so the line you were reading is still on it after the jump.
 const PAGE_OVERLAP = 0.9;
+// How long a jump asked before its thread registered stays up for that thread.
+const PENDING_JUMP_TTL_MS = 10_000;
 const scrollers = new Map();
 /* The timeline owns following; the composer subscribes here to show its jump-to-end button. */
 const ends = new Map();
@@ -83,10 +85,13 @@ function waitingJumps() {
     return {
         register(key, jump) {
             jumpers.set(key, jump);
-            if (waiting.has(key)) {
-                const target = waiting.get(key);
+            const pending = waiting.get(key);
+            if (pending !== undefined) {
                 waiting.delete(key);
-                jump(target);
+                // A jump nobody picked up for long is not what the person wants any more.
+                if (Date.now() - pending.at <= PENDING_JUMP_TTL_MS) {
+                    jump(pending.target);
+                }
             }
             return () => {
                 if (jumpers.get(key) === jump) {
@@ -97,7 +102,7 @@ function waitingJumps() {
         jump(key, target) {
             const jump = jumpers.get(key);
             if (jump === undefined) {
-                waiting.set(key, target);
+                waiting.set(key, { target, at: Date.now() });
                 return false;
             }
             jump(target);
@@ -107,11 +112,11 @@ function waitingJumps() {
 }
 const itemJumps = waitingJumps();
 export function registerItemJumper(key, jump) {
-    return itemJumps.register(key, jump);
+    return itemJumps.register(key, ({ itemId, options }) => jump(itemId, options));
 }
 /* False when that chat has no thread on screen; the jump then waits for the next one that registers. */
-export function jumpToTimelineItem(key, itemId) {
-    return itemJumps.jump(key, itemId);
+export function jumpToTimelineItem(key, itemId, options = {}) {
+    return itemJumps.jump(key, { itemId, options });
 }
 const turnJumps = waitingJumps();
 export function registerTurnJumper(key, jump) {

package/dist/chat/ui/ChatActivity.js

@@ -2,15 +2,15 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { useMemo } from 'react';
 import clsx from 'clsx';
 import { useTranslation } from 'react-i18next';
-import { Activity, Square, SquareTerminal } from 'lucide-react';
+import { Activity, MessageCircleQuestionMark, Square, SquareTerminal } from 'lucide-react';
 import { backgroundCounts } from '../activity.js';
-import { badgeCountOf, entryTimeOf, flyoutSubagents, statusWordOf, subagentTitle, summaryWordOf, taskIdOf } from '../subagent-list.js';
+import { badgeCountOf, entryTimeOf, flyoutSubagents, progressOf, statusWordOf, subagentTitle, summaryWordOf, taskIdOf, taskRowStateOf } from '../subagent-list.js';
 import { useSubagentSupport } from '../subagent-support.js';
 import { canOpenSubagent, crumbOf, openFromMain, useSubagentTrail } from '../subagent-view.js';
 import { SubagentStopButton } from './SubagentStopButton.js';
 import { formatElapsedShort } from '@adecore/ui/format';
 import { Icon, IconButton, Popover, Surface, useNow } from '@adecore/ui';
-import { useChatRow } from '../../state/chats.js';
+import { useChatRow, useChats } from '../../state/chats.js';
 import { chatHost } from '../../host.js';
 import { useChatScope } from '../../scope.js';
 import { useChatActions } from '../actions.js';
@@ -24,8 +24,14 @@ export function ChatActivity({ chatId }) {
     const order = useChatRow(chatId, (row) => row?.order) ?? NO_ITEMS;
     const structure = useChatRow(chatId, (row) => row?.structure);
     const subagents = useMemo(() => (structure === undefined ? [] : flyoutSubagents(order, structure)), [order, structure]);
-    const { id } = useChatScope();
+    const { id, keyOf } = useChatScope();
     const tasks = chatHost().tasks.useTasks(id);
+    const statuses = useChats((s) => s.statusByKey);
+    const progress = useMemo(() => progressOf(subagents.map((item) => {
+        const taskId = taskIdOf(item);
+        const child = item.childId === undefined ? undefined : statuses[keyOf(item.childId)]?.info;
+        return taskRowStateOf(item, taskId === null ? null : (tasks?.[taskId] ?? null), child);
+    })), [subagents, tasks, statuses, keyOf]);
     const words = useMemo(() => subagents.map((item) => {
         const taskId = taskIdOf(item);
         return statusWordOf(item, taskId === null ? null : (tasks?.[taskId] ?? null));
@@ -36,8 +42,14 @@ export function ChatActivity({ chatId }) {
     }
     const { shells, monitors } = backgroundCounts(background);
     const Slot = chatHost().SubagentSlot;
+    const counting = progress.active > 0 && progress.total > 1;
+    const label = counting
+        ? [t('activity.progress', { done: progress.done, total: progress.total }), progress.waiting > 0 && t('activity.needsYou', { count: progress.waiting })]
+            .filter(Boolean)
+            .join(', ')
+        : t('activity.subagents', { count: badgeCountOf(words) });
     return (_jsxs("div", { className: "mb-3 flex flex-wrap items-center gap-2", children: [subagents.length > 0 &&
-                (Slot === null ? (_jsx(Flyout, { icon: _jsx(StatusIcon, { word: summaryWordOf(words) }), label: t('activity.subagents', { count: badgeCountOf(words) }), heading: t('activity.subagents', { count: subagents.length }), children: _jsx(SubagentRows, { chatId: chatId, items: subagents }) })) : (_jsx(Slot, { chatId: chatId, items: subagents }))), background.length > 0 && (_jsx(Flyout, { icon: _jsx(Icon, { icon: shells > 0 ? SquareTerminal : Activity, size: 14 }), label: [shells > 0 && t('activity.shells', { count: shells }), monitors > 0 && t('activity.monitors', { count: monitors })]
+                (Slot === null ? (_jsx(Flyout, { icon: progress.waiting > 0 ? (_jsx(Icon, { icon: MessageCircleQuestionMark, size: 14, className: "shrink-0 text-status-needs-you" })) : (_jsx(StatusIcon, { word: summaryWordOf(words) })), label: label, heading: t('activity.subagents', { count: subagents.length }), children: _jsx(SubagentRows, { chatId: chatId, items: subagents }) })) : (_jsx(Slot, { chatId: chatId, items: subagents }))), background.length > 0 && (_jsx(Flyout, { icon: _jsx(Icon, { icon: shells > 0 ? SquareTerminal : Activity, size: 14 }), label: [shells > 0 && t('activity.shells', { count: shells }), monitors > 0 && t('activity.monitors', { count: monitors })]
                     .filter(Boolean)
                     .join(' · '), children: _jsx(BackgroundTaskRows, { chatId: chatId, tasks: background }) }))] }));
 }
@@ -47,7 +59,7 @@ export function StatusIcon({ word }) {
 }
 /* A chip that opens a list over it, headed by what the chip says unless the list counts more than the chip does. */
 function Flyout({ icon, label, heading = label, children }) {
-    return (_jsxs(Popover.Root, { children: [_jsxs(Surface, { render: _jsx(Popover.Trigger, {}), className: "pointer-events-auto inline-flex h-7.5 items-center gap-1.5 rounded-full px-3 text-xs text-text-muted hover:text-text", children: [icon, label] }), _jsxs(Popover.Popup, { side: "top", className: "w-80", children: [_jsx("div", { className: "px-2.5 pt-1.5 pb-1 text-xs text-text-faint", children: heading }), children] })] }));
+    return (_jsxs(Popover.Root, { children: [_jsxs(Surface, { render: _jsx(Popover.Trigger, {}), className: "pointer-events-auto inline-flex h-7.5 items-center gap-1.5 rounded-full px-3 text-xs text-text-muted tabular-nums hover:text-text", children: [icon, label] }), _jsxs(Popover.Popup, { side: "top", className: "w-80", children: [_jsx("div", { className: "px-2.5 pt-1.5 pb-1 text-xs text-text-faint", children: heading }), children] })] }));
 }
 /* One line of a flyout; with `onOpen` the line leads somewhere and closes the flyout on the way. */
 function ActivityRow({ icon, title, detail, time, onOpen, children }) {
@@ -62,12 +74,14 @@ function SubagentRows({ chatId, items }) {
 }
 function SubagentEntry({ chatId, item, now }) {
     const { t } = useTranslation('agent-chat');
-    const { id } = useChatScope();
+    const { id, keyOf } = useChatScope();
     const refused = useSubagentSupport((s) => s.unsupported[id] === true);
     const task = chatHost().tasks.useTask(id, taskIdOf(item));
     const { show } = useSubagentTrail(chatId);
+    const child = useChats((s) => (item.childId === undefined ? undefined : s.statusByKey[keyOf(item.childId)]?.info));
     const word = statusWordOf(item, task);
-    return (_jsx(ActivityRow, { icon: _jsx(StatusIcon, { word: word }), title: _jsxs(_Fragment, { children: [subagentTitle(item), _jsxs("span", { className: "sr-only", children: [", ", t(`common.status.${word}`)] })] }), time: entryTimeOf(item, task, now), onOpen: canOpenSubagent(item, refused) ? () => show(openFromMain(crumbOf(item))) : undefined, children: _jsx(SubagentStopButton, { chatId: chatId, item: item, className: "mr-1.5" }) }));
+    const state = taskRowStateOf(item, task, child);
+    return (_jsx(ActivityRow, { icon: _jsx(StatusIcon, { word: word }), title: _jsxs(_Fragment, { children: [subagentTitle(item), _jsxs("span", { className: "sr-only", children: [", ", state === 'waiting' ? t('rows.task.waiting') : t(`common.status.${word}`)] })] }), time: entryTimeOf(item, task, now), onOpen: canOpenSubagent(item, refused) ? () => show(openFromMain(crumbOf(item))) : undefined, children: _jsx(SubagentStopButton, { chatId: chatId, item: item, className: "mr-1.5" }) }));
 }
 /* Only drawn while the flyout is open, so the clock ticks for nobody otherwise. */
 function BackgroundTaskRows({ chatId, tasks }) {