@adecore/agents-react 0.21.2 → 0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents-react",
-  "version": "0.21.2",
+  "version": "0.22.0",
   "description": "React agent chat threads, composers, approvals, provider accounts and usage views.",
   "type": "module",
   "exports": {
@@ -34,6 +34,11 @@
       "types": "./dist/agents/accounts.d.ts",
       "default": "./dist/agents/accounts.js"
     },
+    "./agents/model-requirement": {
+      "source": "./src/agents/model-requirement.ts",
+      "types": "./dist/agents/model-requirement.d.ts",
+      "default": "./dist/agents/model-requirement.js"
+    },
     "./agents/model-name": {
       "source": "./src/agents/model-name.ts",
       "types": "./dist/agents/model-name.d.ts",
@@ -104,6 +109,11 @@
       "types": "./dist/chat/guards.d.ts",
       "default": "./dist/chat/guards.js"
     },
+    "./chat/logic/picker-entries": {
+      "source": "./src/chat/logic/picker-entries.ts",
+      "types": "./dist/chat/logic/picker-entries.d.ts",
+      "default": "./dist/chat/logic/picker-entries.js"
+    },
     "./chat/logic/ansi": {
       "source": "./src/chat/logic/ansi.ts",
       "types": "./dist/chat/logic/ansi.d.ts",
@@ -219,6 +229,11 @@
       "types": "./dist/chat/preferences.d.ts",
       "default": "./dist/chat/preferences.js"
     },
+    "./chat/prompt-hold": {
+      "source": "./src/chat/prompt-hold.ts",
+      "types": "./dist/chat/prompt-hold.d.ts",
+      "default": "./dist/chat/prompt-hold.js"
+    },
     "./chat/quote": {
       "source": "./src/chat/quote.ts",
       "types": "./dist/chat/quote.d.ts",
@@ -494,6 +509,11 @@
       "types": "./dist/chat/ui/composer/keys.d.ts",
       "default": "./dist/chat/ui/composer/keys.js"
     },
+    "./chat/ui/composer/menu-aria": {
+      "source": "./src/chat/ui/composer/menu-aria.ts",
+      "types": "./dist/chat/ui/composer/menu-aria.d.ts",
+      "default": "./dist/chat/ui/composer/menu-aria.js"
+    },
     "./chat/ui/diff-theme": {
       "source": "./src/chat/ui/diff-theme.ts",
       "types": "./dist/chat/ui/diff-theme.d.ts",
@@ -1011,8 +1031,8 @@
     "test:visuals": "bun --config=integration.bunfig.toml --conditions=source test ./src/chat/visual-viewport.integration.test.ts"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.21.2",
-    "@adecore/intelligent-ui": "0.21.2",
+    "@adecore/agent-contracts": "0.22.0",
+    "@adecore/intelligent-ui": "0.22.0",
     "@codemirror/commands": "^6.11.1",
     "@codemirror/language": "^6.12.4",
     "@codemirror/state": "^6.7.6",
@@ -1033,7 +1053,7 @@
     "zustand": "^5.0.15"
   },
   "peerDependencies": {
-    "@adecore/ui": "^0.21.2",
+    "@adecore/ui": "^0.22.0",
     "i18next": "^26.4.2",
     "react": "^19.3.0",
     "react-dom": "^19.3.0",

package/src/agents/model-requirement.ts

@@ -0,0 +1,36 @@
+import type { ModelInfo, ProviderInfo } from '@adecore/agent-contracts';
+
+export interface ModelRequirement {
+    /* The CLI's name, as the provider list gives it. */
+    cli: string;
+    minVersion: string;
+}
+
+function partsOf(version: string, strict: boolean): number[] | null {
+    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: string, reported: ReadonlySet<string>): boolean {
+    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: ModelInfo, provider: ProviderInfo, reported: ReadonlySet<string>): ModelRequirement | null {
+    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/src/chat/chat-client.ts

@@ -4,6 +4,7 @@ import type {
     ChatAttachResult,
     ChatBookmark,
     ChatPreferencesPayload,
+    ChatQuoteSource,
     ChatSkill,
     ChatVisual,
     ModelSelection,
@@ -35,6 +36,8 @@ export interface ChatSendExtras {
     skills?: string[];
     /* Chats of the project picked with `@`; only their ids travel, the agent reads them itself. */
     chats?: string[];
+    /* The reply a quote at the head of the text was taken from. */
+    quoteSource?: ChatQuoteSource;
     attachments?: ChatAttachmentUpload[];
 }
 
@@ -170,9 +173,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/src/chat/drafts.ts

@@ -14,12 +14,22 @@ export interface ChatDraft {
     attachments: ChatAttachmentUpload[];
     /* A piece of an answer that goes above the text as a blockquote; empty for none. */
     quote: string;
+    /* The reply the quote was taken from; null when the quote names none. */
+    quoteSource: string | null;
 }
 
-export const EMPTY_DRAFT: ChatDraft = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '' };
+export const EMPTY_DRAFT: ChatDraft = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '', quoteSource: null };
 
 // Older records only had text; the rest is filled in on read.
-type DraftRecord = { text: string; mentions?: string[]; skills?: string[]; chats?: string[]; attachments?: ChatAttachmentUpload[]; quote?: string };
+type DraftRecord = {
+    text: string;
+    mentions?: string[];
+    skills?: string[];
+    chats?: string[];
+    attachments?: ChatAttachmentUpload[];
+    quote?: string;
+    quoteSource?: string;
+};
 
 const storage = persistedJson<Record<string, DraftRecord>>(
     storageKey,
@@ -63,7 +73,8 @@ export function readDraft(chatId: string): ChatDraft {
               skills: record.skills ?? [],
               chats: record.chats ?? [],
               attachments: record.attachments ?? [],
-              quote: record.quote ?? ''
+              quote: record.quote ?? '',
+              quoteSource: record.quoteSource ?? null
           }
         : EMPTY_DRAFT;
 }
@@ -82,13 +93,21 @@ export function writeDraft(chatId: string, draft: ChatDraft): void {
         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);
 }
 
