@jini-ai/chat 0.6.16 → 0.6.19

package/dist/react/hooks/composer-draft-cache.js

@@ -59,6 +59,8 @@ export const COMPOSER_DRAFT_STORAGE_PREFIX = 'jini.chat.composer-draft.v1.';
  * so a corrupt or unwritable attachment entry can never cost the operator their words, and vice
  * versa. See {@link readCachedAttachments} for what these references are and are not.
  */
+const COMPOSER_FOLDERS_STORAGE_PREFIX = 'jini.chat.composer-folders.v1.';
+const folderDrafts = new Map();
 export const COMPOSER_ATTACHMENTS_STORAGE_PREFIX = 'jini.chat.composer-attachments.v1.';
 const drafts = new Map();
 const stagedAttachments = new Map();
@@ -214,31 +216,33 @@ function storedTimestamp(store, { key }) {
 function writeStoredEnvelope(prefix, { conversationId, envelope }) {
     const store = storage();
     if (!store)
-        return;
+        return false;
     const key = `${prefix}${conversationId}`;
     try {
         if (envelope === null) {
             store.removeItem(key);
-            return;
+            return true;
         }
         if (store.getItem(key) === null)
             pruneStored(prefix, MAX_CACHED_CONVERSATION_DRAFTS - 1);
         store.setItem(key, JSON.stringify(envelope));
+        return true;
     }
     catch {
         /* blocked, full, or unusable storage — memory-only is the documented degraded mode */
         /* (on a removal: blocked storage; the in-memory tier is already correct) */
+        return false;
     }
 }
 /**
- * Writes or removes the stored copy for `conversationId`.
+ * Writes or removes the stored copy for `conversationId`; returns false on storage failure.
  *
  * @param draft A blank draft removes the entry; see {@link writeStoredEnvelope}.
  * @complexity Time O(n) in the draft's length; see {@link writeStoredEnvelope}.
  */
 function writeStoredDraft(conversationId, draft) {
     const envelope = draft === '' ? null : { v: 1, t: Date.now(), d: draft };
-    writeStoredEnvelope(COMPOSER_DRAFT_STORAGE_PREFIX, { conversationId, envelope });
+    return writeStoredEnvelope(COMPOSER_DRAFT_STORAGE_PREFIX, { conversationId, envelope });
 }
 /**
  * Records `draft` in the in-memory tier, evicting the oldest-inserted conversation first if this
@@ -272,7 +276,7 @@ export function readCachedDraft({ conversationId }) {
     return stored;
 }
 /**
- * Stores `draft` for `conversationId` in both tiers.
+ * Stores `draft` for `conversationId` in both tiers. Returns whether durable storage accepted it.
  *
  * @param conversationId No-ops when absent (`null`/`undefined`) — there is nothing to key on yet.
  * `useComposer` covers that window by adopting the typed text once an id arrives; see its own doc.
@@ -281,11 +285,11 @@ export function readCachedDraft({ conversationId }) {
  * writes `''` here.
  * @complexity Time/space: O(n) in the draft's length; see {@link writeStoredDraft}.
  */
-export function writeCachedDraft({ conversationId, draft }) {
+export function writeCachedDraft({ conversationId, draft }, _options = {}) {
     if (!conversationId)
-        return;
+        return false;
     rememberCachedDraft({ conversationId: conversationId, draft: draft });
-    writeStoredDraft(conversationId, draft.trim() === '' ? '' : draft);
+    return writeStoredDraft(conversationId, draft.trim() === '' ? '' : draft);
 }
 /**
  * Stores `draft` for `conversationId` in the in-memory tier only, leaving `localStorage` alone.
@@ -434,26 +438,25 @@ export function writeCachedAttachmentBatchId({ conversationId, batchId }, _optio
     setBounded(stagedBatchIds, { key: conversationId, value: batchId });
 }
 /**
- * Stores `attachments` for `conversationId` in both tiers.
+ * Stores `attachments` for `conversationId` in both tiers. Returns whether storage accepted it.
  *
  * @param attachments An empty list deletes the entry, so a sent or cleared turn leaves nothing to
  * restore — the same rule the draft text follows.
  * @complexity Time/space: O(n) in the number of references.
  */
-export function writeCachedAttachments({ conversationId, attachments }) {
+export function writeCachedAttachments({ conversationId, attachments }, _options = {}) {
     if (!conversationId)
-        return;
+        return false;
     if (attachments.length === 0) {
         stagedAttachments.delete(conversationId);
         // A sent or cleared turn's batch is spent; the next upload starts a fresh one.
         stagedBatchIds.delete(conversationId);
-        writeStoredEnvelope(COMPOSER_ATTACHMENTS_STORAGE_PREFIX, { conversationId, envelope: null });
-        return;
+        return writeStoredEnvelope(COMPOSER_ATTACHMENTS_STORAGE_PREFIX, { conversationId, envelope: null });
     }
     setBounded(stagedAttachments, { key: conversationId, value: attachments });
     const batchId = stagedBatchIds.get(conversationId);
     const envelope = { v: 1, t: Date.now(), a: attachments, ...(batchId === undefined ? {} : { b: batchId }) };
-    writeStoredEnvelope(COMPOSER_ATTACHMENTS_STORAGE_PREFIX, { conversationId, envelope });
+    return writeStoredEnvelope(COMPOSER_ATTACHMENTS_STORAGE_PREFIX, { conversationId, envelope });
 }
 /**
  * Test-only: empties the cache so test cases cannot leak drafts into each other.
@@ -465,11 +468,33 @@ export function writeCachedAttachments({ conversationId, attachments }) {
  */
 export function __resetComposerDraftCacheForTests(options) {
     drafts.clear();
+    folderDrafts.clear();
     stagedAttachments.clear();
     stagedBatchIds.clear();
     if (options?.keepStorage === true)
         return;
+    pruneStored(COMPOSER_FOLDERS_STORAGE_PREFIX, 0);
     pruneStored(COMPOSER_DRAFT_STORAGE_PREFIX, 0);
     pruneStored(COMPOSER_ATTACHMENTS_STORAGE_PREFIX, 0);
 }
+/** Folder drafts share the bounded cache owner, but never upload liveness or TTL checks. */
+export function readCachedFolders({ conversationId }, _options = {}) {
+    if (!conversationId)
+        return [];
+    const cached = folderDrafts.get(conversationId);
+    if (cached)
+        return [...cached];
+    const stored = readStoredEnvelope(COMPOSER_FOLDERS_STORAGE_PREFIX, { conversationId, decode: parsed => {
+            const value = parsed;
+            return value?.v === 1 && Array.isArray(value.folders) && value.folders.every(path => typeof path === 'string') ? value.folders : null;
+        } });
+    return stored ?? [];
+}
+/** Persist exact strings independently of text and attachment validation; report storage failure. */
+export function writeCachedFolders({ conversationId, folders }, _options = {}) {
+    if (!conversationId)
+        return false;
+    setBounded(folderDrafts, { key: conversationId, value: [...folders] });
+    return writeStoredEnvelope(COMPOSER_FOLDERS_STORAGE_PREFIX, { conversationId, envelope: folders.length ? { v: 1, t: Date.now(), folders } : null });
+}
 //# sourceMappingURL=composer-draft-cache.js.map

package/dist/react/hooks/useComposer.d.ts

@@ -72,6 +72,13 @@ export interface UseComposerResult {
     /** Optional for compatibility with host-created composer controllers. */
     history?: ComposerHistoryController;
     setDraft: (next: string) => void;
+    folders?: string[];
+    addFolders: (input: {
+        folders: readonly string[];
+    }, options?: {}) => void;
+    removeFolder: (input: {
+        path: string;
+    }, options?: {}) => void;
     attachments: ChatAttachment[];
     /** Uploads via `project.uploadFiles` (when supplied) and stages the results; no-ops (with a rejected promise) when no upload port is wired. */
     addAttachments: (files: File[]) => Promise<void>;

package/dist/react/hooks/useComposer.js

@@ -29,7 +29,7 @@
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useComposerHistory } from './useComposerHistory.hooks.js';
-import { readCachedAttachments, readCachedDraft, rememberCachedDraft, writeCachedAttachments, writeCachedDraft, } from './composer-draft-cache.js';
+import { readCachedFolders, writeCachedFolders, readCachedAttachments, readCachedDraft, rememberCachedDraft, writeCachedAttachments, writeCachedDraft, } from './composer-draft-cache.js';
 import { cacheAttachmentPreviewSource } from './attachment-preview-cache.js';
 /**
  * The real window/document pair, or `null` when this runtime has no `window` — a non-DOM React
@@ -49,16 +49,19 @@ const EMPTY_MENTION = { open: false, query: '', results: [] };
  */
 export const DRAFT_PERSIST_DEBOUNCE_MS = 800;
 /**
- * One pending durable draft write at a time, trailing-edge debounced. Flushes on unmount and when
+ * One pending durable draft write at a time, trailing-edge debounced. Release checks flush and
+ * consult the draft owner without adding a browser reload prompt. Flushes on unmount and when
  * the page is hidden (`pagehide`, or `visibilitychange` to hidden — the last event a mobile browser
  * reliably delivers before discarding the tab).
  * @param pageLifecycle The page-exit event sources, captured at mount; `undefined` resolves the
  *   browser's own, `null` subscribes to nothing (unmount still flushes).
  * @complexity Time/space: O(1) per call.
  */
-function useDeferredDraftWrite(pageLifecycle) {
+function useDeferredDraftWrite(pageLifecycle, canRelease) {
     const [lifecycle] = useState(() => (pageLifecycle === undefined ? browserPageLifecycle() : pageLifecycle));
     const pendingRef = useRef(null);
+    const canReleaseRef = useRef(canRelease);
+    canReleaseRef.current = canRelease;
     const cancel = useCallback(() => {
         const pending = pendingRef.current;
         if (!pending)
@@ -91,10 +94,23 @@ function useDeferredDraftWrite(pageLifecycle) {
             if (doc.visibilityState === 'hidden')
                 flush();
         };
+        const onReleaseCheck = (event) => {
+            try {
+                flush();
+                if (!canReleaseRef.current())
+                    event.preventDefault();
+            }
+            catch {
+                // Host persistence may throw; a release must never discard the only surviving copy.
+                event.preventDefault();
+            }
+        };
         page.addEventListener('pagehide', flush);
+        page.addEventListener('jini:release-check', onReleaseCheck);
         doc.addEventListener('visibilitychange', onVisibilityChange);
         return () => {
             page.removeEventListener('pagehide', flush);
+            page.removeEventListener('jini:release-check', onReleaseCheck);
             doc.removeEventListener('visibilitychange', onVisibilityChange);
             flush();
         };
@@ -104,10 +120,40 @@ function useDeferredDraftWrite(pageLifecycle) {
 export function useComposer(options = {}) {
     const { project, composerSlots, persistence, conversationId, validateAttachments } = options;
     const [draft, setDraftState] = useState(() => options.initialDraft ?? persistence?.read() ?? readCachedDraft({ conversationId: conversationId }) ?? '');
+    const [folders, setFolders] = useState(() => readCachedFolders({ conversationId }));
+    // Persist inside the state transition with its conversation key: switching cannot write an old
+    // render's folders over the newly selected conversation, and a pick survives immediate unmount.
+    const addFolders = useCallback(({ folders: picked }, _options = {}) => {
+        setFolders(previous => {
+            const next = [...new Set([...previous, ...picked])];
+            writeCachedFolders({ conversationId, folders: next });
+            return next;
+        });
+    }, [conversationId]);
+    const removeFolder = useCallback(({ path }, _options = {}) => {
+        setFolders(previous => {
+            const next = previous.filter(folder => folder !== path);
+            writeCachedFolders({ conversationId, folders: next });
+            return next;
+        });
+    }, [conversationId]);
     const [attachments, setAttachments] = useState([]);
     const [agent, setAgent] = useState(options.initialAgent);
     const [mention, setMention] = useState(EMPTY_MENTION);
-    const deferredWrite = useDeferredDraftWrite(options.pageLifecycle);
+    const pendingUploadsRef = useRef(0);
+    const deferredWrite = useDeferredDraftWrite(options.pageLifecycle, () => {
+        if (pendingUploadsRef.current > 0)
+            return false;
+        // Retry even after the debounce: the cache's memory tier cannot survive guest destruction.
+        // Empty values are durable deletions too. A failed remove must not resurrect a cleared draft
+        // after this guest is destroyed and storage becomes readable again.
+        const textSaved = conversationId ? writeCachedDraft({ conversationId, draft }) : draft.trim() === '';
+        const foldersSaved = conversationId ? writeCachedFolders({ conversationId, folders }) : folders.length === 0;
+        // Without the host's liveness validator, a remount deliberately does not restore files.
+        const filesSaved = canReleaseAttachments({ conversationId, attachments, validateAttachments,
+            hydratedFor: attachmentsHydratedForRef.current });
+        return textSaved && foldersSaved && filesSaved;
+    });
     const commitDraft = useCallback((next) => {
         setDraftState(next);
         rememberCachedDraft({ conversationId: conversationId, draft: next });
@@ -164,8 +210,13 @@ export function useComposer(options = {}) {
         // reason — nothing was switched away from.
         if (previousConversationId == null && conversationId != null && restored === null && draftRef.current.trim() !== '') {
             writeCachedDraft({ conversationId: conversationId, draft: draftRef.current });
+            writeCachedFolders({ conversationId, folders });
             return;
         }
+        if (previousConversationId == null && conversationId != null)
+            writeCachedFolders({ conversationId, folders });
+        else
+            setFolders(readCachedFolders({ conversationId }));
         setDraftState(restored ?? '');
         setAttachments([]);
         setMention(EMPTY_MENTION);
@@ -241,7 +292,14 @@ export function useComposer(options = {}) {
         if (!project?.uploadFiles) {
             throw new Error('addAttachments requires ProjectContextValue.uploadFiles to be wired by the host');
         }
-        const uploaded = await project.uploadFiles(files);
+        pendingUploadsRef.current++;
+        let uploaded;
+        try {
+            uploaded = await project.uploadFiles(files);
+        }
+        finally {
+            pendingUploadsRef.current--;
+        }
         setAttachments((prev) => [...prev, ...uploaded]);
         // `uploadFiles` resolves 1:1 with `files`, in order, on success (see
         // `create-daemon-attachment-uploader.ts`'s "preserved order" doc) - any failure rejects the
@@ -284,14 +342,19 @@ export function useComposer(options = {}) {
     }, [draft, setDraft]);
     const reset = useCallback(() => {
         setDraft('');
+        setFolders([]);
+        writeCachedFolders({ conversationId, folders: [] });
         clearAttachments();
         closeMention();
-    }, [clearAttachments, closeMention, setDraft]);
-    const canSubmit = draft.trim().length > 0 || attachments.length > 0;
+    }, [clearAttachments, closeMention, setDraft, conversationId]);
+    const canSubmit = draft.trim().length > 0 || attachments.length > 0 || folders.length > 0;
     return useMemo(() => ({
         draft,
         history,
         setDraft,
+        folders,
+        addFolders,
+        removeFolder,
         attachments,
         addAttachments,
         addAttachment,
@@ -306,6 +369,18 @@ export function useComposer(options = {}) {
         canSubmit,
         reset,
         flushDraft: deferredWrite.flush,
-    }), [draft, history, setDraft, attachments, addAttachments, addAttachment, removeAttachment, clearAttachments, agent, mention, openMention, closeMention, selectMention, canSubmit, reset, deferredWrite.flush]);
+    }), [draft, history, setDraft, folders, addFolders, removeFolder, attachments, addAttachments, addAttachment, removeAttachment, clearAttachments, agent, mention, openMention, closeMention, selectMention, canSubmit, reset, deferredWrite.flush]);
+}
+/** Never erase a pending restore; once settled, confirm persistence of empty lists as well.
+ * Unkeyed empty composers have no stored entry to delete. O(staged files), bounded by the cache.
+ */
+function canReleaseAttachments({ conversationId, attachments, validateAttachments, hydratedFor }, _options = {}) {
+    if (!conversationId)
+        return attachments.length === 0;
+    if (hydratedFor !== conversationId)
+        return false;
+    if (attachments.length > 0 && !validateAttachments)
+        return false;
+    return writeCachedAttachments({ conversationId, attachments });
 }
 //# sourceMappingURL=useComposer.js.map

package/dist/react/hooks/useConversation.d.ts

@@ -27,6 +27,8 @@ export interface SendMessageOptions {
     }) => void;
     /** Non-secret signal from a composer that already sanitized the content before this boundary. */
     secretRedaction?: ChatMessage['secretRedaction'];
+    /** Picked directory paths, kept byte-exact and separate from upload references. */
+    folders?: string[];
     attachments?: ChatAttachment[];
     context?: RunContext;
     agentId?: string;

package/dist/react/hooks/useConversation.js

@@ -1,3 +1,4 @@
+import { formatErrorForLog } from '@jini-ai/core';
 import { acceptedInputUserEvent, projectAcceptedInputEvents } from '../../core/accepted-input.js';
 import { redactUserHistory, redactUserMessage } from '../../core/user-text-redaction.js';
 import { preserveAssistantContent, mergeRunEvents } from '../../core/durable-projection.js';
@@ -32,9 +33,34 @@ function pendingUserMessage({ content, sendOptions, createMessageId }, options =
             content,
             createdAt: Date.now(),
             ...(sendOptions.secretRedaction ? { secretRedaction: sendOptions.secretRedaction } : {}),
+            ...(sendOptions.folders ? { folders: sendOptions.folders } : {}),
             ...(sendOptions.attachments ? { attachments: sendOptions.attachments } : {}),
         } }, options).message;
 }
+/** The queued assistant bubble a send opens; the run's events fill it in. */
+function pendingAssistantMessage({ id }, { agentId } = {}) {
+    return {
+        id,
+        role: 'assistant',
+        content: '',
+        ...(agentId !== undefined ? { agentId } : {}),
+        runStatus: 'queued',
+        createdAt: Date.now(),
+        startedAt: Date.now(),
+    };
+}
+/** What `run.start` receives for one send: only the options the caller actually set. */
+function runStartInput({ assistantMessageId, history, conversationId, sendOptions }, { agentId } = {}) {
+    return {
+        assistantMessageId,
+        history,
+        ...(agentId !== undefined ? { agentId } : {}),
+        conversationId,
+        ...(sendOptions.folders !== undefined ? { folders: sendOptions.folders } : {}),
+        ...(sendOptions.attachments !== undefined ? { attachments: sendOptions.attachments } : {}),
+        ...(sendOptions.context !== undefined ? { context: sendOptions.context } : {}),
+    };
+}
 export function useConversation(options) {
     const { transport, conversationId = null, agentId, createMessageId = defaultCreateMessageId } = options;
     const [messages, setMessagesState] = useState(() => redactUserHistory({ history: options.initialMessages ?? [] }, { ...(options.redactUserText ? { redactUserText: options.redactUserText } : {}) }));
@@ -65,7 +91,7 @@ export function useConversation(options) {
             }
             catch (error) {
                 if (!disposed)
-                    console.error('[chat] conversation refresh failed', error);
+                    console.error('[chat] conversation refresh failed', formatErrorForLog({ error }));
             }
             finally {
                 pending = false;
@@ -183,20 +209,11 @@ export function useConversation(options) {
     // permanently unset.
     useEffect(() => {
         applyRunToAssistantMessage();
-        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [run.events, run.status, run.runId]);
     const sendMessage = useCallback(async (content, sendOptions = {}) => {
         const userMessage = pendingUserMessage({ content, sendOptions, createMessageId }, options);
         const resolvedAgentId = sendOptions.agentId ?? agentId;
-        const assistantMessage = {
-            id: createMessageId(),
-            role: 'assistant',
-            content: '',
-            ...(resolvedAgentId !== undefined ? { agentId: resolvedAgentId } : {}),
-            runStatus: 'queued',
-            createdAt: Date.now(),
-            startedAt: Date.now(),
-        };
+        const assistantMessage = pendingAssistantMessage({ id: createMessageId() }, { agentId: resolvedAgentId });
         activeAssistantIdRef.current = assistantMessage.id;
         setSendRefused(false);
         const history = redactUserHistory({ history: [...messagesRef.current, userMessage] }, options);
@@ -208,21 +225,14 @@ export function useConversation(options) {
         // (host stuck-chat investigation, 2026-09-27).
         setMessagesState((prev) => [...prev, userMessage, assistantMessage]);
         setScrollIntent(true);
-        const accepted = await run.start({
-            assistantMessageId: assistantMessage.id,
-            history,
-            ...(resolvedAgentId !== undefined ? { agentId: resolvedAgentId } : {}),
-            conversationId,
-            ...(sendOptions.attachments !== undefined ? { attachments: sendOptions.attachments } : {}),
-            ...(sendOptions.context !== undefined ? { context: sendOptions.context } : {}),
-        });
+        const accepted = await run.start(runStartInput({ assistantMessageId: assistantMessage.id, history, conversationId, sendOptions }, { agentId: resolvedAgentId }));
         if (!accepted) {
             // The bubbles go, but the reason must not: it was rendered only on the assistant bubble.
             setMessagesState(prev => prev.filter(message => message.id !== userMessage.id && message.id !== assistantMessage.id));
             setSendRefused(true);
             return;
         }
-        const inputs = sendOptions.acceptedInputs ?? [{ id: userMessage.id, text: userMessage.content }];
+        const inputs = sendOptions.acceptedInputs ?? [{ id: userMessage.id, text: userMessage.content, ...(userMessage.folders ? { folders: userMessage.folders } : {}) }];
         setMessagesState(prev => prev.map(message => message.id === userMessage.id ? { ...message, inputPending: false } : message));
         sendOptions.onAccepted?.({ inputs });
     }, [agentId, conversationId, createMessageId, run, options.redactUserText, options.onSecretRedacted]);
@@ -254,6 +264,7 @@ export function useConversation(options) {
             history,
             ...(resolvedAgentId !== undefined ? { agentId: resolvedAgentId } : {}),
             conversationId,
+            ...(priorUser.folders !== undefined ? { folders: priorUser.folders } : {}),
             ...(priorUser.attachments !== undefined ? { attachments: priorUser.attachments } : {}),
         });
     }, [agentId, conversationId, run, options.redactUserText, options.onSecretRedacted]);

package/dist/react/hooks/useRunStream.js

@@ -1,3 +1,4 @@
+import { formatErrorForLog } from '@jini-ai/core';
 /**
  * @module useRunStream
  *
@@ -20,7 +21,7 @@
 import { mergeRunEvents } from '../../core/durable-projection.js';
 import { useCallback, useEffect, useRef, useState } from 'react';
 function reportRunStreamHostEffectFailure(effectName, error) {
-    console.error(`[@jini-ai/chat] useRunStream ${effectName} host effect failed:`, error);
+    console.error(`[@jini-ai/chat] useRunStream ${effectName} host effect failed:`, formatErrorForLog({ error }));
 }
 /**
  * Fire-and-forget teardown call to `transport.stopRun`. Invokes it synchronously, then observes

package/dist/react/hooks/useSurfaceRecovery.d.ts

@@ -0,0 +1,23 @@
+import { type McpUiToolCallHandler, type UIResource } from '@jini-ai/ui/mcp-ui';
+import type { ExtEventCall } from '../ext-event-renderer-registry.js';
+/** Restore only an unanswered call: completed decisions must never execute twice. */
+export declare function surfaceNeedsRecovery({ call, runStreaming }: {
+    call: ExtEventCall | undefined;
+    runStreaming: boolean;
+}, _options?: {}): boolean;
+/** Nonvisual card lifecycle: mount/focus restores the server's original invocation; late clicks
+ * use the same stream. A component owns its subscription and aborts it on teardown.
+ * @complexity O(card document size) per emission; O(1) subscriptions per visible card.
+ */
+export declare function useSurfaceRecovery({ resource, call, runStreaming, onToolCall }: {
+    resource: UIResource | undefined;
+    call: ExtEventCall | undefined;
+    runStreaming: boolean;
+    onToolCall: McpUiToolCallHandler | undefined;
+}, _options?: {}): {
+    resource: UIResource | undefined;
+    restored: boolean;
+    live: boolean;
+    onToolCall: McpUiToolCallHandler | undefined;
+};
+//# sourceMappingURL=useSurfaceRecovery.d.ts.map

package/dist/react/hooks/useSurfaceRecovery.js

@@ -0,0 +1,84 @@
+import { useEffect, useRef, useState } from 'react';
+import { parseUIResource } from '@jini-ai/ui/mcp-ui';
+import { recoverableSurfaceResource, surfaceRecoveryInfo, SURFACE_EXCHANGE_META } from '../../core/surface-recovery.js';
+/** Restore only an unanswered call: completed decisions must never execute twice. */
+export function surfaceNeedsRecovery({ call, runStreaming }, _options = {}) {
+    if (!call)
+        return false;
+    if (!call.result)
+        return !runStreaming;
+    return call.result.isError || /\b(expired|abandoned|did not respond|run ended)\b/i.test(call.result.content);
+}
+function recoveryCaller(call) {
+    if (!call || !('restore' in call) || !('answer' in call))
+        return undefined;
+    if (typeof call.restore !== 'function' || typeof call.answer !== 'function')
+        return undefined;
+    return call;
+}
+/** Nonvisual card lifecycle: mount/focus restores the server's original invocation; late clicks
+ * use the same stream. A component owns its subscription and aborts it on teardown.
+ * @complexity O(card document size) per emission; O(1) subscriptions per visible card.
+ */
+export function useSurfaceRecovery({ resource, call, runStreaming, onToolCall }, _options = {}) {
+    const [restored, setRestored] = useState();
+    const [live, setLive] = useState(false);
+    const pending = useRef(undefined);
+    const answerController = useRef(undefined);
+    const completed = useRef(false);
+    const info = surfaceRecoveryInfo({ value: resource?.resource._meta?.[SURFACE_EXCHANGE_META] });
+    const caller = info ? recoveryCaller(onToolCall) : undefined;
+    const needsRecovery = surfaceNeedsRecovery({ call, runStreaming });
+    const onSurface = (emission) => {
+        if (emission.channel !== 'mcp-ui')
+            return;
+        const next = parseUIResource(recoverableSurfaceResource({ resource: emission.payload['resource'], exchange: emission.payload['surfaceExchange'] }));
+        if (next) {
+            setRestored(next);
+            setLive(true);
+        }
+    };
+    useEffect(() => {
+        if (!caller || !info || !needsRecovery)
+            return;
+        let disposed = false;
+        const restore = () => {
+            if (pending.current || disposed || completed.current)
+                return;
+            const controller = new AbortController();
+            pending.current = controller;
+            void caller.restore({ ...info, signal: controller.signal, onSurface: emission => { if (!disposed)
+                    onSurface(emission); } })
+                .then(() => { if (!disposed)
+                completed.current = true; })
+                .catch(() => { })
+                .finally(() => { if (!disposed) {
+                pending.current = undefined;
+                setLive(false);
+            } });
+        };
+        restore();
+        window.addEventListener('focus', restore);
+        return () => {
+            disposed = true;
+            window.removeEventListener('focus', restore);
+            pending.current?.abort();
+            pending.current = undefined;
+            answerController.current?.abort();
+            answerController.current = undefined;
+        };
+    }, [caller, info?.exchangeId, needsRecovery]);
+    useEffect(() => () => answerController.current?.abort(), []);
+    const toolCall = caller ? async (submitted) => {
+        const controller = new AbortController();
+        answerController.current = controller;
+        try {
+            return await caller.answer({ call: submitted, signal: controller.signal, onSurface });
+        }
+        finally {
+            answerController.current = undefined;
+        }
+    } : onToolCall;
+    return { resource: restored ?? resource, restored: restored !== undefined, live, onToolCall: toolCall };
+}
+//# sourceMappingURL=useSurfaceRecovery.js.map

package/dist/react/styles/reference.css

@@ -36,11 +36,10 @@
 }
 
 /* Lets a long agent name inside (e.g. an AgentRuntimePicker trigger) shrink and ellipsis instead
-   of forcing the row wider — flex items default to min-width:auto, which blocks shrinking below
-   content size unless every ancestor in the chain opts out. Docked into a narrow sidebar (< 400px)
-   is exactly where this stops being cosmetic. */
+   of forcing the row wider, while retaining the fixed controls' intrinsic minimum. A zero floor
+   let the effort selector overflow this wrapper across the Send/Stop hit targets in a dock. */
 .jini-composer-footer-accessories {
-  min-width: 0;
+  min-width: min-content;
 }
 
 /* The picker, plus menu and send share this <div>; flex keeps them on one line, and it wraps
@@ -48,7 +47,7 @@
 .jini-composer-footer-trailing {
   display: flex;
   align-items: center;
-  min-width: 0;
+  min-width: min-content;
   margin-left: auto;
 }
 
@@ -328,3 +327,9 @@
  * deleted silently) so a future reader who remembers seeing "queued" in this file finds the pointer
  * instead of concluding the removal was accidental.
  */
+
+.jini-composer-attachments, .jini-folder-chips__list { display: flex; flex-wrap: wrap; }
+.jini-folder-chips, .jini-folder-chips__name { min-width: 0; max-width: 100%; overflow-wrap: anywhere; }
+.jini-folder-chips__toggle, .jini-folder-chips__item { display: flex; align-items: center; }
+.jini-folder-chips__list { list-style: none; }
+.jini-folder-chips svg, .jini-folder-chips button { flex-shrink: 0; }

package/dist/store/legacy/sqlite/messages.d.ts

@@ -25,6 +25,12 @@ export declare function listMessages({ db, conversationId }: {
     db: SqliteDb;
     conversationId: string;
 }): {
+    sessionMode: ChatSessionMode | undefined;
+    runContext: any;
+    createdAt: any;
+    startedAt: any;
+    endedAt: any;
+    folders?: string[];
     id: any;
     role: any;
     content: any;
@@ -35,11 +41,6 @@ export declare function listMessages({ db, conversationId }: {
     lastRunEventId: any;
     events: any;
     attachments: any;
-    sessionMode: ChatSessionMode | undefined;
-    runContext: any;
-    createdAt: any;
-    startedAt: any;
-    endedAt: any;
 }[];
 /**
  * Thrown by `upsertMessage` when the caller presents a message `id` together with a
@@ -150,6 +151,12 @@ export declare function deleteMessage({ db, id }: {
 }): void;
 /** @internal Converts a raw SQLite row to a plain object with JSON columns parsed and null coerced to undefined. */
 declare function normalizeMessage(row: DbRow): {
+    sessionMode: ChatSessionMode | undefined;
+    runContext: any;
+    createdAt: any;
+    startedAt: any;
+    endedAt: any;
+    folders?: string[];
     id: any;
     role: any;
     content: any;
@@ -160,11 +167,6 @@ declare function normalizeMessage(row: DbRow): {
     lastRunEventId: any;
     events: any;
     attachments: any;
-    sessionMode: ChatSessionMode | undefined;
-    runContext: any;
-    createdAt: any;
-    startedAt: any;
-    endedAt: any;
 };
 export {};
 //# sourceMappingURL=messages.d.ts.map