@jini-ai/chat 0.6.16 → 0.6.19

package/dist/react/features/chat-pane/components/AgentRuntimePicker.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { pickerModelValue, pickerCatalogNote, pickerModelOptions, shortModelLabel } from '../model-options.js';
+import { friendlyModelLabel, pickerModelValue, pickerCatalogNote, pickerModelOptions, shortModelLabel } from '../model-options.js';
 import { useId } from 'react';
 import { createPortal } from 'react-dom';
 import { AgentIcon, RemixIcon, SearchableModelSelect } from '@jini-ai/ui';
@@ -62,9 +62,11 @@ function RuntimeAgentRow({ agent, active, noteId, onChange, agentIconBasePath, t
 function RuntimeBarMenus({ selectedAgent, value, onChange, modelLabel, t }) {
     if (!selectedAgent)
         return null;
-    const models = pickerModelOptions(selectedAgent);
+    // Raw catalog ids (an offline fallback list's rows) read as friendly names in the bar and its list.
+    const models = pickerModelOptions(selectedAgent).map((row) => ({ ...row, label: friendlyModelLabel({ label: row.label }) }));
     const efforts = selectedAgent.reasoningOptions ?? [];
-    return (_jsxs(_Fragment, { children: [models.length > 0 ? (_jsx(RuntimeDropUp, { label: t('Model'), valueLabel: modelLabel, 
+    const modelName = friendlyModelLabel({ label: modelLabel });
+    return (_jsxs(_Fragment, { children: [models.length > 0 ? (_jsx(RuntimeDropUp, { label: t('Model'), valueLabel: modelName, 
                 // The agent icon sits right beside it, so the bar drops the vendor word and caps the rest.
                 triggerLabel: shortModelLabel({ label: modelLabel, agentId: selectedAgent.id }), value: pickerModelValue(selectedAgent, value.model), options: models, note: pickerCatalogNote(selectedAgent, t), width: 260, onSelect: (model) => onChange({
                     agentId: value.agentId,

package/dist/react/features/chat-pane/components/ChatPane.js

@@ -271,6 +271,7 @@ function useComposerHandlePublisher({ pane }, { composerHandle }) {
         if (!composerHandle)
             return undefined;
         composerHandle.current = {
+            addFolders: pane.composer.addFolders,
             insertText: (text) => {
                 pane.composer.setDraft(appendComposerDiscovery({ draft: composerDraftRef.current, insertText: text }));
             },

package/dist/react/features/chat-pane/create-mcp-ui-tool-caller.d.ts

@@ -34,7 +34,20 @@
  * single-use token minted into the dialog is what proves a human saw it. Adding a client-side
  * allow-list would suggest a protection that is not real.
  */
-import type { McpUiToolCallHandler } from '@jini-ai/ui/mcp-ui';
+import type { McpUiToolCall, McpUiToolCallHandler } from '@jini-ai/ui/mcp-ui';
+import type { SurfaceEmission } from '@jini-ai/core';
+import type { SurfaceRecoveryInfo } from '../../../core/surface-recovery.js';
+export interface SurfaceRecoveryCallbacks {
+    readonly onSurface: (emission: SurfaceEmission) => void;
+    readonly signal: AbortSignal;
+}
+/** Callable as before; lifecycle controllers can also restore without replaying browser input. */
+export type RecoverableMcpUiToolCaller = McpUiToolCallHandler & {
+    restore(required: SurfaceRecoveryInfo & SurfaceRecoveryCallbacks, options?: Record<string, never>): Promise<unknown>;
+    answer(required: {
+        call: McpUiToolCall;
+    } & SurfaceRecoveryCallbacks, options?: Record<string, never>): Promise<unknown>;
+};
 export interface CreateMcpUiToolCallerOptions {
     /**
      * Path appended to `baseUrl`. Defaults to `/api/mcp-ui/tool-calls`.
@@ -69,5 +82,5 @@ export interface McpUiToolCallRequest {
 export declare function createMcpUiToolCaller({ baseUrl, fetch }: {
     baseUrl: string;
     fetch: typeof globalThis.fetch;
-}, options?: CreateMcpUiToolCallerOptions): McpUiToolCallHandler;
+}, options?: CreateMcpUiToolCallerOptions): RecoverableMcpUiToolCaller;
 //# sourceMappingURL=create-mcp-ui-tool-caller.d.ts.map

package/dist/react/features/chat-pane/create-mcp-ui-tool-caller.js

@@ -1,3 +1,4 @@
+import { readSurfaceRecoveryStream } from './surface-recovery-stream.js';
 const DEFAULT_PATH = '/api/mcp-ui/tool-calls';
 const DEFAULT_TIMEOUT_MS = 30_000;
 function errorTextFrom(body, status) {
@@ -35,7 +36,7 @@ function timeoutAware(error, timeoutMs) {
         : error;
 }
 /** One POST of a confirmed action and its parsed answer; a non-2xx response rejects via {@link errorFrom}. */
-async function postToolCall({ call, endpoint, headers, signal, fetch }) {
+async function postToolCall({ call, endpoint, headers, signal, fetch, onSurface, exchangeId, restore }) {
     // `{name, arguments}` on the MCP-UI side becomes `{toolName, params}` on the wire: `arguments`
     // is a reserved word in a JS function scope and reads badly in a server handler, and the
     // renamed pair matches what the reference implementation's redemption route already accepts.
@@ -48,9 +49,12 @@ async function postToolCall({ call, endpoint, headers, signal, fetch }) {
         // Same-origin cookie session is the usual authenticator for the human's second step.
         credentials: 'same-origin',
         headers: { ...headers, 'content-type': 'application/json' },
-        body: JSON.stringify(request),
+        body: JSON.stringify({ ...request, ...(restore ? { exchangeId, restore } : {}) }),
         signal,
     });
+    if (response.ok && response.headers.get('content-type')?.includes('application/x-ndjson')) {
+        return readSurfaceRecoveryStream({ response, onSurface });
+    }
     const raw = await response.text();
     let parsed = raw;
     if (raw.length > 0) {
@@ -83,12 +87,24 @@ export function createMcpUiToolCaller({ baseUrl, fetch }, options = {}) {
     const path = options.path ?? DEFAULT_PATH;
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const endpoint = `${baseUrl.replace(/\/$/u, '')}${path}`;
-    return async (call) => {
+    const answer = async (call) => {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeoutMs);
         return postToolCall({ call, endpoint, headers: options.headers, signal: controller.signal, fetch })
             .catch((error) => { throw timeoutAware(error, timeoutMs); })
             .finally(() => clearTimeout(timer));
     };
+    return Object.assign(answer, {
+        // Recovery streams deliberately have no reading-time deadline. The controller cancels on
+        // unmount; the server's executing-call lease handles run cancellation independently.
+        restore: (required) => postToolCall({
+            call: { name: required.toolId, arguments: {} }, endpoint, headers: options.headers, fetch,
+            signal: required.signal, onSurface: required.onSurface, exchangeId: required.exchangeId, restore: true,
+        }),
+        answer: (required) => postToolCall({
+            call: required.call, endpoint, headers: options.headers, fetch,
+            signal: required.signal, onSurface: required.onSurface,
+        }),
+    });
 }
 //# sourceMappingURL=create-mcp-ui-tool-caller.js.map

package/dist/react/features/chat-pane/hooks/useChatPane.hooks.js

@@ -50,12 +50,12 @@ const ATTACHMENTS_ONLY_PROMPT = 'Review the attached file(s).';
  */
 function composerPrompt(composer) {
     return composer.draft.trim()
-        || (composer.attachments.length > 0 ? ATTACHMENTS_ONLY_PROMPT : '');
+        || (composer.attachments.length > 0 || composer.folders?.length ? ATTACHMENTS_ONLY_PROMPT : '');
 }
 /** History hydration can replace a controller without an edit. Compare the accepted empty draft
  * and staged files so holding Enter cannot requeue an attachment-only submission on that render. */
 function isRepeatedComposerSubmission({ composer, submitted }, _options = {}) {
-    return submitted === composer || (submitted !== null && composer.draft.trim() === '' && submitted.attachments === composer.attachments);
+    return submitted === composer || (submitted !== null && composer.draft.trim() === '' && submitted.attachments === composer.attachments && submitted.folders === composer.folders);
 }
 function composerDeliveryBlocked({ delivering, starting, composer, submitted }, _options = {}) {
     return delivering || starting || isRepeatedComposerSubmission({ composer, submitted });
@@ -262,6 +262,20 @@ export function useChatPane(options) {
         queued, next: { text: input.text, secretRedacted: input.secretRedaction?.secretRedacted ?? false,
             count: input.secretRedaction?.count ?? 0 },
     }), null), [queuedInputs]);
+    const releaseStateRef = useRef({ streaming: conversation.isStreaming, queued: queuedInputs.length > 0 });
+    releaseStateRef.current = { streaming: conversation.isStreaming, queued: queuedInputs.length > 0 };
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const onReleaseCheck = (event) => {
+            const { streaming, queued } = releaseStateRef.current;
+            // Read mutable operation locks at dispatch time, including the gap before React renders.
+            if (streaming || queued || activeUploadsRef.current.size > 0 || startingPromptRef.current || deliveringTypedAnswerRef.current)
+                event.preventDefault();
+        };
+        window.addEventListener('jini:release-check', onReleaseCheck);
+        return () => window.removeEventListener('jini:release-check', onReleaseCheck);
+    }, []);
     // Release consumed text/files locally as well as hiding them; next-turn fallback uses this same projection.
     useEffect(() => {
         if (queuedInputs.length !== storedQueuedInputs.length)
@@ -331,6 +345,8 @@ export function useChatPane(options) {
     latestComposerRef.current = composer;
     const latestDraftRef = useRef(composer.draft);
     latestDraftRef.current = composer.draft;
+    const latestFoldersRef = useRef(composer.folders ?? []);
+    latestFoldersRef.current = composer.folders ?? [];
     const latestAttachmentsRef = useRef(composer.attachments);
     latestAttachmentsRef.current = composer.attachments;
     useEffect(() => {
@@ -440,6 +456,7 @@ export function useChatPane(options) {
     const restoreQueuedDraft = useCallback(({ inputs, text, attachments }, _options = {}) => {
         if (inputs === undefined)
             return;
+        latestComposerRef.current.addFolders({ folders: inputs.flatMap(input => input.folders ?? []) });
         latestComposerRef.current.setDraft([text, latestDraftRef.current].filter(Boolean).join('\n\n'));
         const staged = new Set(latestAttachmentsRef.current.map(attachment => attachment.path));
         for (const attachment of attachments) {
@@ -449,20 +466,21 @@ export function useChatPane(options) {
     }, []);
     /** A refused composer send is kept for Retry and goes back only into a composer that is still
      * empty: text typed (or files staged) while it was sending are never overwritten. */
-    const restoreRefusedDraft = useCallback(({ redaction, draft, attachments }, _options = {}) => {
-        refusedSendRef.current = { redaction, draft, attachments };
+    const restoreRefusedDraft = useCallback(({ redaction, draft, attachments, folders = [] }, _options = {}) => {
+        refusedSendRef.current = { redaction, draft, attachments, folders };
+        latestComposerRef.current.addFolders({ folders });
         if (latestDraftRef.current.trim() !== '' || latestAttachmentsRef.current.length > 0)
             return;
         latestComposerRef.current.setDraft(draft);
         for (const attachment of attachments)
             latestComposerRef.current.addAttachment(attachment);
     }, []);
-    const finishPromptSend = useCallback(({ accepted, inputs, redaction, submittedDraft, attachments, composerDraft }, _options = {}) => {
+    const finishPromptSend = useCallback(({ accepted, inputs, redaction, submittedDraft, attachments, composerDraft, folders }, _options = {}) => {
         if (!accepted) {
             if (composerDraft === undefined)
                 restoreQueuedDraft({ inputs, text: redaction.text, attachments });
             else
-                restoreRefusedDraft({ redaction, draft: composerDraft, attachments });
+                restoreRefusedDraft({ redaction, draft: composerDraft, attachments, folders });
             return;
         }
         refusedSendRef.current = null;
@@ -471,11 +489,17 @@ export function useChatPane(options) {
             latestComposerRef.current.setDraft('');
             latestComposerRef.current.closeMention();
         }
+        // Composer/queued sends already took these references. A later pick, even of the same path,
+        // belongs to the next draft and must survive this send's asynchronous acceptance.
+        if (composerDraft === undefined && inputs === undefined) {
+            for (const path of folders)
+                latestComposerRef.current.removeFolder({ path });
+        }
         consumeDeliveredAttachments({ attachments });
     }, [consumeDeliveredAttachments, restoreQueuedDraft, restoreRefusedDraft]);
     /** `composerDraft`: the composer text this send already took out of the composer, so the
      * composer is never cleared again on acceptance and a refusal hands the text back. */
-    const sendGuardedPrompt = useCallback(async ({ redaction, inputs, attachments = composer.attachments, composerDraft }, _options = {}) => {
+    const sendGuardedPrompt = useCallback(async ({ redaction, inputs, attachments = composer.attachments, composerDraft, folders = inputs ? inputs.flatMap(input => input.folders ?? []) : composer.folders ?? [] }, _options = {}) => {
         const trimmed = redaction.text.trim();
         assertPromptSendable({ trimmed, sendBlocker });
         if (startingPromptRef.current)
@@ -494,6 +518,7 @@ export function useChatPane(options) {
                     // Empty attachment arrays remain absent at the transport boundary.
                     attachments: attachments.length === 0 ? undefined : attachments,
                     context,
+                    folders: folders.length ? folders : undefined,
                     acceptedInputs: inputs,
                     onAccepted: ({ inputs: acceptedInputs }) => {
                         accepted = true;
@@ -503,7 +528,7 @@ export function useChatPane(options) {
                 } }));
             if (!mountedRef.current || generation !== typedAnswerGenerationRef.current)
                 return;
-            finishPromptSend({ accepted, inputs, redaction, submittedDraft, attachments, composerDraft });
+            finishPromptSend({ accepted, inputs, redaction, submittedDraft, attachments, composerDraft, folders });
         }
         finally {
             startingPromptRef.current = false;
@@ -520,24 +545,27 @@ export function useChatPane(options) {
             return;
         const draft = latestDraftRef.current;
         const attachments = latestAttachmentsRef.current;
+        const folders = latestFoldersRef.current;
+        for (const path of folders)
+            latestComposerRef.current.removeFolder({ path });
         latestComposerRef.current.setDraft('');
         latestComposerRef.current.closeMention();
         for (const attachment of attachments)
             latestComposerRef.current.removeAttachment(attachment.path);
         const redaction = guard.redact({ text: prompt.trim() }, {});
         try {
-            await sendGuardedPrompt({ redaction, attachments, composerDraft: draft });
+            await sendGuardedPrompt({ redaction, attachments, folders, composerDraft: draft });
         }
         catch (error) {
             // A host hook that throws (run context, activity) must not cost the typed text either.
-            restoreRefusedDraft({ redaction, draft, attachments });
+            restoreRefusedDraft({ redaction, draft, attachments, folders });
             throw error;
         }
     }, [guard.redact, restoreRefusedDraft, sendBlocker, sendGuardedPrompt]);
     // MOVE: Every queue path retains per-message receipts; appendQueuedTurn owns their one-turn delivery.
     // A turn queued against another conversation is not joined — it would never be flushed there anyway.
     const enqueueTurn = useCallback(({ turn, inputs, attachments = composer.attachments }, _options = {}) => {
-        const accepted = inputs ?? [{ id: createChatLocalId({}), text: turn.text, attachments,
+        const accepted = inputs ?? [{ id: createChatLocalId({}), text: turn.text, attachments, folders: composer.folders ?? [],
                 ...(turn.secretRedacted ? { secretRedaction: { secretRedacted: true, count: turn.count } } : {}) }];
         const sameConversation = queuedConversationIdRef.current === options.conversationId;
         queuedConversationIdRef.current = options.conversationId;
@@ -550,7 +578,9 @@ export function useChatPane(options) {
         // MOVE: Take files out of the composer without rotating their batch: every queued message ships together.
         for (const attachment of attachments)
             latestComposerRef.current.removeAttachment(attachment.path);
-    }, [composer.attachments, options.conversationId, recordAcceptedInput]);
+        for (const path of composer.folders ?? [])
+            latestComposerRef.current.removeFolder({ path });
+    }, [composer.folders, composer.attachments, options.conversationId, recordAcceptedInput]);
     const answerWaitingQuestion = useCallback(async ({ deliver, questionId, text }) => {
         const safeText = guard.redactText(text);
         const generation = typedAnswerGenerationRef.current;
@@ -647,7 +677,8 @@ export function useChatPane(options) {
             queuedForLiveDeliveryRef.current = queuedTurn === null || queuedForLiveDeliveryRef.current;
         }
         // MOVE: The existing queue owns its files; a later steer must join it to preserve send order.
-        const target = uploadPending || queuedInputs.some(input => input.liveMessageId === undefined) ? null : findMidRunTarget({
+        // Folder context is attached on ordinary run start; live messages have no such envelope.
+        const target = uploadPending || composer.folders?.length || queuedInputs.some(input => input.liveMessageId === undefined) ? null : findMidRunTarget({
             deliver: options.deliverMidRunMessage,
             blocker: sendBlocker,
             attachmentCount: composer.attachments.length,
@@ -686,7 +717,7 @@ export function useChatPane(options) {
             await sendOrdinaryTurn(prompt);
             return;
         }
-        const typedAnswer = findTypedAnswerTarget({
+        const typedAnswer = composer.folders?.length ? null : findTypedAnswerTarget({
             deliver: options.deliverTypedAnswer,
             blocker: sendBlocker,
             attachmentCount: composer.attachments.length,
@@ -715,7 +746,7 @@ export function useChatPane(options) {
         }
         if (sendBlocker !== null || startingPromptRef.current)
             return;
-        await sendGuardedPrompt({ redaction: refused.redaction, attachments: refused.attachments, composerDraft: refused.draft });
+        await sendGuardedPrompt({ redaction: refused.redaction, attachments: refused.attachments, composerDraft: refused.draft, folders: refused.folders });
     }, [send, sendBlocker, sendGuardedPrompt]);
     const sendAsNewMessage = useCallback(async () => {
         const prompt = composerPrompt(composer);
@@ -773,7 +804,7 @@ export function useChatPane(options) {
         }
         if (activeUploadCount > 0 || attachmentError !== null)
             return;
-        const target = queuedForLiveDeliveryRef.current ? findMidRunTarget({
+        const target = queuedForLiveDeliveryRef.current && !queuedInputs.some(input => input.folders?.length) ? findMidRunTarget({
             deliver: options.deliverMidRunMessage,
             blocker: sendBlocker, attachmentCount: queuedInputs.flatMap(input => input.attachments).length, messages: conversation.messages,
         }) : null;

package/dist/react/features/chat-pane/hooks/useChatPaneFileDrop.hooks.js

@@ -1,3 +1,4 @@
+import { formatErrorForLog } from '@jini-ai/core';
 import { useCallback, } from 'react';
 import { useFileDropTarget } from '@jini-ai/ui';
 function carriesFiles(event) {
@@ -12,11 +13,11 @@ function runOnFilesHostEffect(onFiles, files) {
         result = onFiles(files);
     }
     catch (error) {
-        console.error('[@jini-ai/chat] useChatPaneFileDrop onFiles host effect failed:', error);
+        console.error('[@jini-ai/chat] useChatPaneFileDrop onFiles host effect failed:', formatErrorForLog({ error }));
         return;
     }
     void Promise.resolve(result).catch((error) => {
-        console.error('[@jini-ai/chat] useChatPaneFileDrop onFiles host effect failed:', error);
+        console.error('[@jini-ai/chat] useChatPaneFileDrop onFiles host effect failed:', formatErrorForLog({ error }));
     });
 }
 /**

package/dist/react/features/chat-pane/hooks/useRuntimeDropUp.hooks.js

@@ -100,13 +100,30 @@ export function useRuntimeDropUp({ width }) {
         const checked = menu?.querySelector(`${MENU_ITEMS}[aria-checked="true"]`);
         (checked ?? menu?.querySelector(MENU_ITEMS))?.focus();
     }, [open, position]);
+    // Escape is also handled here, on the menu and the trigger themselves: the document listener
+    // above never hears a keydown that something between them and the document stopped (demo
+    // practice run, 2026-11-02: Escape left the model picker open). preventDefault marks it consumed,
+    // so a host's own Escape (the admin dock closing) leaves this press to the menu.
+    const closeOnOwnEscape = useCallback((event) => {
+        if (event.key !== 'Escape')
+            return false;
+        event.preventDefault();
+        closeToTrigger();
+        return true;
+    }, [closeToTrigger]);
     const handleTriggerKeyDown = useCallback((event) => {
-        if (open || (event.key !== 'ArrowUp' && event.key !== 'ArrowDown'))
+        if (open) {
+            closeOnOwnEscape(event);
+            return;
+        }
+        if (event.key !== 'ArrowUp' && event.key !== 'ArrowDown')
             return;
         event.preventDefault();
         setOpen(true);
-    }, [open]);
+    }, [closeOnOwnEscape, open]);
     const handleMenuKeyDown = useCallback((event) => {
+        if (closeOnOwnEscape(event))
+            return;
         if (event.key === 'Tab') {
             setOpen(false);
             return;
@@ -123,7 +140,7 @@ export function useRuntimeDropUp({ width }) {
             return;
         event.preventDefault();
         items[next]?.focus();
-    }, []);
+    }, [closeOnOwnEscape]);
     const choose = useCallback((apply) => {
         apply();
         closeToTrigger();

package/dist/react/features/chat-pane/model-options.d.ts

@@ -12,6 +12,16 @@ export declare function configuredPickerModel(agent: ChatPaneAgent): string | un
 export declare function pickerModelLabel(agent: ChatPaneAgent | undefined, requested?: string, t?: I18nAdapter['t']): string;
 export declare function pickerModelValue(agent: ChatPaneAgent, requested?: string): string;
 export declare function pickerCatalogNote(agent: ChatPaneAgent, t?: I18nAdapter['t']): string | undefined;
+/**
+ * A catalog row's display name: a bare raw id ("claude-opus-5-5", which offline fallback lists carry)
+ * reads as "Claude Opus 5.5"; a human label is kept as written. Still exact: a date or context suffix
+ * stays, and a routed id ("anthropic/…") is left whole, since its prefix names a different model.
+ * @example friendlyModelLabel({ label: 'claude-haiku-4-5-20251001' }) // "Claude Haiku 4.5 20251001"
+ * @complexity O(n) in the label length. Pure.
+ */
+export declare function friendlyModelLabel({ label }: {
+    label: string;
+}, _options?: Record<string, never>): string;
 /**
  * The composer bar's compact model name: the catalog label (or a prettified raw id when the catalog
  * has no label), minus the leading vendor word the agent's icon already conveys, capped with "…".

package/dist/react/features/chat-pane/model-options.js

@@ -35,6 +35,10 @@ export function pickerCatalogNote(agent, t = passthrough) {
     const catalog = agent.modelCatalog;
     if (catalog?.freshness === 'stale')
         return `${t('Cached')} · ${catalog.fetchedAt}`;
+    // While the host is still probing, the live list has not failed yet: the rows are the
+    // cached/fallback list the inventory contract says to show meanwhile, not an offline verdict.
+    if (agent.discoveryPending)
+        return undefined;
     if (catalog?.freshness === 'offline-fallback' || !catalog && agent.models)
         return t('Offline fallback');
     return undefined;
@@ -49,21 +53,36 @@ const BAR_VENDOR_WORDS = {
 // A bare catalog id ("claude-opus-5-5", "gpt-6-astra[1m]", "anthropic/claude-sonnet-5") rather than a display name.
 const RAW_MODEL_ID = /^(?:[a-z0-9._-]+\/)*[a-z0-9][a-z0-9._-]*(?:\[[^\]]*\])?$/;
 const BRAND_CASING = { gpt: 'GPT' };
-function prettifyRawModelId(id) {
+function prettifyRawModelId(id, { keepDates = false } = {}) {
     // A routing prefix ("anthropic/") is the full name's job; the bar names only the model.
     // The caller proved RAW_MODEL_ID, so the first '[' can only start its trailing context suffix.
-    const tokens = id.slice(id.lastIndexOf('/') + 1).split('[', 1)[0].split(/[-_]+/).filter((token) => token && !/^\d{8}$/.test(token));
+    const tokens = id.slice(id.lastIndexOf('/') + 1).split('[', 1)[0].split(/[-_]+/).filter((token) => token && (keepDates || !/^\d{8}$/.test(token)));
     const words = [];
     for (const token of tokens) {
         const previous = words[words.length - 1];
         // Dash-separated version digits read as one dotted version: "5-5" → "5.5".
-        if (/^\d+$/.test(token) && previous && /^\d+(?:\.\d+)*$/.test(previous))
+        // A kept 8-digit date stays its own word, never a version part.
+        if (/^\d{1,7}$/.test(token) && previous && /^\d+(?:\.\d+)*$/.test(previous))
             words[words.length - 1] = `${previous}.${token}`;
         else
             words.push(BRAND_CASING[token] ?? token.charAt(0).toUpperCase() + token.slice(1));
     }
     return words;
 }
+/**
+ * A catalog row's display name: a bare raw id ("claude-opus-5-5", which offline fallback lists carry)
+ * reads as "Claude Opus 5.5"; a human label is kept as written. Still exact: a date or context suffix
+ * stays, and a routed id ("anthropic/…") is left whole, since its prefix names a different model.
+ * @example friendlyModelLabel({ label: 'claude-haiku-4-5-20251001' }) // "Claude Haiku 4.5 20251001"
+ * @complexity O(n) in the label length. Pure.
+ */
+export function friendlyModelLabel({ label }, _options = {}) {
+    if (!RAW_MODEL_ID.test(label) || label.includes('/'))
+        return label;
+    const suffix = label.indexOf('[');
+    const words = prettifyRawModelId(label, { keepDates: true }).join(' ');
+    return suffix === -1 ? words : `${words} ${label.slice(suffix)}`;
+}
 /**
  * The composer bar's compact model name: the catalog label (or a prettified raw id when the catalog
  * has no label), minus the leading vendor word the agent's icon already conveys, capped with "…".