@@ -108,7 +127,7 @@ function union(first: readonly string[], second: readonly string[]): string[] {
  */
 export function takeBackIntoDraft(
     current: ChatDraft,
-    taken: Omit<ChatDraft, 'quote'>
+    taken: Omit<ChatDraft, 'quote' | 'quoteSource'>
 ): { draft: ChatDraft; rejected: Array<{ name: string; reason: string }> } {
     const checked = checkAttachmentLimits(
         current.attachments.length,
@@ -122,7 +141,8 @@ export function takeBackIntoDraft(
             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/src/chat/logic/picker-entries.ts

@@ -0,0 +1,25 @@
+import type { ModelInfo, ProviderInfo } from '@adecore/agent-contracts';
+
+/* A model row, or the one row that folds the legacy models open. Both take a turn in the arrow keys. */
+export type PickerEntry = { kind: 'model'; provider: ProviderInfo; model: ModelInfo } | { kind: 'legacy'; count: number };
+
+function matches(model: ModelInfo, query: string): boolean {
+    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: readonly ProviderInfo[], query: string, legacyOpen: boolean): PickerEntry[] {
+    const rows = providers.flatMap((entry) => entry.models.map((model) => ({ kind: 'model' as const, 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/src/chat/logic/timeline.ts

@@ -52,7 +52,7 @@ export type TimelineRow =
     | { kind: 'question'; id: string; item: ChatQuestionItem }
     | { kind: 'note'; id: string; level: 'info' | 'warning' | 'error'; text: string; from?: string }
     | { kind: 'compaction'; id: string; preTokens: number | null }
-    | { kind: 'changed-files'; id: string; turnId: string; tools: ChatToolItem[]; diff: ChatCheckpointDiff | null; checkpoint: boolean }
+    | { kind: 'changed-files'; id: string; turnId: string; tools: ChatToolItem[]; diff: ChatCheckpointDiff | null; checkpoint: boolean; baseMoved?: BaseMoved }
     | { kind: 'turn-fold'; id: string; turn: ChatTurnItem; label: string; work: string[]; hiddenCount: number; expanded: boolean }
     | { kind: 'forks'; id: string; turnId: string }
     | { kind: 'working'; id: string; startedAt: number }
@@ -322,6 +322,12 @@ function rowsForItems(items: ChatItem[], options: TimelineOptions, children: Map
     return rows;
 }
 
+/* The branch the turn started on was not the one it ended on, so its diff also holds what came in with the move. */
+export interface BaseMoved {
+    from: string;
+    to: string;
+}
+
 /* The card of a settled turn: the checkpoint diff when the host took one, else what the tool calls carry. */
 function changedFilesRow(turn: ChatTurnItem, items: ChatItem[]): TimelineRow | null {
     const edits = items.filter(
@@ -332,7 +338,16 @@ function changedFilesRow(turn: ChatTurnItem, items: ChatItem[]): TimelineRow | n
     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: TimelineRow[]): TimelineRow | null {

package/src/chat/prompt-hold.ts

@@ -0,0 +1,27 @@
+/* How long a person must stop typing before a waiting prompt card takes the composer's place. */
+export const PROMPT_HOLD_PAUSE_MS = 2000;
+
+export interface HoldInput {
+    /* When the last change to the draft was made; null when none was since the hold last lifted. */
+    typedAt: number | null;
+    /* An IME composition is under way, which can run for any length without a change. */
+    composing: boolean;
+}
+
+export type HoldRelease = 'pause' | 'send' | 'blur' | 'show';
+
+/* A card waits while the person is composing, or typed less than the pause ago. */
+export function holdsPrompt(input: HoldInput, now: number): boolean {
+    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: HoldInput, now: number): number | null {
+    if (input.composing || input.typedAt === null) {
+        return null;
+    }
+    return Math.max(0, input.typedAt + PROMPT_HOLD_PAUSE_MS - now);
+}

package/src/chat/quote.ts

@@ -24,3 +24,23 @@ export function withQuote(quote: string, message: string): string {
         .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: string): { quote: string; rest: string } | null {
+    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/src/chat/stash.ts

@@ -27,9 +27,17 @@ export interface StashedPrompt {
     mentions: string[];
     skills: string[];
     attachments: StashedAttachment[];
+    /* A quote that knew its reply, kept apart from the text so it can lead back to it in the chat it came from. */
+    quote?: StashedQuote;
     createdAt: number;
 }
 
+export interface StashedQuote {
+    text: string;
+    chatId: string;
+    itemId: string;
+}
+
 function strings(value: unknown): string[] {
     return Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === 'string') : [];
 }
@@ -45,6 +53,18 @@ function attachments(value: unknown): StashedAttachment[] {
     }));
 }
 
+function stashedQuote(value: unknown): StashedQuote | undefined {
+    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: unknown): { quote?: StashedQuote } {
+    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: string | null): StashedPrompt[] {
     if (raw === null) {
@@ -64,6 +84,7 @@ export function parseStash(raw: string | null): StashedPrompt[] {
                 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);
@@ -77,14 +98,19 @@ export function withStashed(prompts: StashedPrompt[], entry: StashedPrompt): Sta
     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: ChatDraft, id: string, now: number): StashedPrompt | null {
+/*
+ * 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: ChatDraft, id: string, now: number, chatId: string): StashedPrompt | null {
     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) })),
@@ -106,8 +132,8 @@ function write(prompts: StashedPrompt[]): void {
 }
 
 /* Puts a draft on the shelf; false when the composer held nothing to put there. */
-export function stashDraft(draft: ChatDraft): boolean {
-    const entry = stashedFrom(draft, `stash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, Date.now());
+export function stashDraft(draft: ChatDraft, chatId: string): boolean {
+    const entry = stashedFrom(draft, `stash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, Date.now(), chatId);
     if (!entry) {
         return false;
     }

package/src/chat/subagent-list.ts

@@ -48,6 +48,16 @@ export function taskRowStateOf(item: ChatSubagentItem, task: SubagentTask | null
     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: readonly TaskRowState[]): { done: number; total: number; waiting: number; active: number } {
+    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
@@ -106,11 +116,12 @@ export function entryTimeOf(item: ChatSubagentItem, task: SubagentTask | null, n
 }
 
 /*
- * What the Stop of an active entry does: a task stops the node working on it, and a subagent of the
- * CLI's own is only marked stopped, since no CLI stops one on its own. While the chat's turn runs that
- * turn may still wait on it, so stopping the turn (the composer's Stop) is the only offer then.
+ * What the Stop of an active entry does: a task stops the node working on it, and a subagent whose CLI
+ * named its task id (`native`) is ended on its own, turn or not. Any other subagent of the CLI's own is
+ * only marked stopped; while the chat's turn runs that turn may still wait on it, so stopping the turn
+ * (the composer's Stop) is the only offer then.
  */
-export type SubagentStop = 'task' | 'mark';
+export type SubagentStop = 'task' | 'native' | 'mark';
 
 export function stopOf(item: ChatSubagentItem, turnRunning: boolean): SubagentStop | null {
     if (item.status !== 'running') {
@@ -119,11 +130,14 @@ export function stopOf(item: ChatSubagentItem, turnRunning: boolean): SubagentSt
     if (item.origin === 'ruimte') {
         return item.childId === undefined ? null : 'task';
     }
+    if (item.native?.agentId) {
+        return 'native';
+    }
     return turnRunning ? null : 'mark';
 }
 
 export function stopLabel(stop: SubagentStop): string {
-    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}`);
 }
 
 /*

package/src/chat/timeline-scroll.ts

@@ -1,6 +1,9 @@
 // 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;
+
 type Scroller = {
     element: HTMLElement;
     follow: (enabled: boolean) => void;
@@ -103,14 +106,17 @@ export function stepTimelineMessage(key: string, direction: -1 | 1): boolean {
  */
 function waitingJumps<T>(): { register(key: string, jump: (target: T) => void): () => void; jump(key: string, target: T): boolean } {
     const jumpers = new Map<string, (target: T) => void>();
-    const waiting = new Map<string, T>();
+    const waiting = new Map<string, { target: T; at: number }>();
     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) {
@@ -121,7 +127,7 @@ function waitingJumps<T>(): { register(key: string, jump: (target: T) => void):
         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);
@@ -130,15 +136,23 @@ function waitingJumps<T>(): { register(key: string, jump: (target: T) => void):
     };
 }
 
-const itemJumps = waitingJumps<string>();
+/* What a jump to an item may ask beyond scrolling to it. */
+export interface ItemJumpOptions {
+    /* Lights the row up once it is in view. */
+    flash?: boolean;
+    /* Runs when the item is nowhere in the thread, after every earlier page has been tried. */
+    onMissing?(): void;
+}
+
+const itemJumps = waitingJumps<{ itemId: string; options: ItemJumpOptions }>();
 
-export function registerItemJumper(key: string, jump: (itemId: string) => void): () => void {
-    return itemJumps.register(key, jump);
+export function registerItemJumper(key: string, jump: (itemId: string, options: ItemJumpOptions) => void): () => void {
+    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: string, itemId: string): boolean {
-    return itemJumps.jump(key, itemId);
+export function jumpToTimelineItem(key: string, itemId: string, options: ItemJumpOptions = {}): boolean {
+    return itemJumps.jump(key, { itemId, options });
 }
 
 /* Which part of a turn a jump lands on: the message that opened it, or the files it changed. */

package/src/chat/ui/ChatActivity.tsx

@@ -1,16 +1,16 @@
 import { useMemo, type ReactNode } 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 type { ChatBackgroundTask, ChatSubagentItem } from '@adecore/agent-contracts';
 import { backgroundCounts } from '../activity';
-import { badgeCountOf, entryTimeOf, flyoutSubagents, statusWordOf, subagentTitle, summaryWordOf, taskIdOf } from '../subagent-list';
+import { badgeCountOf, entryTimeOf, flyoutSubagents, progressOf, statusWordOf, subagentTitle, summaryWordOf, taskIdOf, taskRowStateOf } from '../subagent-list';
 import { useSubagentSupport } from '../subagent-support';
 import { canOpenSubagent, crumbOf, openFromMain, useSubagentTrail } from '../subagent-view';
 import { SubagentStopButton } from './SubagentStopButton';
 import { formatElapsedShort } from '@adecore/ui/format';
 import { Icon, IconButton, Popover, Surface, useNow } from '@adecore/ui';
-import { useChatRow } from '../../state/chats';
+import { useChatRow, useChats } from '../../state/chats';
 import { chatHost } from '../../host';
 import { useChatScope } from '../../scope';
 import { useChatActions } from '../actions';
@@ -28,8 +28,20 @@ export function ChatActivity({ chatId }: { chatId: string }) {
     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) => {
@@ -44,13 +56,25 @@ export function ChatActivity({ chatId }: { chatId: string }) {
     }
     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 (
         <div className="mb-3 flex flex-wrap items-center gap-2">
             {subagents.length > 0 &&
                 (Slot === null ? (
                     <Flyout
-                        icon={<StatusIcon word={summaryWordOf(words)} />}
-                        label={t('activity.subagents', { count: badgeCountOf(words) })}
+                        icon={
+                            progress.waiting > 0 ? (
+                                <Icon icon={MessageCircleQuestionMark} size={14} className="shrink-0 text-status-needs-you" />
+                            ) : (
+                                <StatusIcon word={summaryWordOf(words)} />
+                            )
+                        }
+                        label={label}
                         heading={t('activity.subagents', { count: subagents.length })}
                     >
                         <SubagentRows chatId={chatId} items={subagents} />
@@ -83,7 +107,7 @@ function Flyout({ icon, label, heading = label, children }: { icon: ReactNode; l
         <Popover.Root>
             <Surface
                 render={<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"
+                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"
             >
                 {icon}
                 {label}
@@ -148,11 +172,13 @@ function SubagentRows({ chatId, items }: { chatId: string; items: readonly ChatS
 
 function SubagentEntry({ chatId, item, now }: { chatId: string; item: ChatSubagentItem; now: number }) {
     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);
+    const state = taskRowStateOf(item, task, child);
     return (
         <ActivityRow
             icon={<StatusIcon word={word} />}
@@ -160,7 +186,7 @@ function SubagentEntry({ chatId, item, now }: { chatId: string; item: ChatSubage
                 <>
                     {subagentTitle(item)}
                     {/* The icon says the state to the eye; a screen reader hears it with the title. */}
-                    <span className="sr-only">, {t(`common.status.${word}`)}</span>
+                    <span className="sr-only">, {state === 'waiting' ? t('rows.task.waiting') : t(`common.status.${word}`)}</span>
                 </>
             }
             time={entryTimeOf(item, task, now)}