@adecore/agents-react 0.24.2 → 0.25.0

package/dist/providers/index.js

@@ -3,15 +3,9 @@ export { AccountDot } from '../agents/AccountDot.js';
 export { AgentIcon } from '../agents/AgentIcon.js';
 export { ModelOptionControl } from '../agents/ModelOptionControl.js';
 export { ProviderLogo } from '../agents/ProviderLogo.js';
-export { accountsOfKind, accountName, ACCOUNT_TONE_CLASSES, accountStatusLine, canContinueOn } from '../agents/accounts.js';
+export { accountsOfKind, ACCOUNT_TONE_CLASSES, accountStatusLine, canContinueOn } from '../agents/accounts.js';
 export { modelName, useModelName, shortModelName } from '../agents/model-name.js';
-export { optionValue, carryOptions } from '../agents/model-options.js';
-export { modelRequirementOf } from '../agents/model-requirement.js';
-export { AccountColors } from './AccountColors.js';
-export { AccountDetail } from './AccountDetail.js';
-export { AccountVariables } from './AccountVariables.js';
-export { AddAccountForm } from './AddAccountForm.js';
-export { CliDetail } from './CliDetail.js';
+export { carryOptions } from '../agents/model-options.js';
+export {} from '../agents/model-requirement.js';
 export { ProvidersPane } from './ProvidersPane.js';
-export { saveAccounts, saveAccount, removeAccount, createAccount, linkAccount } from './account-actions.js';
 export { CliMark, CliTile } from './parts.js';

package/dist/state/index.d.ts

@@ -1,4 +1,4 @@
-export { type ChatState, type ChatsById, type ChatStatuses, type ChatSink, prependPage, waitingRequestsOf, applyEvent, useChats, chatSink, useChatRow, useReportedModels, useCurrentItem, type ChatHistoryPage, type ChatPage } from './chats.js';
+export { type ChatState, type ChatsById, type ChatStatuses, type ChatSink, waitingRequestsOf, applyEvent, useChats, chatSink, useChatRow, type ChatHistoryPage, type ChatPage } from './chats.js';
 export { useProviderAccountsStore, useProviderAccounts, providerAccountsOf, knownAccounts, watchProviderAccounts, type ProviderAccountsRow } from './provider-accounts.js';
 export { useProvidersStore, useProviders, providersOf, providerSinkFor, type ProvidersRow } from './providers.js';
-export { type UsageMetric, USAGE_PREFERENCES_KEY, usagePreferencesKey, dayOf, windowFor, summaryPayload, reloadUsagePreferences, useUsageStore, useUsage, type UsagePeriod, type UsageView } from './usage.js';
+export { type UsageMetric, USAGE_PREFERENCES_KEY, dayOf, windowFor, reloadUsagePreferences, useUsageStore, type UsagePeriod, type UsageView } from './usage.js';

package/dist/state/index.js

@@ -1,5 +1,5 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
-export { prependPage, waitingRequestsOf, applyEvent, useChats, chatSink, useChatRow, useReportedModels, useCurrentItem } from './chats.js';
+export { waitingRequestsOf, applyEvent, useChats, chatSink, useChatRow } from './chats.js';
 export { useProviderAccountsStore, useProviderAccounts, providerAccountsOf, knownAccounts, watchProviderAccounts } from './provider-accounts.js';
 export { useProvidersStore, useProviders, providersOf, providerSinkFor } from './providers.js';
-export { USAGE_PREFERENCES_KEY, usagePreferencesKey, dayOf, windowFor, summaryPayload, reloadUsagePreferences, useUsageStore, useUsage } from './usage.js';
+export { USAGE_PREFERENCES_KEY, dayOf, windowFor, reloadUsagePreferences, useUsageStore } from './usage.js';

package/dist/state/usage.d.ts

@@ -7,7 +7,6 @@ export declare const USAGE_PERIODS: readonly {
     days: number;
 }[];
 export declare let USAGE_PREFERENCES_KEY: string;
