@adecore/agents-react 0.21.2 → 0.22.1

package/dist/locales/nl/agent-chat.json

@@ -91,7 +91,8 @@
     "user": {
       "heading": "Jij",
       "showAll": "Alles tonen",
-      "showLess": "Minder tonen"
+      "showLess": "Minder tonen",
+      "quoteGone": "Het antwoord waar dit citaat vandaan kwam, staat niet meer in deze chat."
     },
     "report": {
       "heading": "Rapport"
@@ -107,7 +108,8 @@
     "note": {
       "hide": "Verbergen",
       "show": "Tonen",
-      "openFork": "Fork openen"
+      "openFork": "Fork openen",
+      "openWaiting": "Openen om te antwoorden"
     },
     "compaction": {
       "plain": "Context gecomprimeerd",
@@ -165,6 +167,9 @@
     },
     "changedFiles_one": "{{count}} gewijzigd bestand",
     "changedFiles_other": "{{count}} gewijzigde bestanden",
+    "folderChanges_one": "{{count}} wijziging in de map tijdens deze beurt",
+    "folderChanges_other": "{{count}} wijzigingen in de map tijdens deze beurt",
+    "baseMoved": "De branch is tijdens deze beurt verplaatst ({{from}} naar {{to}}), dus dit omvat ook wat daarmee binnenkwam.",
     "andMore": "en meer, afgekapt",
     "edits_one": "{{count}} bewerking",
     "edits_other": "{{count}} bewerkingen",
@@ -249,6 +254,17 @@
   },
   "composer": {
     "slotFailed": "Dit onderdeel kon niet worden getekend",
+    "inputLabel": "Bericht",
+    "menu": {
+      "commands": "Commando's",
+      "skills": "Skills",
+      "mentions": "Vermeldingen"
+    },
+    "held": {
+      "question": "Er wacht een vraag. Die opent zodra je even stopt met typen.",
+      "approval": "Er wacht een goedkeuring. Die opent zodra je even stopt met typen.",
+      "show": "Nu tonen"
+    },
     "commands": {
       "model": "Wissel van model",
       "compact": "Comprimeer de context",
@@ -294,7 +310,8 @@
     },
     "quote": {
       "add": "Citeren",
-      "remove": "Citaat verwijderen"
+      "remove": "Citaat verwijderen",
+      "goToSource": "Naar het antwoord"
     },
     "removeAttachment": "{{name}} verwijderen",
     "attach": "Bestanden toevoegen",
@@ -319,6 +336,9 @@
     "monitors_one": "{{count}} monitor",
     "monitors_other": "{{count}} monitors",
     "pausedUntil": "gepauzeerd tot {{time}}",
+    "progress": "{{done}} van {{total}} sub-agents klaar",
+    "needsYou_one": "{{count}} vraagt aandacht",
+    "needsYou_other": "{{count}} vragen aandacht",
     "took": {
       "done": "klaar in {{duration}}",
       "failed": "mislukt na {{duration}}",
@@ -332,8 +352,10 @@
   "subagents": {
     "stop": {
       "task": "Deze taak stoppen",
+      "native": "Deze sub-agent stoppen",
       "mark": "Markeren als gestopt. De CLI kan een losse sub-agent niet stoppen, dus die werkt mogelijk door tot het proces van de chat eindigt."
     },
+    "stale": "Deze sub-agent hoort bij een proces dat al gestopt is.",
     "title": "Sub-agents",
     "backToMain": "Terug naar de main agent",
     "loading": "Gesprek laden…",
@@ -344,9 +366,7 @@
     "stopFailed": "De sub-agent kon niet worden gestopt",
     "info": {
       "label": "Over deze sub-agent",
-      "tokens": "{{tokens}} tokens",
-      "showTask": "Opdracht tonen",
-      "hideTask": "Opdracht verbergen"
+      "tokens": "{{tokens}} tokens"
     }
   },
   "modes": {
@@ -382,7 +402,10 @@
       "noMatch": "Geen modellen gevonden",
       "legacyGroup_one": "Legacy-modellen ({{count}})",
       "legacyGroup_other": "Legacy-modellen ({{count}})",
-      "legacy": "Legacy"
+      "legacy": "Legacy",
+      "requires": "Vereist {{cli}} {{version}} of nieuwer op {{machine}}",
+      "requiresHere": "Vereist {{cli}} {{version}} of nieuwer",
+      "providerSettings": "Providerinstellingen"
     },
     "stash": {
       "title": "Stashed prompts",
@@ -504,7 +527,13 @@
     "chart": {
       "values": "Waarden",
       "summary": "{{count}} waarden, hoogste {{label}} met {{value}}",
-      "summarySeries": "{{count}} categorieën, hoogste {{series}} bij {{label}} met {{value}}"
+      "summarySeries": "{{count}} categorieën, hoogste {{series}} bij {{label}} met {{value}}",
+      "rowsLeftOut": "De eerste {{shown}} van {{total}} rijen zijn getekend.",
+      "seriesLeftOut_one": "{{series}} is niet getekend.",
+      "seriesLeftOut_other": "{{series}} zijn niet getekend.",
+      "sideBySide": "Negatieve waarden kunnen niet gestapeld worden, dus de reeksen staan naast elkaar.",
+      "showValues": "Alle waarden tonen",
+      "hideValues": "Waarden verbergen"
     },
     "image": {
       "label": "Afbeelding",
@@ -528,8 +557,8 @@
     "answered": "Beantwoord met “{{label}}”",
     "chose": "Gekozen: “{{label}}”",
     "choseOlder": "Gekozen: “{{label}}”, bij het antwoord van {{time}}",
-    "fixes_one": "{{count}} correctie",
-    "fixes_other": "{{count}} correcties",
+    "notes_one": "{{count}} opmerking",
+    "notes_other": "{{count}} opmerkingen",
     "shownAsText": "Als tekst getoond",
     "unknownComponent": "Deze versie kan {{component}} niet tekenen",
     "renderFailed": "Dit deel kon niet getekend worden",

package/dist/state/chats.d.ts

@@ -1,4 +1,4 @@
-import type { ChatApprovalItem, ChatBookmark, ChatEvent, ChatHistoryResult, ChatInfo, ChatItem, ChatQuestionItem, ChatVisual } from '@adecore/agent-contracts';
+import type { AgentKind, ChatApprovalItem, ChatBookmark, ChatEvent, ChatHistoryResult, ChatInfo, ChatItem, ChatQuestionItem, ChatVisual } from '@adecore/agent-contracts';
 export interface ChatState {
     info: ChatInfo;
     items: Record<string, ChatItem>;
@@ -43,5 +43,6 @@ export declare function applyEvent(state: ChatState, event: ChatEvent): ChatStat
 export declare const useChats: import("zustand").UseBoundStore<import("zustand").StoreApi<ChatsStore>>;
 export declare function chatSink(keyOf: (chatId: string) => string): ChatSink;
 export declare function useChatRow<T>(chatId: string, select: (row: ChatState | undefined) => T): T;
+export declare function useReportedModels(provider: AgentKind): ReadonlySet<string>;
 export declare function useCurrentItem<T extends ChatItem>(chatId: string, derived: T): T;
 export {};

package/dist/state/chats.js

@@ -1,5 +1,6 @@
+import { useContext, useMemo } from 'react';
 import { create } from 'zustand';
-import { useChatScope } from '../scope.js';
+import { ChatScopeContext, useChatScope } from '../scope.js';
 function isWaiting(item) {
     return (item?.kind === 'approval' && item.decision === 'pending') || (item?.kind === 'question' && item.state === 'pending');
 }
@@ -209,6 +210,23 @@ export function useChatRow(chatId, select) {
     const { keyOf } = useChatScope();
     return useChats((s) => select(s.byKey[keyOf(chatId)]));
 }
+/*
+ * The models the CLI of this provider reported running in the chats this client holds of the host.
+ * A model it ran is proof the CLI offers it, whatever the version says. Outside a scope there is none.
+ */
+export function useReportedModels(provider) {
+    const scope = useContext(ChatScopeContext);
+    const joined = useChats((s) => {
+        const names = new Set();
+        for (const [key, state] of Object.entries(s.statusByKey)) {
+            if (scope?.owns(key) === true && state.info.provider === provider && state.info.model !== null) {
+                names.add(state.info.model);
+            }
+        }
+        return [...names].sort().join('\n');
+    });
+    return useMemo(() => new Set(joined === '' ? [] : joined.split('\n')), [joined]);
+}
 /* The item as the thread holds it now, for a row derived from the structure, which a delta leaves alone. */
 export function useCurrentItem(chatId, derived) {
     return useChatRow(chatId, (row) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents-react",
-  "version": "0.21.2",
+  "version": "0.22.1",
   "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",
@@ -619,6 +639,11 @@
       "types": "./dist/chat/ui/intelligent-ui/use-later.d.ts",
       "default": "./dist/chat/ui/intelligent-ui/use-later.js"
     },
+    "./chat/ui/intelligent-ui/use-truncated": {
+      "source": "./src/chat/ui/intelligent-ui/use-truncated.ts",
+      "types": "./dist/chat/ui/intelligent-ui/use-truncated.d.ts",
+      "default": "./dist/chat/ui/intelligent-ui/use-truncated.js"
+    },
     "./chat/ui/intelligent-ui/use-ui-links": {
       "source": "./src/chat/ui/intelligent-ui/use-ui-links.ts",
       "types": "./dist/chat/ui/intelligent-ui/use-ui-links.d.ts",
@@ -1011,8 +1036,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.1",
+    "@adecore/intelligent-ui": "0.22.1",
     "@codemirror/commands": "^6.11.1",
     "@codemirror/language": "^6.12.4",
     "@codemirror/state": "^6.7.6",
@@ -1033,7 +1058,7 @@
     "zustand": "^5.0.15"
   },
   "peerDependencies": {
-    "@adecore/ui": "^0.21.2",
+    "@adecore/ui": "^0.22.1",
     "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}`);
 }
 
 /*