@adecore/agents-react 0.31.12 → 0.32.0

package/src/chat/composer-effort.ts

@@ -0,0 +1,32 @@
+import type { EffortStep } from './logic/effort';
+
+type Stepper = (step: EffortStep) => void;
+
+/*
+ * A command outside the composer, such as a menu row or a shortcut of the app, steps the reasoning effort
+ * of a chat whose composer is on screen. Keyed with the scope's `keyOf`, like `sendFromComposer`. One chat can
+ * have two composers on screen; the one that came last steps, and the one before takes over when it goes.
+ */
+const steppers = new Map<string, Stepper[]>();
+
+export function registerEffortStepper(key: string, stepper: Stepper): () => void {
+    steppers.set(key, [...(steppers.get(key) ?? []), stepper]);
+    return () => {
+        const left = (steppers.get(key) ?? []).filter((entry) => entry !== stepper);
+        if (left.length > 0) {
+            steppers.set(key, left);
+        } else {
+            steppers.delete(key);
+        }
+    };
+}
+
+/* False when that chat has no composer on screen. At either end of the model's efforts the composer says so and nothing changes. */
+export function stepEffortFromComposer(key: string, step: EffortStep): boolean {
+    const stepper = steppers.get(key)?.at(-1);
+    if (stepper === undefined) {
+        return false;
+    }
+    stepper(step);
+    return true;
+}

package/src/chat/forks.ts

@@ -1,4 +1,3 @@
-import { useMemo } from 'react';
 import type { ChatInfo } from '@adecore/agent-contracts';
 import { forkIdsAfter, forkedTurnIds } from './logic/fork';
 import { useChatScope } from '../scope';
@@ -40,15 +39,15 @@ function splitIds(joined: string): string[] {
 /* The turns of this chat a fork went on after, for the thread to put a line under. */
 export function useForkedTurns(chatId: string): ReadonlySet<string> {
     const { owns } = useChatScope();
-    const select = useMemo(() => joinedForks(owns, (infos) => forkedTurnIds(infos, chatId)), [owns, chatId]);
+    const select = joinedForks(owns, (infos) => forkedTurnIds(infos, chatId));
     const joined = useChats(select);
-    return useMemo(() => new Set(splitIds(joined)), [joined]);
+    return new Set(splitIds(joined));
 }
 
 /* The forks that went on after this turn of this chat. */
 export function useForkIdsAfter(chatId: string, turnId: string): string[] {
     const { owns } = useChatScope();
-    const select = useMemo(() => joinedForks(owns, (infos) => forkIdsAfter(infos, chatId, turnId)), [owns, chatId, turnId]);
+    const select = joinedForks(owns, (infos) => forkIdsAfter(infos, chatId, turnId));
     const joined = useChats(select);
-    return useMemo(() => splitIds(joined), [joined]);
+    return splitIds(joined);
 }

package/src/chat/index.ts

@@ -1,9 +1,11 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
-export { type AccountChoice, useAccountChoice } from './account-choice';
+export { type AccountChoice, useAccountChoice, type NewAccountChoice, useNewAccountChoice } from './account-choice';
 export { transportActions, actionsOf, useChatActions } from './actions';
 export { type ChatSendExtras, ChatClient } from './chat-client';
 export type { ProjectChat } from './chat-references';
 export { sendFromComposer, type ComposerSend } from './composer-send';
+export { stepEffortFromComposer } from './composer-effort';
+export type { EffortStep } from './logic/effort';
 export { EMPTY_DRAFT, useDrafts, readDraft, writeDraft, offerDraft, type ChatDraft } from './drafts';
 export { stripAnsi } from './logic/ansi';
 export {

package/src/chat/logic/effort.ts

@@ -0,0 +1,32 @@
+import type { ModelInfo, ModelOptionChoice, ModelSelection } from '@adecore/agent-contracts';
+
+/* The option a catalog names the reasoning effort by; its choices run from the least to the most. */
+export const EFFORT_OPTION = 'effort';
+
+/* `up` is one choice more effort, `down` one less. */
+export type EffortStep = 'up' | 'down';
+
+export type EffortStepResult =
+    | { kind: 'stepped'; selection: ModelSelection; choice: ModelOptionChoice }
+    /* Already at the end of the model's choices that way, which `choice` names. */
+    | { kind: 'edge'; choice: ModelOptionChoice }
+    /* The model has no effort to step, or the catalog does not know the model. */
+    | { kind: 'none' };
+
+/* One step of effort within what the model offers. A value the model no longer offers counts as its default. */
+export function stepEffort(model: ModelInfo | undefined, selection: ModelSelection, step: EffortStep): EffortStepResult {
+    const option = model?.options.find((candidate) => candidate.id === EFFORT_OPTION);
+    if (option === undefined || option.type !== 'select') {
+        return { kind: 'none' };
+    }
+    const chosen = selection.options[EFFORT_OPTION];
+    const index = option.choices.findIndex((choice) => choice.id === chosen);
+    const from = index === -1 ? option.choices.findIndex((choice) => choice.id === option.defaultChoice) : index;
+    const current = Math.max(0, from);
+    const next = current + (step === 'up' ? 1 : -1);
+    const choice = option.choices[next];
+    if (choice === undefined) {
+        return { kind: 'edge', choice: option.choices[current]! };
+    }
+    return { kind: 'stepped', selection: { ...selection, options: { ...selection.options, [EFFORT_OPTION]: choice.id } }, choice };
+}

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

@@ -17,6 +17,11 @@ export interface PickerCurrent {
     model: string;
 }
 
+/* The models a person starred, per CLI. */
+export type FavoritesOf = (kind: AgentKind) => ReadonlySet<string>;
+
+const NO_FAVORITES: FavoritesOf = () => new Set();
+
 function matches(model: ModelInfo, query: string): boolean {
     return model.name.toLowerCase().includes(query) || model.slug.toLowerCase().includes(query) || (model.vendor?.toLowerCase().includes(query) ?? false);
 }
@@ -40,12 +45,31 @@ export function modelsByVendor(models: ModelInfo[]): ModelInfo[] {
     });
 }
 