-export declare function usagePreferencesKey(): string;
 interface Preferences {
     period: UsagePeriod;
     metric: UsageMetric;

package/dist/state/usage.js

@@ -14,9 +14,6 @@ export let USAGE_PREFERENCES_KEY = storageKey();
 onChatStorageConfiguration(() => {
     USAGE_PREFERENCES_KEY = storageKey();
 });
-export function usagePreferencesKey() {
-    return storageKey();
-}
 const DEFAULTS = { period: '7d', metric: 'cost', currency: 'USD' };
 function parsePreferences(raw) {
     try {

package/dist/theme.css

@@ -27,6 +27,9 @@
     --chart-4: #eda100;
     --chart-5: #e87ba4;
     --chart-6: #008300;
+    /* The two grounds of the map a page draws without tiles. */
+    --map-land: #f2f1ed;
+    --map-water: #d3dde5;
 }
 
 [data-theme="dark"] {
@@ -46,6 +49,8 @@
     --chart-4: #c98500;
     --chart-5: #d55181;
     --chart-6: #008300;
+    --map-land: #2c3135;
+    --map-water: #1a2026;
 }
 
 /* Output and diffs take the terminal's colors when the app loads `@adecore/terminal/terminal.css`,
@@ -56,6 +61,9 @@
     --chat-added: var(--term-ansi-green, var(--positive));
     --chat-removed: var(--term-ansi-red, var(--status-error));
     --chart-1: var(--accent);
+    /* The number of a place on a map and in its list: the ink on the ground, so it reads on either. */
+    --map-marker: var(--text);
+    --map-marker-text: var(--surface);
 }
 
 @theme inline {
@@ -73,6 +81,8 @@
     --color-chat-output: var(--chat-output);
     --color-chat-added: var(--chat-added);
     --color-chat-removed: var(--chat-removed);
+    --color-map-marker: var(--map-marker);
+    --color-map-marker-text: var(--map-marker-text);
 }
 
 @layer components {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents-react",
-  "version": "0.24.2",
+  "version": "0.25.0",
   "description": "React agent chat threads, composers, approvals, provider accounts and usage views.",
   "type": "module",
   "exports": {
@@ -67,11 +67,11 @@
     "test:visuals": "bun --config=integration.bunfig.toml --conditions=source test ./src/chat/visual-viewport.integration.test.ts"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.24.2",
-    "@adecore/editor": "0.24.2",
-    "@adecore/editor-react": "0.24.2",
-    "@adecore/intelligent-ui": "0.24.2",
-    "@adecore/merge": "0.24.2",
+    "@adecore/agent-contracts": "0.25.0",
+    "@adecore/editor": "0.25.0",
+    "@adecore/editor-react": "0.25.0",
+    "@adecore/intelligent-ui": "0.25.0",
+    "@adecore/merge": "0.25.0",
     "@codemirror/commands": "^6.11.1",
     "@codemirror/language": "^6.12.4",
     "@codemirror/state": "^6.7.6",
@@ -83,6 +83,7 @@
     "@tanstack/react-virtual": "^3.14.13",
     "clsx": "^2.1.1",
     "lucide-react": "^1.47.0",
+    "maplibre-gl": "^6.14.0",
     "mermaid": "^12.2.0",
     "react-markdown": "^10.1.0",
     "remark-breaks": "^4.0.0",
@@ -93,14 +94,14 @@
     "zustand": "^5.0.15"
   },
   "peerDependencies": {
-    "@adecore/ui": "^0.24.2",
+    "@adecore/ui": "^0.25.0",
     "i18next": "^26.4.2",
     "react": "^19.3.0",
     "react-dom": "^19.3.0",
     "react-i18next": "^17.0.15"
   },
   "devDependencies": {
-    "@adecore/ui": "0.24.2",
+    "@adecore/ui": "0.25.0",
     "@types/bun": "^1.4.2",
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",

package/src/chat/index.ts

@@ -1,18 +1,6 @@
 // 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 { transportActions, actionsOf, useChatActions } from './actions';
-export { backgroundCounts } from './activity';
-export {
-    isImageAttachment,
-    fileBadge,
-    formatBytes,
-    checkAttachmentLimits,
-    filesOf,
-    readAttachments,
-    readStoredAttachments,
-    uploadPreviewUrl,
-    uploadBytes
-} from './attachments';
 export { type ChatSendExtras, ChatClient } from './chat-client';
 export type { ProjectChat } from './chat-references';
 export { sendFromComposer, type ComposerSend } from './composer-send';
@@ -36,24 +24,17 @@ export {
 export { handbackReportOf } from './logic/handback';
 export { limitView, type LimitView } from './logic/limit';
 export type { TickKind, ScrubberTick } from './logic/scrubber';
-export { type TimedRow, cardRows, visualRows, withTimedRows, timedRowsOf, withThreadCards } from './logic/thread-cards';
+export { type TimedRow, withTimedRows, timedRowsOf } from './logic/thread-cards';
 export { EMPTY_TARGET, readTimelineTarget, type TimelineTarget } from './logic/timeline-target';
 export { type TimelineRow, summarizeGroup, deriveTimelineRows, type SubagentBranch, type BaseMoved } from './logic/timeline';
-export { toolSummary, fileChanges, unifiedChanges, approvalChanges, hasFileChanges, type FileChange } from './logic/tools';
+export { toolSummary, type FileChange } from './logic/tools';
 export {
     MENTION_DRAG_TYPE,
     LEGACY_MENTION_DRAG_TYPE,
-    MENTION_DRAG_TYPES,
     carriesMentions,
     droppedMentions,
     writeMentionDrag,
-    findMentionQuery,
-    findSkillQuery,
-    insertMention,
-    insertSkill,
-    presentMentions,
     chipText,
-    tokenizeChips,
     type MentionQuery,
     type ChipSegment
 } from './mentions';
@@ -66,7 +47,6 @@ export {
     useChatPreferences,
     readChatPreferences,
     CHAT_PREFERENCES_KEY,
-    chatPreferencesKey,
     reloadChatPreferences,
     rememberChatPreferences,
     rememberReadingWidth,
@@ -93,6 +73,5 @@ export {
     type SubagentStep,
     type SubagentTrail
 } from './subagent-view';
-export { THUMBNAIL_PX, useUploadThumbnail } from './thumbnails';
 export { stepTimelineMessage, jumpToTimelineItem, type TurnTarget, registerTurnJumper, jumpToTimelineTurn, type ItemJumpOptions } from './timeline-scroll';
 export { type StatusWord, statusLookOf, taskStatusWord, type StatusLook, type TaskState } from '../agents/status-look';

package/src/chat/logic/continue-after-stop.ts

@@ -0,0 +1,32 @@
+import { abortedByEnd, abortedByMachine, type ChatInfo, type ChatItem } from '@adecore/agent-contracts';
+
+/* English like the other prompts the CLI gets, and it reaches the thread as the person's own message, which it is. */
+export const CONTINUE_PROMPT = 'Continue.';
+
+/*
+ * The turn a person stopped last, when nothing has happened since and Continue can pick it up; null otherwise.
+ * A paused queue, a limit and a paused goal have their own way out, a turn the machine ended has its own resume,
+ * and a request that waits on a person comes first.
+ */
+export function continuableTurn(info: ChatInfo, items: readonly ChatItem[]): string | null {
+    if (
+        info.activeTurnId !== null ||
+        info.status === 'needs-you' ||
+        (info.queue ?? []).length > 0 ||
+        info.limit !== undefined ||
+        info.goal?.status === 'paused'
+    ) {
+        return null;
+    }
+    const index = items.findLastIndex((item) => item.kind === 'turn');
+    const turn = items[index];
+    if (turn?.kind !== 'turn' || turn.state !== 'aborted' || turn.limit !== undefined || abortedByMachine(turn, items) || abortedByEnd(turn, items)) {
+        return null;
+    }
+    // A message of this turn sits after the turn item too, so only one sent after the turn ended counts.
+    const endedAt = turn.endedAt ?? turn.createdAt;
+    if (items.slice(index + 1).some((item) => item.kind === 'user' && item.createdAt > endedAt)) {
+        return null;
+    }
+    return turn.id;
+}

package/src/chat/logic/thread-cards.ts

@@ -92,8 +92,3 @@ export function withTimedRows(rows: TimelineRow[], timed: readonly TimedRow[]):
 export function timedRowsOf(cards: readonly ThreadCard[], visuals: readonly ChatVisual[] | null, heldFrom: number | null = null): TimedRow[] {
     return [...(visuals === null ? [] : visualRows(visuals, heldFrom)), ...cardRows(cards)];
 }
-
-/* The thread's rows with an app's cards among them, the way `withTimedRows` places them. */
-export function withThreadCards(rows: TimelineRow[], cards: readonly ThreadCard[]): TimelineRow[] {
-    return withTimedRows(rows, cardRows(cards));
-}

package/src/chat/preferences.ts

@@ -143,10 +143,6 @@ onChatStorageConfiguration(() => {
     CHAT_PREFERENCES_KEY = storageKey();
 });
 
-export function chatPreferencesKey(): string {
-    return storageKey();
-}
-
 /* Reads the remembered default again, once another window of the same origin wrote it. */
 export function reloadChatPreferences(): void {
     useChatPreferences.setState(storage.read(), true);

package/src/chat/stash.ts

@@ -26,6 +26,8 @@ export interface StashedPrompt {
     text: string;
     mentions: string[];
     skills: string[];
+    /* Chats of the project picked with `@`; an entry from before this field has none. */
+    chats: 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;
@@ -83,6 +85,7 @@ export function parseStash(raw: string | null): StashedPrompt[] {
                 text: entry.text as string,
                 mentions: strings(entry.mentions),
                 skills: strings(entry.skills),
+                chats: strings(entry.chats),
                 attachments: attachments(entry.attachments),
                 ...stashedQuoteField(entry.quote),
                 createdAt: typeof entry.createdAt === 'number' ? entry.createdAt : 0
@@ -113,11 +116,25 @@ export function stashedFrom(draft: ChatDraft, id: string, now: number, chatId: s
         ...(kept ? { quote: { text: draft.quote, chatId, itemId: draft.quoteSource! } } : {}),
         mentions: [...draft.mentions],
         skills: [...draft.skills],
+        chats: [...draft.chats],
         attachments: draft.attachments.map((attachment) => ({ name: attachment.name, mime: attachment.mime, size: uploadBytes(attachment) })),
         createdAt: now
     };
 }
 
+/* The limit of `chats` in a send. */
+export const STASH_CHATS_LIMIT = 16;
+
+/*
+ * The attached chats a composer may take back: the ones it can still reference, never its own chat, in the
+ * order they were picked. `dropped` counts the chats left out because the project no longer has them.
+ */
+export function restorableChats(stashed: readonly string[], referable: ReadonlySet<string>, chatId: string): { chats: string[]; dropped: number } {
+    const others = stashed.filter((id) => id !== chatId);
+    const chats = others.filter((id) => referable.has(id));
+    return { chats: chats.slice(0, STASH_CHATS_LIMIT), dropped: others.length - chats.length };
+}
+
 const storage = persistedJson<StashedPrompt[]>(storageKey, parseStash, [], () => chatStorageLegacyKeys('stash'));
 
 /* Prompts put aside for later can move to another chat, so the shelf is shared across chats. */

package/src/chat/ui/Composer.tsx

@@ -36,6 +36,7 @@ import { useComposerDraft } from './composer/use-composer-draft';
 import { useComposerMenus } from './composer/use-composer-menus';
 import { useComposerSubmit } from './composer/use-composer-submit';
 import { LEAVE_DROPS_TO_THE_CARD, useDraftFiles } from './composer/use-draft-files';
+import { useContinuableTurn } from './composer/use-continuable-turn';
 import { useNotice } from './composer/use-notice';
 import { usePendingRequests } from './composer/use-pending-requests';
 import { usePromptHistory } from './composer/use-prompt-history';
@@ -96,7 +97,11 @@ export function Composer({ chatId, info, focused, answerPromptsElsewhere, disabl
     const files = useDraftFiles({ capabilities, providerName: provider?.name, writable, draft: box, inputRef, setNotice: notice.setNotice });
     const controls = useChatControls({ chatId, info, notice, onRetarget });
     const guard = promptGuard(withQuote(draft.quote, draft.text));
-    const { submit, restoreStashed, toggleStash } = useComposerSubmit({
+    const continuable = useContinuableTurn(chatId, info);
+    // The stopped turn something went out for, since the chat takes a moment to answer and Continue must not stand there meanwhile.
+    const [sentFor, setSentFor] = useState<string | null>(null);
+    const extraPrompts = host.prompts.useExtra(scope.id, chatId);
+    const { submit, continueTurn, restoreStashed, toggleStash } = useComposerSubmit({
         chatId,
         writable,
         guard,
@@ -109,7 +114,23 @@ export function Composer({ chatId, info, focused, answerPromptsElsewhere, disabl
         hold,
         inputRef,
         setNotice: notice.setNotice,
-        onSend
+        onSend: (text, extras) => {
+            setSentFor(continuable);
+            const sent = onSend(text, extras);
+            // A send the host did not take leaves Continue where it was; the original promise still reaches its caller.
+            void Promise.resolve(sent).then(
+                (taken) => {
+                    if (taken === false) {
+                        setSentFor(null);
+                    }
+                },
+                (error: unknown) => {
+                    setSentFor(null);
+                    throw error;
+                }
+            );
+            return sent;
+        }
     });
     const { takingBack, takeBack } = useTakeBack({
         chatId,
@@ -231,7 +252,7 @@ export function Composer({ chatId, info, focused, answerPromptsElsewhere, disabl
                                 quote={draft.quote}
                                 source={draft.quoteSource}
                                 onRemove={box.removeQuote}
-                                onSourceGone={() => notice.setNotice(t('rows.user.quoteGone'))}
+                                onSourceGone={() => notice.setNotice(t('rows.user.quoteGone'), 'info')}
                             />
                         )}
                         {draft.chats.length > 0 && <DraftChats chats={draft.chats} onRemove={box.removeChat} />}
@@ -263,7 +284,10 @@ export function Composer({ chatId, info, focused, answerPromptsElsewhere, disabl
                             onPaste={files.onPaste}
                         />
                         {notice.notice && (
-                            <div className="px-5 pb-1 text-xs text-status-error @max-md/composer:px-3.5" role="alert">
+                            <div
+                                className={clsx('px-5 pb-1 text-xs @max-md/composer:px-3.5', notice.tone === 'error' ? 'text-status-error' : 'text-text-muted')}
+                                role={notice.tone === 'error' ? 'alert' : 'status'}
+                            >
                                 {notice.notice}
                             </div>
                         )}
@@ -290,7 +314,11 @@ export function Composer({ chatId, info, focused, answerPromptsElsewhere, disabl
                                 disabled: empty || !writable || guard.tooLong,
                                 label: t(sendLabelKey(busy, steerable, sendDelivery)),
                                 kbd: sendShortcut(sendKey, draft.text.includes('\n')),
-                                onSend: (alternate) => submit(alternate ? 'alternate' : 'default')
+                                onSend: (alternate) => submit(alternate ? 'alternate' : 'default'),
+                                onContinue:
+                                    continuable !== null && continuable !== sentFor && empty && writable && pending.length === 0 && extraPrompts.length === 0
+                                        ? continueTurn
+                                        : null
                             }}
                             dictationToolbar={setDictationToolbar}
                             onFiles={(picked) => {

package/src/chat/ui/Pickers.tsx

@@ -273,6 +273,7 @@ export function StashPicker({ onRestore }: { onRestore(prompt: StashedPrompt): v
                                 {prompt.attachments.length > 0 && (
                                     <span className="text-text-faint">{t('pickers.stash.files', { count: prompt.attachments.length })}</span>
                                 )}
+                                {prompt.chats.length > 0 && <span className="text-text-faint">{t('pickers.stash.chats', { count: prompt.chats.length })}</span>}
                             </Popover.Close>
                             <IconButton
                                 icon={Trash2}

package/src/chat/ui/composer/ComposerControls.tsx

@@ -1,8 +1,8 @@
 import { useRef, type Ref } from 'react';
 import { useTranslation } from 'react-i18next';
-import { ArrowUp, Plus, Square } from 'lucide-react';
+import { ArrowUp, Play, Plus, Square } from 'lucide-react';
 import type { ChatInfo } from '@adecore/agent-contracts';
-import { ErrorBoundary, Icon, Tooltip, type Shortcut } from '@adecore/ui';
+import { Button, ErrorBoundary, Icon, Tooltip, type Shortcut } from '@adecore/ui';
 import { useChatHost } from '../../../host';
 import { useChatScope } from '../../../scope';
 import { useProviders } from '../../../state/providers';
@@ -20,6 +20,8 @@ interface SendProps {
     label: string;
     kbd: Shortcut;
     onSend(alternate: boolean): void;
+    /* Set when a person stopped the last turn and the box is empty: Continue stands where the send button would. */
+    onContinue: (() => void) | null;
 }
 
 interface ComposerControlsProps {
@@ -130,7 +132,15 @@ export function ComposerControls({
                         </button>
                     </Tooltip>
                 )}
-                {send.visible && (
+                {send.onContinue !== null && (
+                    <Tooltip label={t('composer.continueHint')}>
+                        <Button variant="primary" shape="pill" disabled={controls.configurationPending} onClick={send.onContinue}>
+                            <Icon icon={Play} size={14} />
+                            {t('composer.continue')}
+                        </Button>
+                    </Tooltip>
+                )}
+                {send.onContinue === null && send.visible && (
                     <Tooltip label={send.label} kbd={send.kbd} name>
                         <button
                             className="flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-accent text-accent-text hover:brightness-90 disabled:opacity-50 disabled:hover:brightness-100"

package/src/chat/ui/composer/use-composer-submit.ts

@@ -1,17 +1,20 @@
 import { useEffect, useRef, type RefObject } from 'react';
+import { useTranslation } from 'react-i18next';
 import { useChatHost } from '../../../host';
 import { useChatScope } from '../../../scope';
 import { checkAttachmentLimits, uploadBytes } from '../../attachments';
 import type { ChatSendExtras } from '../../chat-client';
 import { registerComposerSender, type ComposerSend } from '../../composer-send';
 import { isEmptyDraft } from '../../drafts';
+import { CONTINUE_PROMPT } from '../../logic/continue-after-stop';
 import type { PromptGuard } from '../../guards';
 import { presentMentions, presentSkills } from '../../mentions';
 import { withQuote } from '../../quote';
-import { stashDraft, useStash, type StashedPrompt } from '../../stash';
+import { restorableChats, stashDraft, useStash, type StashedPrompt } from '../../stash';
 import { scrollTimelineToEnd } from '../../timeline-scroll';
 import type { ComposerInputHandle } from '../ComposerInput';
 import type { ChatControls } from './use-chat-controls';
+import type { NoticeTone } from './use-notice';
 import type { ComposerDraft } from './use-composer-draft';
 import type { ComposerMenus } from './use-composer-menus';
 import type { PromptHistory } from './use-prompt-history';
@@ -31,7 +34,7 @@ interface SubmitInput {
     history: PromptHistory;
     hold: ComposerPromptHold;
     inputRef: RefObject<ComposerInputHandle | null>;
-    setNotice(notice: string): void;
+    setNotice(notice: string, tone?: NoticeTone): void;
     onSend(text: string, extras: ChatSendExtras): void | Promise<boolean>;
 }
 
@@ -51,9 +54,11 @@ export function useComposerSubmit({
     setNotice,
     onSend
 }: SubmitInput) {
+    const { t } = useTranslation('agent-chat');
     const host = useChatHost();
     const scope = useChatScope();
     const { draft, setDraft } = box;
+    const referable = host.useReferableChats();
 
     /* Opens the host's new chat once the host took the message; a host that answers nothing took it. */
     const afterSend = (sent: void | Promise<boolean>, andNew: boolean): void => {
@@ -127,23 +132,38 @@ export function useComposerSubmit({
     useEffect(() => registerComposerSender(scope.keyOf(chatId), (how) => submitRef.current(how)), [scope, chatId]);
 
     /*
-     * A stashed prompt comes back as text, mentions and skills; its files were never kept. Its quote
-     * keeps leading to its reply in the chat it came from, and is plain text in any other.
+     * A stashed prompt comes back as text, mentions, skills and the chats this project still has; its
+     * files were never kept. Its quote keeps leading to its reply in the chat it came from, and is plain
+     * text in any other.
      */
     const restoreStashed = (prompt: StashedPrompt): void => {
         const stashedQuote = prompt.quote;
         const here = stashedQuote !== undefined && stashedQuote.chatId === chatId;
+        const { chats, dropped } = restorableChats(prompt.chats, new Set(referable.map((chat) => chat.id)), chatId);
         setDraft((current) => ({
             ...current,
             text: stashedQuote === undefined || here ? prompt.text : withQuote(stashedQuote.text, prompt.text),
             mentions: [...prompt.mentions],
             skills: [...prompt.skills],
+            chats,
             ...(here ? { quote: stashedQuote.text, quoteSource: stashedQuote.itemId } : {})
         }));
+        if (dropped > 0) {
+            setNotice(t('composer.notice.stashChatsDropped', { count: dropped }), 'info');
+        }
         history.forget();
         inputRef.current?.focus();
     };
 
+    /* Sends the prompt that goes on after a stop through the same door as a typed one, so the host sees a person's message. */
+    const continueTurn = (): void => {
+        if (!writable) {
+            return;
+        }
+        scrollTimelineToEnd(chatId, 'instant');
+        afterSend(onSend(CONTINUE_PROMPT, {}), false);
+    };
+
     /* Cmd+S puts the draft away and clears the box; on an empty box the same key takes the last one back. */
     const toggleStash = (): void => {
         if (isEmptyDraft(draft)) {
@@ -159,5 +179,5 @@ export function useComposerSubmit({
         }
     };
 
-    return { submit, restoreStashed, toggleStash };
+    return { submit, continueTurn, restoreStashed, toggleStash };
 }

package/src/chat/ui/composer/use-continuable-turn.ts

@@ -0,0 +1,14 @@
+import { useMemo } from 'react';
+import type { ChatInfo, ChatItem } from '@adecore/agent-contracts';
+import { useChatRow } from '../../../state/chats';
+import { continuableTurn } from '../../logic/continue-after-stop';
+
+/* The turn a person stopped that Continue would pick up, or null when there is none. */
+export function useContinuableTurn(chatId: string, info: ChatInfo): string | null {
+    const order = useChatRow(chatId, (row) => row?.order);
+    const structure = useChatRow(chatId, (row) => row?.structure);
+    return useMemo(() => {
+        const items = (order ?? []).map((id) => structure?.[id]).filter((item): item is ChatItem => item !== undefined);
+        return continuableTurn(info, items);
+    }, [info, order, structure]);
+}

package/src/chat/ui/composer/use-notice.ts

@@ -1,27 +1,34 @@
-import { useEffect, useState } from 'react';
+import { useCallback, useEffect, useState } from 'react';
 
 const NOTICE_MS = 4000;
 
+/* An error is what went wrong; info is something the composer did that the person should know. */
+export type NoticeTone = 'error' | 'info';
+
 export interface ComposerNotice {
     notice: string | null;
-    setNotice(notice: string | null): void;
+    tone: NoticeTone;
+    setNotice(notice: string | null, tone?: NoticeTone): void;
     showError(error: unknown): void;
 }
 
 /* A line under the box that says what went wrong, gone again after a few seconds. */
 export function useNotice(): ComposerNotice {
-    const [notice, setNotice] = useState<string | null>(null);
+    const [shown, setShown] = useState<{ text: string; tone: NoticeTone } | null>(null);
 
     useEffect(() => {
-        if (!notice) {
+        if (!shown) {
             return;
         }
-        const timer = setTimeout(() => setNotice(null), NOTICE_MS);
+        const timer = setTimeout(() => setShown(null), NOTICE_MS);
         return () => clearTimeout(timer);
-    }, [notice]);
+    }, [shown]);
+
+    const setNotice = useCallback((notice: string | null, tone: NoticeTone = 'error'): void => setShown(notice ? { text: notice, tone } : null), []);
 
     return {
-        notice,
+        notice: shown?.text ?? null,
+        tone: shown?.tone ?? 'error',
         setNotice,
         showError: (error) => setNotice(error instanceof Error ? error.message : String(error))
     };