-/* The models a long list shows before it is opened: the default and the one that is picked. Null when the list is short enough to show whole. */
-export function shortlistOf(kind: AgentKind, models: ModelInfo[], current: PickerCurrent | null): ModelInfo[] | null {
+/* The starred models first, in the order they came, then the rest by maker. */
+export function favoritesFirst(models: ModelInfo[], favorites: ReadonlySet<string>): ModelInfo[] {
+    if (favorites.size === 0) {
+        return modelsByVendor(models);
+    }
+    return [...models.filter((model) => favorites.has(model.slug)), ...modelsByVendor(models.filter((model) => !favorites.has(model.slug)))];
+}
+
+/*
+ * The models a long list shows before it is opened: the starred ones, the default and the one that is picked.
+ * Null when the list is short enough to show whole.
+ */
+export function shortlistOf(
+    kind: AgentKind,
+    models: ModelInfo[],
+    current: PickerCurrent | null,
+    favorites: ReadonlySet<string> = new Set()
+): ModelInfo[] | null {
     if (models.length <= COMPACT_MODEL_LIMIT) {
         return null;
     }
-    return modelsByVendor(models.filter((model) => model.isDefault || (current?.provider === kind && current.model === model.slug)));
+    return favoritesFirst(
+        models.filter((model) => model.isDefault || favorites.has(model.slug) || (current?.provider === kind && current.model === model.slug)),
+        favorites
+    );
 }
 
 /* Whether the providers offer enough models together that a search is quicker than reading the list. */
@@ -53,11 +77,21 @@ export function wantsModelSearch(providers: readonly ProviderInfo[]): boolean {
     return providers.reduce((count, entry) => count + entry.models.length, 0) > COMPACT_MODEL_LIMIT;
 }
 
-/* Every model of every provider that a search finds, legacy ones included, by maker; a provider with none is left out. */
-export function searchModels(providers: readonly ProviderInfo[], query: string): Array<{ entry: ProviderInfo; models: ModelInfo[] }> {
+/* Every model of every provider that a search finds, legacy ones included, starred first and then by maker; a provider with none is left out. */
+export function searchModels(
+    providers: readonly ProviderInfo[],
+    query: string,
+    favoritesOf: FavoritesOf = NO_FAVORITES
+): Array<{ entry: ProviderInfo; models: ModelInfo[] }> {
     const needle = query.trim().toLowerCase();
     return providers
-        .map((entry) => ({ entry, models: modelsByVendor(entry.models.filter((model) => matches(model, needle))) }))
+        .map((entry) => ({
+            entry,
+            models: favoritesFirst(
+                entry.models.filter((model) => matches(model, needle)),
+                favoritesOf(entry.kind)
+            )
+        }))
         .filter((group) => group.models.length > 0);
 }
 
@@ -67,17 +101,18 @@ const NONE: ReadonlySet<AgentKind> = new Set();
  * 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. A search looks through
  * every model of every provider; without one, a provider with many models shows a short list and a row
- * that opens the rest, grouped by maker.
+ * that opens the rest, grouped by maker. A provider's starred models come first wherever it lists them.
  */
 export function pickerEntriesOf(
     providers: readonly ProviderInfo[],
     query: string,
     legacyOpen: boolean,
     expanded: ReadonlySet<AgentKind> = NONE,
-    current: PickerCurrent | null = null
+    current: PickerCurrent | null = null,
+    favoritesOf: FavoritesOf = NO_FAVORITES
 ): PickerEntry[] {
     const rowsOf = (entry: ProviderInfo, models: ModelInfo[]): PickerEntry[] =>
-        modelsByVendor(models).map((model) => ({ kind: 'model', provider: entry, model }));
+        favoritesFirst(models, favoritesOf(entry.kind)).map((model) => ({ kind: 'model', provider: entry, model }));
     if (query !== '') {
         return providers.flatMap((entry) =>
             rowsOf(
@@ -91,7 +126,7 @@ export function pickerEntriesOf(
     );
     const live = providers.flatMap((entry): PickerEntry[] => {
         const models = entry.models.filter((model) => !model.legacy);
-        const shortlist = shortlistOf(entry.kind, models, current);
+        const shortlist = shortlistOf(entry.kind, models, current, favoritesOf(entry.kind));
         if (shortlist === null) {
             return rowsOf(entry, models);
         }

package/src/chat/logic/resume-compaction.ts

@@ -9,31 +9,39 @@ export const RESUME_COMPACTION_TOKENS = 100_000;
 /* The longest prompt cache Claude keeps is an hour, so past this the whole thread is read again anyway. */
 export const RESUME_COMPACTION_IDLE_MS = 70 * 60_000;
 
+/* `cache-expired` when the CLI named when its prompt cache goes cold, `idle` when only the silence says so. */
+export type ResumeCompactionReason = 'cache-expired' | 'idle';
+
 export interface ResumeCompactionOffer {
     /* The turn the offer is about, and the key "Keep full history" is remembered under. */
     turnId: string;
     tokens: number;
+    reason: ResumeCompactionReason;
 }
 
-function lastTurn(items: readonly ChatItem[]): Extract<ChatItem, { kind: 'turn' }> | null {
-    return items.findLast((item): item is Extract<ChatItem, { kind: 'turn' }> => item.kind === 'turn') ?? null;
-}
+type Turn = Extract<ChatItem, { kind: 'turn' }>;
 
-/* Whether to offer compacting before the next message. */
-export function resumeCompactionOffer({
-    info,
-    compaction,
-    items,
-    dismissedTurnId,
-    now
-}: {
+interface OfferInput {
     info: ChatInfo;
     /* Absent until the host answered `provider.list`. */
     compaction: ProviderCapabilities['compaction'] | undefined;
     items: readonly ChatItem[];
     dismissedTurnId: string | null;
-    now: number;
-}): ResumeCompactionOffer | null {
+}
+
+/* The newest turn by when it started, so a thread that arrives out of order still names the turn that ran last. */
+function lastTurn(items: readonly ChatItem[]): Turn | null {
+    let last: Turn | null = null;
+    for (const item of items) {
+        if (item.kind === 'turn' && (last === null || item.createdAt >= last.createdAt)) {
+            last = item;
+        }
+    }
+    return last;
+}
+
+/* The turn an offer would be about, or null while nothing could be offered whatever the time. */
+function offerableTurn({ info, compaction, items, dismissedTurnId }: OfferInput): Turn | null {
     if (compaction === undefined || compaction === 'none') {
         return null;
     }
@@ -47,9 +55,6 @@ export function resumeCompactionOffer({
     if (turn === null || turn.endedAt === null || turn.id === dismissedTurnId) {
         return null;
     }
-    if (now - turn.endedAt < RESUME_COMPACTION_IDLE_MS) {
-        return null;
-    }
     /*
      * `contextTokens` keeps the old number until the next request, so without this the offer would
      * come straight back after a compaction. A native compaction is a turn without a message of the
@@ -58,5 +63,78 @@ export function resumeCompactionOffer({
     if (items.some((item) => item.kind === 'compaction' && item.turnId === turn.id)) {
         return null;
     }
-    return { turnId: turn.id, tokens: info.usage.contextTokens };
+    return turn;
+}
+
+/* A silence longer than any cache lives stands in for an expiry from a CLI that names none. */
+function dueAtOf(info: ChatInfo, endedAt: number): number {
+    return info.usage.cacheExpiresAt ?? endedAt + RESUME_COMPACTION_IDLE_MS;
+}
+
+/*
+ * When the next message would pay for the whole thread again, or null while nothing could be offered,
+ * so a surface knows whether to keep a timer.
+ */
+export function resumeCompactionDueAt(input: OfferInput): number | null {
+    const endedAt = offerableTurn(input)?.endedAt ?? null;
+    return endedAt === null ? null : dueAtOf(input.info, endedAt);
+}
+
+/* Whether to offer compacting before the next message. */
+export function resumeCompactionOffer(input: OfferInput & { now: number }): ResumeCompactionOffer | null {
+    const turn = offerableTurn(input);
+    if (turn === null || turn.endedAt === null || input.now < dueAtOf(input.info, turn.endedAt)) {
+        return null;
+    }
+    return {
+        turnId: turn.id,
+        tokens: input.info.usage.contextTokens,
+        reason: input.info.usage.cacheExpiresAt === undefined ? 'idle' : 'cache-expired'
+    };
+}
+
+/* What `watchDueAt` keeps time with; a test hands in a fake. */
+export interface DueClock {
+    now(): number;
+    setTimer(run: () => void, ms: number): unknown;
+    clearTimer(timer: unknown): void;
+    /* Calls `wake` when the page may have slept or sat in the background, and answers how to stop. */
+    onWake(wake: () => void): () => void;
+}
+
+/*
+ * Calls `due` with the time once `dueAt` passed. A timer can fire a few milliseconds early, and one that runs on a
+ * monotonic clock fires late after the system slept, so an early timer is armed again and a wake looks at once.
+ */
+export function watchDueAt(dueAt: number, due: (now: number) => void, clock: DueClock): () => void {
+    let timer: unknown = null;
+    let done = false;
+    const check = (): void => {
+        if (timer !== null) {
+            clock.clearTimer(timer);
+            timer = null;
+        }
+        if (done) {
+            return;
+        }
+        const now = clock.now();
+        if (now >= dueAt) {
+            done = true;
+            due(now);
+            return;
+        }
+        timer = clock.setTimer(() => {
+            timer = null;
+            check();
+        }, dueAt - now);
+    };
+    const stopWake = clock.onWake(check);
+    check();
+    return () => {
+        done = true;
+        stopWake();
+        if (timer !== null) {
+            clock.clearTimer(timer);
+        }
+    };
 }

package/src/chat/logic/timeline.ts

@@ -125,12 +125,13 @@ export function summarizeGroup(tools: ChatToolItem[], looks?: readonly CommandLo
     }
     const names = new Set(tools.map((tool) => tool.name));
     const only = names.size === 1 ? tools[0]!.name : null;
-    if (only !== null && toolEntry(only)?.grouped === true) {
+    const failed = tools.filter(failedFileChange);
+    if (only !== null && toolEntry(only)?.grouped === true && failed.length === 0) {
         return i18next.t(`agent-chat:group.tools.${only}`, { count: tools.length });
     }
     // Counts the files rather than the calls: three edits to one file are one file edited.
-    if (tools.every((tool) => isFileChange(tool.name))) {
-        const paths = new Set(tools.map(editedPath));
+    if (tools.every((tool) => isFileChange(tool.name)) && failed.length < tools.length) {
+        const paths = new Set(tools.filter((tool) => !failedFileChange(tool)).map(editedPath));
         return i18next.t('agent-chat:group.edited', { count: paths.size });
     }
     if (only !== null) {
@@ -139,6 +140,11 @@ export function summarizeGroup(tools: ChatToolItem[], looks?: readonly CommandLo
     return i18next.t('agent-chat:group.toolCalls', { count: tools.length });
 }
 
+/* A file change that failed or was refused changed nothing: it counts as a call, never as an edit. */
+function failedFileChange(tool: ChatToolItem): boolean {
+    return isFileChange(tool.name) && tool.state === 'error';
+}
+
 function editedPath(tool: ChatToolItem): string {
     return (tool.input as { file_path?: string })?.file_path ?? tool.id;
 }
@@ -168,6 +174,8 @@ export function summarizeTurn(tools: readonly ChatToolItem[], looks?: readonly C
         if (run !== null && group !== undefined) {
             // Keyed by the program too, so two looks with a key in common keep their own sentences.
             add(`look:${run.look.program}:${group.key}`, group.sentence);
+        } else if (failedFileChange(tool)) {
+            other += 1;
         } else if (isFileChange(tool.name)) {
             edited.add(editedPath(tool));
             add('agent-chat:group.edited', (count) => i18next.t('agent-chat:group.edited', { count }), edited.size);

package/src/chat/preferences.ts

@@ -20,6 +20,8 @@ export interface ChatPreferences {
     readingWidth: ChatReadingWidth;
     /* Which key sends from the composer. It never reaches a machine either. */
     sendKey: ChatSendKey;
+    /* The models a person starred, per CLI, which the pickers list first. Neither does this. */
+    favoriteModels: Partial<Record<AgentKind, string[]>>;
     /* When a person last changed any of it; what settles whose pick a machine uses when several clients told it one. */
     changedAt: number;
 }
@@ -32,9 +34,23 @@ export const DEFAULT_CHAT_PREFERENCES: ChatPreferences = {
     accountByMachine: {},
     readingWidth: DEFAULT_READING_WIDTH,
     sendKey: DEFAULT_SEND_KEY,
+    favoriteModels: {},
     changedAt: 0
 };
 
+/* Only lists of slugs survive, so a hand-edited or older record cannot put something else in the pickers. */
+function parseFavoriteModels(stored: unknown): Partial<Record<AgentKind, string[]>> {
+    if (typeof stored !== 'object' || stored === null || Array.isArray(stored)) {
+        return {};
+    }
+    return Object.fromEntries(
+        Object.entries(stored).flatMap(([provider, slugs]) => {
+            const kept = Array.isArray(slugs) ? slugs.filter((slug): slug is string => typeof slug === 'string' && slug !== '') : [];
+            return kept.length === 0 ? [] : [[provider, kept]];
+        })
+    );
+}
+
 /*
  * Only the fields we know today, so what an older build wrote (one global `selection`, the plan
  * toggle's `interactionMode`) falls away here instead of riding along in every later write. A
@@ -54,6 +70,7 @@ export function parseChatPreferences(raw: string | null): ChatPreferences {
             accountByMachine: { ...stored.accountByMachine },
             readingWidth: isChatReadingWidth(stored.readingWidth) ? stored.readingWidth : DEFAULT_READING_WIDTH,
             sendKey: isChatSendKey(stored.sendKey) ? stored.sendKey : DEFAULT_SEND_KEY,
+            favoriteModels: parseFavoriteModels(stored.favoriteModels),
             changedAt: typeof stored.changedAt === 'number' ? stored.changedAt : 0
         };
     } catch {
@@ -190,6 +207,24 @@ export function rememberChatAccount(scopeId: string, provider: AgentKind, accoun
     write(withAccount(useChatPreferences.getState(), scopeId, provider, account));
 }
 
+/* The starred models of one CLI; a slug only means something inside its own catalog. */
+export function favoriteModelsOf(favorites: ChatPreferences['favoriteModels'], provider: AgentKind): ReadonlySet<string> {
+    return new Set(favorites[provider] ?? []);
+}
+
+/* Stars a model that was not, and takes the star off one that was. A provider left without any drops out. */
+export function withFavoriteToggled(preferences: ChatPreferences, provider: AgentKind, slug: string): ChatPreferences {
+    const current = preferences.favoriteModels[provider] ?? [];
+    const next = current.includes(slug) ? current.filter((each) => each !== slug) : [...current, slug];
+    const { [provider]: _previous, ...others } = preferences.favoriteModels;
+    return { ...preferences, favoriteModels: next.length === 0 ? others : { ...others, [provider]: next } };
+}
+
+/* Leaves `changedAt` alone: a star orders a person's own pickers and is no pick a machine weighs. */
+export function toggleFavoriteModel(provider: AgentKind, slug: string): void {
+    store(withFavoriteToggled(useChatPreferences.getState(), provider, slug));
+}
+
 /* Back to the CLI's own default for this provider; the other providers keep what they had. */
 export function forgetChatSelection(provider: AgentKind): void {
     const current = useChatPreferences.getState();

package/src/chat/subagent-view.ts

@@ -1,5 +1,4 @@
 import i18next from 'i18next';
-import { useMemo } from 'react';
 import { create } from 'zustand';
 import type { ChatItem, ChatSubagentItem } from '@adecore/agent-contracts';
 import { useChatScope } from '../scope';
@@ -128,10 +127,10 @@ export function useOpenableSubagents(chatId: string): ChatSubagentItem[] {
     // The structure and not the items, so a delta growing a reply does not walk the thread again.
     const order = useChatRow(chatId, (row) => row?.order);
     const structure = useChatRow(chatId, (row) => row?.structure);
-    return useMemo(() => (structure === undefined ? [] : openableSubagents(order ?? NO_ITEMS, structure, refused)), [order, structure, refused]);
+    return structure === undefined ? [] : openableSubagents(order ?? NO_ITEMS, structure, refused);
 }
 
 export function useSubagentItem(chatId: string, toolUseId: string): ChatSubagentItem | null {
     const structure = useChatRow(chatId, (row) => row?.structure);
-    return useMemo(() => (structure === undefined ? null : subagentOf(structure, toolUseId)), [structure, toolUseId]);
+    return structure === undefined ? null : subagentOf(structure, toolUseId);
 }

package/src/chat/ui/AnsiOutput.tsx

@@ -1,10 +1,9 @@
-import { useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { parseAnsi } from '../logic/ansi';
 
 export function AnsiOutput({ text, limit, tailLines }: { text: string; limit?: number; tailLines?: number }) {
     const { t } = useTranslation('agent-chat');
-    const { tokens, omitted } = useMemo(() => parseAnsi(text, { limit, tailLines }), [text, limit, tailLines]);
+    const { tokens, omitted } = parseAnsi(text, { limit, tailLines });
     return (
         <>
             {tokens.map((token, index) => (

package/src/chat/ui/BookmarkSubmenu.tsx

@@ -1,4 +1,3 @@
-import { useMemo } from 'react';
 import clsx from 'clsx';
 import { useTranslation } from 'react-i18next';
 import { Bookmark, Pencil, X } from 'lucide-react';
@@ -8,6 +7,7 @@ import { useChatHost } from '../../host';
 import { useChatScope } from '../../scope';
 import { useChatRow } from '../../state/chats';
 import { Icon, Menu } from '@adecore/ui';
+import { useHostChatPlace } from '../../host-hooks';
 
 /* A chat's bookmarks in thread order, each a jump to its message with rename and remove; nothing without bookmarks. */
 export function BookmarkSubmenu({ chatId }: { chatId: string }) {
@@ -16,8 +16,8 @@ export function BookmarkSubmenu({ chatId }: { chatId: string }) {
     const bookmarks = useChatRow(chatId, (row) => row?.bookmarks);
     const order = useChatRow(chatId, (row) => row?.order);
     const host = useChatHost();
-    const place = host.useChatPlace(chatId);
-    const sorted = useMemo(() => bookmarksInThreadOrder(bookmarks ?? [], order ?? []), [bookmarks, order]);
+    const place = useHostChatPlace(chatId);
+    const sorted = bookmarksInThreadOrder(bookmarks ?? [], order ?? []);
     if (sorted.length === 0) {
         return null;
     }

package/src/chat/ui/ChatActivity.tsx

@@ -1,4 +1,4 @@
-import { useMemo, type ReactNode } from 'react';
+import { type ReactNode } from 'react';
 import clsx from 'clsx';
 import { useShallow } from 'zustand/shallow';
 import { useTranslation } from 'react-i18next';
@@ -16,6 +16,7 @@ import { useChatHost } from '../../host';
 import { useChatScope } from '../../scope';
 import { useChatActions } from '../actions';
 import { statusLookOf, type StatusWord } from '../../agents/status-look';
+import { useHostTask, useHostTasks } from '../../host-hooks';
 
 const NO_TASKS: readonly ChatBackgroundTask[] = [];
 
@@ -30,29 +31,21 @@ export function ChatActivity({ chatId }: { chatId: string }) {
     const order = useChatRow(chatId, (row) => row?.order) ?? NO_ITEMS;
     const before = useChatRow(chatId, (row) => row?.subagentsBefore) ?? NO_ITEMS;
     const structure = useChatRow(chatId, (row) => row?.structure);
-    const subagents = useMemo(() => (structure === undefined ? [] : flyoutSubagents([...before, ...order], structure)), [before, order, structure]);
+    const subagents = structure === undefined ? [] : flyoutSubagents([...before, ...order], structure);
     const { id, keyOf } = useChatScope();
-    const tasks = host.tasks.useTasks(id);
+    const tasks = useHostTasks(id);
     // The infos of these sub-agents' own chats, so the info of any other chat changing does not draw this again.
     const children = useChats(useShallow((s) => subagents.map((item) => (item.childId === undefined ? undefined : s.statusByKey[keyOf(item.childId)]?.info))));
-    const progress = useMemo(
-        () =>
-            progressOf(
-                subagents.map((item, index) => {
-                    const taskId = taskIdOf(item);
-                    return taskRowStateOf(item, taskId === null ? null : (tasks?.[taskId] ?? null), children[index]);
-                })
-            ),
-        [subagents, tasks, children]
-    );
-    const words = useMemo(
-        () =>
-            subagents.map((item) => {
-                const taskId = taskIdOf(item);
-                return statusWordOf(item, taskId === null ? null : (tasks?.[taskId] ?? null));
-            }),
-        [subagents, tasks]
+    const progress = progressOf(
+        subagents.map((item, index) => {
+            const taskId = taskIdOf(item);
+            return taskRowStateOf(item, taskId === null ? null : (tasks?.[taskId] ?? null), children[index]);
+        })
     );
+    const words = subagents.map((item) => {
+        const taskId = taskIdOf(item);
+        return statusWordOf(item, taskId === null ? null : (tasks?.[taskId] ?? null));
+    });
     const background = useChatRow(chatId, (row) => row?.info.background) ?? NO_TASKS;
     if (subagents.length === 0 && background.length === 0) {
         return null;
@@ -174,11 +167,10 @@ function SubagentRows({ chatId, items }: { chatId: string; items: readonly ChatS
 }
 
 function SubagentEntry({ chatId, item, now }: { chatId: string; item: ChatSubagentItem; now: number }) {
-    const host = useChatHost();
     const { t } = useTranslation('agent-chat');
     const { id, keyOf } = useChatScope();
     const refused = useSubagentSupport((s) => s.unsupported[id] === true);
-    const task = host.tasks.useTask(id, taskIdOf(item));
+    const task = useHostTask(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);

package/src/chat/ui/ChatReferenceChip.tsx

@@ -1,15 +1,14 @@
 import clsx from 'clsx';
 import { useTranslation } from 'react-i18next';
 import { MessageSquare, X } from 'lucide-react';
-import { useChatHost } from '../../host';
 import { CHIP_IN_MESSAGE, MENTION_TONE } from './chips';
 import { Icon, Tooltip } from '@adecore/ui';
+import { useHostReferableChats } from '../../host-hooks';
 
 /* A chat attached to a message, under the title it has now rather than the one it had when it was attached. */
 export function ChatReferenceChip({ chatId, onRemove }: { chatId: string; onRemove?: () => void }) {
-    const host = useChatHost();
     const { t } = useTranslation('agent-chat');
-    const chat = host.useReferableChats().find((candidate) => candidate.id === chatId);
+    const chat = useHostReferableChats().find((candidate) => candidate.id === chatId);
     const title = chat === undefined ? t('chatReference.gone') : chat.title || t('chatReference.untitled');
     return (
         <span className={clsx(MENTION_TONE, CHIP_IN_MESSAGE)}>