@jini-ai/chat 0.5.3 → 0.5.4

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.5.4 — 2026-10-06
+
+- Prompt history in the composer: ↑ with the caret on the first line recalls earlier sent messages and ↓ on the last line walks forward; the first ↑ stashes the current draft (empty or not) and ↓ past the newest entry (or Escape) restores it exactly. Recalled entries are never mutated; consecutive duplicates collapse. New pure `createComposerHistoryState` / `transitionComposerHistory` / `composerHistoryKeyAction` / `mergeComposerHistory` / `normalizeComposerHistory` (core) and `createBrowserComposerHistoryStorage` (react, a `ComposerHistoryStoragePort` default). `useComposer`/`ChatPane` take `historyScope`, `historyStorage` and `historyMessages`.
+- Durable runs: new `recoveredRunEvents` (core) projects a recovered run's saved events so a continued answer completes the same message; a run notice shows only on a real resume.
+- Message attachments: the transport sends each message's own attachment refs, and attachment chips keep their kind across reloads.
+- Requires `@jini-ai/protocol` ^0.4.1.
+
 ## 0.5.3 — 2026-10-06
 
 - New `createLastConversationStore({ scope }, { storage? })` (react): remembers one conversation id per caller identity under a versioned localStorage key (`jini.chat.last-conversation.v1.<scope>`); corrupt or foreign entries read as nothing remembered. Selection stays host-owned.

package/dist/core/composer-history.d.ts

@@ -0,0 +1,54 @@
+/** Text-only prompt recall. Browsing owns a snapshot so incoming turns cannot move its cursor. */
+export interface ComposerHistoryState {
+    entries: readonly string[];
+    index: number | null;
+    draft: string | null;
+}
+export interface ComposerHistoryStoragePort {
+    read: (required: {
+        scope: string;
+    }, optional: {}) => Promise<readonly string[]>;
+    write: (required: {
+        scope: string;
+        entries: readonly string[];
+    }, optional: {}) => Promise<void>;
+}
+export interface ComposerHistoryKeyInput {
+    key: string;
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+    isComposing?: boolean;
+    popupOpen?: boolean;
+    /** A DOM host can refine logical newline boundaries with measured soft-wrap boundaries. */
+    firstLine?: boolean;
+    lastLine?: boolean;
+}
+export declare function normalizeComposerHistory({ entries }: {
+    entries: readonly string[];
+}, { cap }?: {
+    cap?: number;
+}): string[];
+export declare function mergeComposerHistory({ recent, current }: {
+    recent: readonly string[];
+    current: readonly string[];
+}, { cap }?: {
+    cap?: number;
+}): string[];
+export declare function createComposerHistoryState(_required: {}, _optional?: {}): ComposerHistoryState;
+export declare function composerHistoryKeyAction(input: ComposerHistoryKeyInput, _optional?: {}): 'previous' | 'next' | 'restore' | null;
+export declare function transitionComposerHistory({ state, action, text, entries }: {
+    state: ComposerHistoryState;
+    action: 'previous' | 'next' | 'restore' | 'edit' | 'reset';
+    text: string;
+    entries: readonly string[];
+}, _optional?: {}): {
+    state: ComposerHistoryState;
+    text: string;
+    handled: boolean;
+};
+//# sourceMappingURL=composer-history.d.ts.map

package/dist/core/composer-history.js

@@ -0,0 +1,57 @@
+export function normalizeComposerHistory({ entries }, { cap = 100 } = {}) {
+    const result = [];
+    for (const text of entries) {
+        // Blank/attachment-only turns are not useful prompts; meaningful whitespace stays exact.
+        if (text.trim() && text !== result[result.length - 1])
+            result.push(text);
+    }
+    return result.slice(-Math.max(1, Math.floor(cap)));
+}
+export function mergeComposerHistory({ recent, current }, { cap = 100 } = {}) {
+    const left = normalizeComposerHistory({ entries: recent }, { cap });
+    const right = normalizeComposerHistory({ entries: current }, { cap });
+    // A mounted conversation is usually already the recent list's suffix. Do not append its
+    // entire transcript again on every streamed render; preserve nonconsecutive repetitions.
+    let overlap = Math.min(left.length, right.length);
+    while (overlap > 0 && !right.slice(0, overlap).every((text, i) => text === left[left.length - overlap + i]))
+        overlap -= 1;
+    return normalizeComposerHistory({ entries: [...left, ...right.slice(overlap)] }, { cap });
+}
+export function createComposerHistoryState(_required, _optional = {}) {
+    return { entries: [], index: null, draft: null };
+}
+export function composerHistoryKeyAction(input, _optional = {}) {
+    if (input.shiftKey || input.ctrlKey || input.altKey || input.metaKey || input.isComposing || input.popupOpen)
+        return null;
+    if (input.key === 'Escape')
+        return 'restore';
+    const start = Math.min(input.selectionStart, input.selectionEnd);
+    const end = Math.max(input.selectionStart, input.selectionEnd);
+    if (input.text.slice(start, end).includes('\n'))
+        return null;
+    const firstLine = !input.text.slice(0, end).includes('\n') && input.firstLine !== false;
+    const lastLine = !input.text.slice(start).includes('\n') && input.lastLine !== false;
+    if (input.key === 'ArrowUp' && firstLine)
+        return 'previous';
+    if (input.key === 'ArrowDown' && lastLine)
+        return 'next';
+    return null;
+}
+export function transitionComposerHistory({ state, action, text, entries }, _optional = {}) {
+    if (action === 'edit' || action === 'reset') {
+        return { state: createComposerHistoryState({}), text, handled: false };
+    }
+    if (state.index === null) {
+        if (action !== 'previous' || entries.length === 0)
+            return { state, text, handled: false };
+        const snapshot = [...entries];
+        const index = snapshot.length - 1;
+        return { state: { entries: snapshot, index, draft: text }, text: snapshot[index], handled: true };
+    }
+    if (action === 'restore' || (action === 'next' && state.index === state.entries.length - 1)) {
+        return { state: createComposerHistoryState({}), text: state.draft ?? '', handled: true };
+    }
+    const index = action === 'previous' ? Math.max(0, state.index - 1) : state.index + 1;
+    return { state: { ...state, index }, text: state.entries[index], handled: true };
+}
+//# sourceMappingURL=composer-history.js.map

package/dist/core/durable-projection.d.ts

@@ -0,0 +1,28 @@
+import type { AgentEvent } from './events.js';
+import type { ChatMessage } from './messages.js';
+/** Saved checkpoints can coalesce deltas and a completion may replay only a prefix. Keep the
+ * saved projection, merge identifiable events, and append only text beyond its saved prefix. */
+export declare function mergeRunEvents({ saved, incoming }: {
+    saved?: readonly AgentEvent[] | undefined;
+    incoming: readonly AgentEvent[];
+}, _optional?: {}): AgentEvent[];
+/** A recovered attempt stays visibly in progress until new text or tool work supersedes its marker. */
+export declare function continuingRunNotice({ events, active }: {
+    events: readonly AgentEvent[] | undefined;
+    active: boolean;
+}, _optional?: {}): string | null;
+export declare function preserveAssistantContent({ saved, incoming }: {
+    saved: string;
+    incoming: string;
+}, _optional?: {}): string;
+/** Terminal failure belongs to the message. Legacy resend instructions are display-only;
+ * changing this copy must never execute or reopen an old terminal run. */
+export declare function terminalMessageNotice({ message }: {
+    message: ChatMessage;
+}, _optional?: {}): string | null;
+/** The first answer has no earlier segment to divide, even if startup was retried. Only saved
+ * visible text can justify a Continued divider; the recovery marker still records the attempt. */
+export declare function recoveredRunEvents({ saved }: {
+    saved: readonly AgentEvent[];
+}, _optional?: {}): AgentEvent[];
+//# sourceMappingURL=durable-projection.d.ts.map

package/dist/core/durable-projection.js

@@ -0,0 +1,71 @@
+function identity(event) {
+    const wire = event;
+    if (wire.eventId !== undefined)
+        return `event:${wire.eventId}`;
+    if (wire.cursor !== undefined)
+        return `cursor:${wire.cursor}`;
+    if (event.kind === 'tool_use')
+        return `use:${event.id}`;
+    if (event.kind === 'tool_result')
+        return `result:${event.toolUseId}`;
+    return JSON.stringify(event);
+}
+function textOf(events) {
+    return events.filter((event) => event.kind === 'text').map((event) => event.text).join('');
+}
+/** Saved checkpoints can coalesce deltas and a completion may replay only a prefix. Keep the
+ * saved projection, merge identifiable events, and append only text beyond its saved prefix. */
+export function mergeRunEvents({ saved, incoming }, _optional = {}) {
+    const previous = saved ?? [];
+    const result = [...previous];
+    const keys = new Set(previous.map(identity));
+    const before = textOf(previous);
+    const after = textOf(incoming);
+    let skip = after.startsWith(before) ? before.length : after.length;
+    for (const event of incoming) {
+        if (event.kind === 'text') {
+            const text = event.text.slice(skip);
+            skip = Math.max(0, skip - event.text.length);
+            if (text)
+                result.push({ ...event, text });
+        }
+        else if (!keys.has(identity(event))) {
+            keys.add(identity(event));
+            result.push(event);
+        }
+    }
+    return result;
+}
+/** A recovered attempt stays visibly in progress until new text or tool work supersedes its marker. */
+export function continuingRunNotice({ events, active }, _optional = {}) {
+    if (!active)
+        return null;
+    const list = events ?? [];
+    const marker = list.findLastIndex((event) => event.kind === 'status' && event.code === 'run_recovering');
+    if (marker < 0)
+        return null;
+    const progressed = list.slice(marker + 1).some((event) => event.kind === 'text' || event.kind === 'tool_use' || event.kind === 'tool_result');
+    return progressed ? null : 'Continuing…';
+}
+export function preserveAssistantContent({ saved, incoming }, _optional = {}) {
+    return incoming.length >= saved.length ? incoming : saved;
+}
+/** Terminal failure belongs to the message. Legacy resend instructions are display-only;
+ * changing this copy must never execute or reopen an old terminal run. */
+export function terminalMessageNotice({ message }, _optional = {}) {
+    if (message.runStatus !== 'failed' && message.runStatus !== 'canceled')
+        return null;
+    const notice = message.events?.filter((event) => event.kind === 'status' &&
+        (event.code === 'run_terminal' || /failed|stopped|restarted|could not|not logged in|cancell?ed/i.test(event.label))).at(-1);
+    if (notice?.kind === 'status')
+        return [notice.label, notice.detail].filter(Boolean).join(' ').replace(/Send your message again to retry\.?/gi, '').trim();
+    return message.runStatus === 'failed' ? 'This turn failed.' : 'Stopped.';
+}
+/** The first answer has no earlier segment to divide, even if startup was retried. Only saved
+ * visible text can justify a Continued divider; the recovery marker still records the attempt. */
+export function recoveredRunEvents({ saved }, _optional = {}) {
+    const hasAnswer = saved.some(event => event.kind === 'text' && event.text.trim().length > 0);
+    return [...saved, ...(hasAnswer ? [{ kind: 'text', text: '\n\n---\n\nContinued\n\n' }] : []),
+        { kind: 'status', code: 'run_recovering', label: 'Continuing…' }];
+}
+//# sourceMappingURL=durable-projection.js.map

package/dist/core/index.d.ts

@@ -42,4 +42,7 @@ export * from './agentic/index.js';
  * module, and a host binds it to its own authentication.
  */
 export * from './persistence/index.js';
+export { recoveredRunEvents } from './durable-projection.js';
+export { composerHistoryKeyAction, createComposerHistoryState, mergeComposerHistory, normalizeComposerHistory, transitionComposerHistory, } from './composer-history.js';
+export type { ComposerHistoryKeyInput, ComposerHistoryState, ComposerHistoryStoragePort } from './composer-history.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -42,4 +42,6 @@ export * from './agentic/index.js';
  * module, and a host binds it to its own authentication.
  */
 export * from './persistence/index.js';
+export { recoveredRunEvents } from './durable-projection.js';
+export { composerHistoryKeyAction, createComposerHistoryState, mergeComposerHistory, normalizeComposerHistory, transitionComposerHistory, } from './composer-history.js';
 //# sourceMappingURL=index.js.map

package/dist/core/transport.d.ts

@@ -30,6 +30,8 @@ import type { ChatAttachment, ChatMessage, ChatRunStatus } from './messages.js';
  * via `extends`.
  */
 export interface RunHandlers {
+    /** Authoritative saved projection; may advance an attempt without ending its message. */
+    onCheckpoint?: (message: ChatMessage) => void;
     /** Fired once per renderable unit of agent output. */
     onEvent: (ev: AgentEvent) => void;
     /**
@@ -50,6 +52,8 @@ export interface RunHandlers {
  */
 export type RunContext = Record<string, unknown>;
 export interface StartRunInput {
+    /** The logical assistant message identity, allocated before acceptance. */
+    assistantMessageId?: string;
     history: ChatMessage[];
     agentId?: string;
     conversationId?: string | null;

package/dist/react/components/Composer.js

@@ -15,6 +15,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useLayoutEffect, useRef, useState, } from 'react';
 import { RemixIcon } from '@jini-ai/ui';
 import { useT } from '../hooks/context.js';
+import { useComposerHistoryKeys } from '../hooks/useComposerHistoryKeys.hooks.js';
 import { AttachmentTray } from './AttachmentTray.js';
 import { ComposerDiscoveryMenu, ComposerSlashMenu } from './ComposerDiscovery.js';
 import { appendComposerDiscovery, composerDiscoveryMenuPosition, composerSlashMenuPosition, filterComposerDiscovery, parseComposerSlashQuery, replaceComposerSlashTrigger, resolveComposerSlashInvocation, resolveComposerSlashKeyAction, } from './composer-discovery.js';
@@ -103,6 +104,9 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
      * point the shrinking list is its own feedback.
      */
     const showSlashFilterHint = slashQuery !== null && slashQuery.command === '' && slashQuery.argument === null;
+    const handleHistoryKey = useComposerHistoryKeys({ composer, textareaRef }, {
+        popupOpen: slashOpen || discoveryMenuOpen || workdirOpen || composer.mention.open,
+    });
     function restoreComposerFocus() {
         textareaRef.current?.focus();
     }
@@ -286,6 +290,8 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
                 return;
             }
         }
+        if (handleHistoryKey(event))
+            return;
         if (event.key !== 'Enter' || event.shiftKey)
             return;
         event.preventDefault();

package/dist/react/components/MessageRow.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { terminalMessageNotice, continuingRunNotice } from '../../core/durable-projection.js';
 /**
  * @module MessageRow
  *
@@ -120,6 +121,23 @@ function UsageSummary({ usage }) {
         return null;
     return (_jsxs("div", { className: "jini-message-usage", children: [_jsx("span", { className: "jini-message-usage-dot", "aria-hidden": true, children: "\u25CF" }), t('Done'), " \u00B7 ", parts.join(' · ')] }));
 }
+function messageBlocks({ visibleContent, message, rows }, _optional = {}) {
+    // Interleaving is skipped outright when an artifact was stripped. `stripArtifact` operates on the
+    // whole string and trims, so the surviving text no longer lines up with the per-run offsets the
+    // event walk produces, and an artifact block could legitimately span a tool call. Rather than
+    // reason about partial overlaps, an artifact-bearing message keeps the flat layout — those
+    // messages are dominated by the artifact panel anyway, so the ordering matters least there.
+    if (visibleContent !== message.content)
+        return null;
+    return interleaveMessageBlocks({ events: message.events, content: message.content, rows }, { slotOf: (ev) => extEventSlot({ name: ev.name, data: ev.data }) });
+}
+function messageAwaitingAnswer({ runStreaming, runInProgress, events }, _optional = {}) {
+    return runStreaming === true && runInProgress && isAwaitingAnswer({ events });
+}
+function AssistantMessageFooter({ message, usageEvent, terminalNotice, pending, runInProgress, runStreaming, visibleContent }, _optional = {}) {
+    const t = useT();
+    return _jsxs(_Fragment, { children: [usageEvent ? _jsx(UsageSummary, { usage: usageEvent }) : null, terminalNotice ? _jsx("div", { className: "jini-message-error", role: "status", children: t(terminalNotice) }) : null, !pending && !runInProgress ? (_jsx("div", { className: "jini-message-actions jini-message-actions--assistant", children: _jsx(CopyMessageButton, { text: visibleContent, label: t('Copy message') }) })) : null, runInProgress ? _jsx(RunActivityLine, { events: message.events, active: pending || (runStreaming === true && runInProgress) }) : null] });
+}
 /**
  * Quiet, icon-only copy affordance shared by the user- and assistant-message
  * action rows below. Delegates the actual clipboard write (and its
@@ -147,20 +165,14 @@ export function MessageRow({ message, runStreaming = false, runSucceeded = false
     if (message.role === 'user') {
         return (_jsxs("div", { className: "jini-message jini-message-user", "data-message-id": message.id, "data-agent-element": `chat-message-${message.id}`, "data-agent-role": "region", "data-agent-label": "A message from the user", children: [message.attachments && message.attachments.length > 0 ? (_jsx("div", { className: "jini-message-attachments", children: message.attachments.map((a) => (_jsx("button", { type: "button", className: "jini-message-attachment-chip", onClick: () => setOpenAttachment(a), title: t('Open {name}', { name: a.name }), "aria-label": t('Open {name}', { name: a.name }), children: renderAttachment ? renderAttachment(a) : a.name }, a.path))) })) : null, _jsx("div", { className: "jini-message-content", children: message.content }), _jsx("div", { className: "jini-message-actions jini-message-actions--user", children: _jsx(CopyMessageButton, { text: message.content, label: t('Copy message') }) }), openAttachment ? (_jsx(AttachmentPreviewModal, { attachment: openAttachment, onClose: () => setOpenAttachment(null) })) : null] }));
     }
+    const terminalNotice = terminalMessageNotice({ message }, {});
     const visibleContent = stripArtifact({ content: message.content });
     const segments = splitOnQuestionForms({ input: visibleContent });
     const usageEvent = message.events?.filter((ev) => ev.kind === 'usage').pop();
-    // Interleaving is skipped outright when an artifact was stripped. `stripArtifact` operates on the
-    // whole string and trims, so the surviving text no longer lines up with the per-run offsets the
-    // event walk produces, and an artifact block could legitimately span a tool call. Rather than
-    // reason about partial overlaps, an artifact-bearing message keeps the flat layout — those
-    // messages are dominated by the artifact panel anyway, so the ordering matters least there.
-    const blocks = visibleContent === message.content
-        ? interleaveMessageBlocks({ events: message.events, content: message.content, rows: timeline.rows }, { slotOf: (ev) => extEventSlot({ name: ev.name, data: ev.data }) })
-        : null;
+    const blocks = messageBlocks({ visibleContent, message, rows: timeline.rows }, {});
     const pending = isPendingWithNoContent(message, visibleContent, timeline.rows.length);
     const runInProgress = isRunInProgress(message.runStatus);
-    const awaitingAnswer = runStreaming && runInProgress && isAwaitingAnswer({ events: message.events });
+    const awaitingAnswer = messageAwaitingAnswer({ runStreaming, runInProgress, events: message.events }, {});
     const renderToolCard = (row) => (_jsx(ToolCard, { use: row.use, result: row.result, runStreaming: runStreaming, runSucceeded: runSucceeded, ...(projectFileNames !== undefined ? { projectFileNames } : {}), ...(onRequestOpenFile !== undefined ? { onRequestOpenFile } : {}) }, row.id));
     const renderExtGroup = (group) => {
         const renderer = getExtEventRenderer({ name: group.name });
@@ -197,7 +209,7 @@ export function MessageRow({ message, runStreaming = false, runSucceeded = false
                         return null;
                     return (_jsx("div", { className: "jini-message-ext-events", children: renderExtGroup(group) }, block.key));
                 })
-                : (_jsxs(_Fragment, { children: [segments.map((segment, i) => segment.kind === 'text' ? (segment.text.trim() ? (_jsx("div", { className: "jini-message-content", children: _jsx(Markdown, { children: segment.text }) }, i)) : null) : (_jsx(QuestionForm, { form: segment.form, interactive: questionFormInteractive, ...(questionFormSubmittedAnswers !== undefined ? { submittedAnswers: questionFormSubmittedAnswers } : {}), ...(onQuestionFormSubmit !== undefined ? { onSubmit: onQuestionFormSubmit } : {}) }, i))), timeline.rows.length > 0 ? (_jsx("div", { className: "jini-message-tools", children: timeline.rows.map(renderToolCard) })) : null, extGroups.length > 0 ? _jsx("div", { className: "jini-message-ext-events", children: extGroups.map(renderExtGroup) }) : null] })), usageEvent ? _jsx(UsageSummary, { usage: usageEvent }) : null, message.runStatus === 'failed' ? _jsx("div", { className: "jini-message-error", children: t('This turn failed.') }) : null, !pending && !runInProgress ? (_jsx("div", { className: "jini-message-actions jini-message-actions--assistant", children: _jsx(CopyMessageButton, { text: visibleContent, label: t('Copy message') }) })) : null, _jsx(RunActivityLine, { events: message.events, active: pending || (runStreaming === true && runInProgress) })] }));
+                : (_jsxs(_Fragment, { children: [segments.map((segment, i) => segment.kind === 'text' ? (segment.text.trim() ? (_jsx("div", { className: "jini-message-content", children: _jsx(Markdown, { children: segment.text }) }, i)) : null) : (_jsx(QuestionForm, { form: segment.form, interactive: questionFormInteractive, ...(questionFormSubmittedAnswers !== undefined ? { submittedAnswers: questionFormSubmittedAnswers } : {}), ...(onQuestionFormSubmit !== undefined ? { onSubmit: onQuestionFormSubmit } : {}) }, i))), timeline.rows.length > 0 ? (_jsx("div", { className: "jini-message-tools", children: timeline.rows.map(renderToolCard) })) : null, extGroups.length > 0 ? _jsx("div", { className: "jini-message-ext-events", children: extGroups.map(renderExtGroup) }) : null] })), _jsx(AssistantMessageFooter, { message, usageEvent, terminalNotice, pending, runInProgress, runStreaming, visibleContent })] }));
 }
 /**
  * The live "what is it doing" line under a running reply (see `core/run-activity.ts`). Replaces the
@@ -205,7 +217,8 @@ export function MessageRow({ message, runStreaming = false, runSucceeded = false
  * Kept a separate component so its one-second tick re-renders only this line, not the whole row.
  */
 function RunActivityLine({ events, active }) {
-    const label = useRunActivity({ events: events, active: active });
+    const activityLabel = useRunActivity({ events: events, active: active });
+    const label = continuingRunNotice({ events, active }, {}) ?? activityLabel;
     if (label === null)
         return null;
     return (_jsx("div", { className: "jini-message-pending jini-run-activity", "aria-live": "off", children: label }));

package/dist/react/features/chat-pane/components/ChatPane.d.ts

@@ -6,5 +6,5 @@ import type { ChatPaneProps } from '../types.js';
  * @complexity Time/space: O(n) in rendered messages, agents, and suggestions.
  * @overallScore 100/100
  */
-export declare function ChatPane({ transport, agents: injectedAgents, runtimeAccess, runtimeStatusPollMs, title, variant, initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents, daemonOnline, executionMode, apiModeAvailable, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions, workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement, projectFileNames, uploadAttachments, attachmentAccept, disabled, runtimePickerPlacement, composerSlots, header, leadingAccessory, footer, className, style, }: ChatPaneProps): import("react").JSX.Element;
+export declare function ChatPane({ transport, agents: injectedAgents, runtimeAccess, runtimeStatusPollMs, title, variant, initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents, daemonOnline, executionMode, apiModeAvailable, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, composerHistoryScope, composerHistoryStorage, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions, workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement, projectFileNames, uploadAttachments, attachmentAccept, disabled, runtimePickerPlacement, composerSlots, header, leadingAccessory, footer, className, style, }: ChatPaneProps): import("react").JSX.Element;
 //# sourceMappingURL=ChatPane.d.ts.map

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

@@ -73,8 +73,8 @@ function ChatPaneNoUsableCliMessage({ executionMode, apiModeAvailable, onExecuti
 }
 /** The pane's stack of mutually-independent error/status banners — each condition is its own
  * source of truth, so they are rendered as siblings rather than folded into one derived state. */
-function ChatPaneStatusMessages({ unavailable, scanningAgents, connectingAgents, executionMode, apiModeAvailable, onExecutionModeChange, conversationError, attachmentError, dropReadError, workingDirectoryError, workingDirectoryPending, workingDirectoryInvalid, runtimeInventoryError, typedAnswerNotice, onSendAsNewMessage, t, }) {
-    return (_jsxs(_Fragment, { children: [unavailable && connectingAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Connecting to the assistant…') })) : unavailable && scanningAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Loading available CLIs') })) : unavailable ? (_jsx(ChatPaneNoUsableCliMessage, { executionMode: executionMode, apiModeAvailable: apiModeAvailable, onExecutionModeChange: onExecutionModeChange, t: t })) : null, conversationError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: conversationError.message })) : null, attachmentError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: attachmentError.message })) : null, dropReadError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: dropReadError })) : null, workingDirectoryError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: workingDirectoryError.message })) : null, workingDirectoryPending ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Checking working directory…') })) : workingDirectoryInvalid ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: t('Working directory is unavailable.') })) : null, runtimeInventoryError && !connectingAgents ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: runtimeInventoryError.message })) : null, typedAnswerNotice ? (_jsxs("div", { className: "jini-chat-pane__error", role: "alert", children: [t(describeTypedAnswerNotice({ notice: typedAnswerNotice })), typedAnswerNotice === 'not-pending' ? (_jsxs(_Fragment, { children: [' ', _jsx("button", { type: "button", className: "jini-chat-pane__error-action", onClick: onSendAsNewMessage, children: t('Send as a new message') })] })) : null] })) : null] }));
+function ChatPaneStatusMessages({ unavailable, scanningAgents, connectingAgents, executionMode, apiModeAvailable, onExecutionModeChange, attachmentError, dropReadError, workingDirectoryError, workingDirectoryPending, workingDirectoryInvalid, runtimeInventoryError, typedAnswerNotice, onSendAsNewMessage, t, }) {
+    return (_jsxs(_Fragment, { children: [unavailable && connectingAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Connecting to the assistant…') })) : unavailable && scanningAgents ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Loading available CLIs') })) : unavailable ? (_jsx(ChatPaneNoUsableCliMessage, { executionMode: executionMode, apiModeAvailable: apiModeAvailable, onExecutionModeChange: onExecutionModeChange, t: t })) : null, attachmentError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: attachmentError.message })) : null, dropReadError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: dropReadError })) : null, workingDirectoryError ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: workingDirectoryError.message })) : null, workingDirectoryPending ? (_jsx("div", { className: "jini-chat-pane__status", role: "status", children: t('Checking working directory…') })) : workingDirectoryInvalid ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: t('Working directory is unavailable.') })) : null, runtimeInventoryError && !connectingAgents ? (_jsx("div", { className: "jini-chat-pane__error", role: "alert", children: runtimeInventoryError.message })) : null, typedAnswerNotice ? (_jsxs("div", { className: "jini-chat-pane__error", role: "alert", children: [t(describeTypedAnswerNotice({ notice: typedAnswerNotice })), typedAnswerNotice === 'not-pending' ? (_jsxs(_Fragment, { children: [' ', _jsx("button", { type: "button", className: "jini-chat-pane__error-action", onClick: onSendAsNewMessage, children: t('Send as a new message') })] })) : null] })) : null] }));
 }
 function ChatPaneWorkingDirectoryBlock({ workingDirectoryAccess, workingDirectoryControlPlacement, pane, t, }) {
     if (workingDirectoryAccess && workingDirectoryControlPlacement === 'below') {
@@ -178,7 +178,7 @@ function ChatPaneComposerArea({ fileDrop, uploadAttachments, pane, disabled, una
  * @complexity Time/space: O(n) in rendered messages, agents, and suggestions.
  * @overallScore 100/100
  */
-export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, runtimeAccess, runtimeStatusPollMs = 5_000, title, variant = 'workspace', initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents = false, daemonOnline = true, executionMode = 'local', apiModeAvailable = false, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions = [], workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement = 'below', projectFileNames, uploadAttachments, attachmentAccept, disabled = false, runtimePickerPlacement = 'up', composerSlots, header, leadingAccessory, footer, className, style, }) {
+export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, runtimeAccess, runtimeStatusPollMs = 5_000, title, variant = 'workspace', initialMessages, conversationId, initialSelection, selection: controlledSelection, onSelectionChange, runContext, agentControl, onActivityChange, onMessagesChange, onRescanAgents, scanningAgents = false, daemonOnline = true, executionMode = 'local', apiModeAvailable = false, onExecutionModeChange, byokRuntime, onByokModelChange, initialDraft, composerHistoryScope, composerHistoryStorage, validateAttachments, deliverTypedAnswer, composerHandle, placeholder, placeholders, suggestions = [], workingDirectory, initialWorkingDirectory, onChangeWorkingDirectory, workingDirectoryAccess, workingDirectoryControlPlacement = 'below', projectFileNames, uploadAttachments, attachmentAccept, disabled = false, runtimePickerPlacement = 'up', composerSlots, header, leadingAccessory, footer, className, style, }) {
     const t = useT();
     const composerPlaceholder = useChatPaneComposerPlaceholder({ placeholder: placeholder, placeholders: placeholders });
     const inventory = useChatPaneRuntimeInventory(definedProps({ source: {
@@ -201,6 +201,8 @@ export function ChatPane({ transport, agents: injectedAgents = EMPTY_AGENTS, run
             onSelectionChange,
             runContext,
             initialDraft,
+            composerHistoryScope,
+            composerHistoryStorage,
             validateAttachments,
             uploadAttachments,
             onActivityChange,

package/dist/react/features/chat-pane/hooks/useChatPane.hooks.d.ts

@@ -1,6 +1,7 @@
 import { type ChatPaneSendBlocker } from '../rules.js';
 import type { ChatPaneActivity, ChatPaneAgent, ChatPaneAttachmentUploadOptions, ChatPaneAgentSelection, ChatPaneRunContext, ChatPaneWorkingDirectoryAccess, DeliverTypedAnswer, TypedAnswerNotice } from '../types.js';
 import type { ChatAttachment, ChatMessage } from '@jini-ai/chat';
+import type { ComposerHistoryStoragePort } from '../../../../core/composer-history.js';
 import type { ChatTransport } from '@jini-ai/chat';
 import { type UseComposerResult } from '../../../hooks/useComposer.js';
 import { type UseConversationResult } from '../../../hooks/useConversation.js';
@@ -15,6 +16,8 @@ export interface UseChatPaneOptions {
     onSelectionChange?: (selection: ChatPaneAgentSelection) => void;
     runContext?: ChatPaneRunContext;
     initialDraft?: string;
+    composerHistoryScope?: string;
+    composerHistoryStorage?: ComposerHistoryStoragePort;
     /** Forwarded verbatim to `useComposer`; see `validateAttachments` there for the contract. */
     validateAttachments?: (attachments: readonly ChatAttachment[]) => Promise<readonly ChatAttachment[]>;
     uploadAttachments?: (files: File[], options?: ChatPaneAttachmentUploadOptions) => Promise<ChatAttachment[]>;

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

@@ -114,12 +114,6 @@ export function useChatPane(options) {
     const requestedSelection = options.selection ?? internalSelection;
     const selection = useMemo(() => resolveChatPaneSelection({ agents: options.agents, requested: requestedSelection }), [options.agents, requestedSelection]);
     const selectedAgent = options.agents.find((agent) => agent.id === selection.agentId);
-    const composer = useComposer(definedProps({ source: {
-            initialDraft: options.initialDraft,
-            initialAgent: selection,
-            conversationId: options.conversationId,
-            validateAttachments: options.validateAttachments,
-        } }));
     const conversation = useConversation(definedProps({ source: {
             transport: options.transport,
             initialMessages: options.initialMessages,
@@ -128,6 +122,15 @@ export function useChatPane(options) {
             // absent), so only the falsy "no agent selected" case should omit the key.
             agentId: selection.agentId || undefined,
         } }));
+    const composer = useComposer(definedProps({ source: {
+            initialDraft: options.initialDraft,
+            historyMessages: conversation.messages,
+            historyScope: options.composerHistoryScope,
+            historyStorage: options.composerHistoryStorage,
+            initialAgent: selection,
+            conversationId: options.conversationId,
+            validateAttachments: options.validateAttachments,
+        } }));
     const activity = resolveChatPaneActivity(selectedAgent, conversation);
     useEffect(() => {
         options.onActivityChange?.(activity);

package/dist/react/features/chat-pane/types.d.ts

@@ -1,6 +1,7 @@
 import type { CSSProperties, ReactNode, RefObject } from 'react';
 import type { ChatAttachment, ChatMessage } from '@jini-ai/chat';
 import type { ComposerSlots } from '../../slots.js';
+import type { ComposerHistoryStoragePort } from '../../../core/composer-history.js';
 import type { ChatTransport, RunContext } from '@jini-ai/chat';
 export interface ChatPaneAgentOption {
     id: string;
@@ -172,6 +173,10 @@ export interface ChatPaneProps {
     /** Passed straight through to the runtime picker. */
     onByokModelChange?: (model: string) => void;
     initialDraft?: string;
+    /** Principal-scoped recent prompt recall; defaults to the origin-local default scope. */
+    composerHistoryScope?: string;
+    /** Optional storage effects; omitted uses bounded browser storage with memory fallback. */
+    composerHistoryStorage?: ComposerHistoryStoragePort;
     /**
      * Confirms which previously staged attachments still exist, so a draft restored after a reload
      * never shows a chip for a file the backend has since garbage-collected — that looks intact and

package/dist/react/hooks/composer-history-storage.d.ts

@@ -0,0 +1,8 @@
+import { type ComposerHistoryStoragePort } from '../../core/composer-history.js';
+/** Browser default; private/embedded hosts may replace this port without changing recall. */
+export declare function createBrowserComposerHistoryStorage(_required: {}, { storage, prefix }?: {
+    storage?: Pick<Storage, 'getItem' | 'setItem'>;
+    prefix?: string;
+}): ComposerHistoryStoragePort;
+export declare const browserComposerHistoryStorage: ComposerHistoryStoragePort;
+//# sourceMappingURL=composer-history-storage.d.ts.map

package/dist/react/hooks/composer-history-storage.js

@@ -0,0 +1,40 @@
+import { normalizeComposerHistory } from '../../core/composer-history.js';
+/** Browser default; private/embedded hosts may replace this port without changing recall. */
+export function createBrowserComposerHistoryStorage(_required, { storage, prefix = 'jini:composer-history:v1:' } = {}) {
+    const memory = new Map();
+    function resolveStorage() {
+        // Accessing localStorage itself can throw (sandboxed embeds/private browsing).
+        return storage ?? globalThis.localStorage;
+    }
+    return {
+        async read({ scope }, _optional = {}) {
+            try {
+                const raw = resolveStorage()?.getItem(prefix + encodeURIComponent(scope));
+                if (raw) {
+                    const parsed = JSON.parse(raw);
+                    if (Array.isArray(parsed)) {
+                        const entries = normalizeComposerHistory({ entries: parsed.filter((value) => typeof value === 'string') });
+                        memory.set(scope, entries);
+                        return entries;
+                    }
+                }
+            }
+            catch {
+                // Storage denial/corruption must not disable draft editing or in-memory recall.
+            }
+            return memory.get(scope) ?? [];
+        },
+        async write({ scope, entries }, _optional = {}) {
+            const normalized = normalizeComposerHistory({ entries });
+            memory.set(scope, normalized);
+            try {
+                resolveStorage()?.setItem(prefix + encodeURIComponent(scope), JSON.stringify(normalized));
+            }
+            catch {
+                // Quota/denial falls back to the same scoped in-memory list.
+            }
+        },
+    };
+}
+export const browserComposerHistoryStorage = createBrowserComposerHistoryStorage({});
+//# sourceMappingURL=composer-history-storage.js.map

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

@@ -1,4 +1,6 @@
-import type { ChatAttachment } from '../../core/index.js';
+import type { ChatAttachment, ChatMessage } from '../../core/index.js';
+import type { ComposerHistoryStoragePort } from '../../core/composer-history.js';
+import { type ComposerHistoryController } from './useComposerHistory.hooks.js';
 import type { AgentSelection, ComposerSlots, MentionResult, ProjectContextValue } from '../slots.js';
 export interface ComposerDraftPersistence {
     read: () => string | null;
@@ -6,6 +8,11 @@ export interface ComposerDraftPersistence {
 }
 export interface UseComposerOptions {
     initialDraft?: string;
+    /** This principal's current transcript; only user-role text participates in recall. */
+    historyMessages?: readonly ChatMessage[];
+    /** Scopes recent prompts across conversations. Hosts with multiple users must supply an id. */
+    historyScope?: string;
+    historyStorage?: ComposerHistoryStoragePort;
     initialAgent?: AgentSelection;
     project?: ProjectContextValue;
     composerSlots?: ComposerSlots;
@@ -42,6 +49,8 @@ export interface MentionPopoverState {
 }
 export interface UseComposerResult {
     draft: string;
+    /** Optional for compatibility with host-created composer controllers. */
+    history?: ComposerHistoryController;
     setDraft: (next: string) => 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. */

package/dist/react/hooks/useComposer.js

@@ -28,6 +28,7 @@
  * the wrong thread, so they are cleared instead.
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useComposerHistory } from './useComposerHistory.hooks.js';
 import { readCachedAttachments, readCachedDraft, writeCachedAttachments, writeCachedDraft, } from './composer-draft-cache.js';
 import { cacheAttachmentPreviewSource } from './attachment-preview-cache.js';
 const EMPTY_MENTION = { open: false, query: '', results: [] };
@@ -37,11 +38,21 @@ export function useComposer(options = {}) {
     const [attachments, setAttachments] = useState([]);
     const [agent, setAgent] = useState(options.initialAgent);
     const [mention, setMention] = useState(EMPTY_MENTION);
-    const setDraft = useCallback((next) => {
+    const commitDraft = useCallback((next) => {
         setDraftState(next);
         persistence?.write(next);
         writeCachedDraft({ conversationId: conversationId, draft: next });
     }, [persistence, conversationId]);
+    const history = useComposerHistory({ setRecalledDraft: setDraftState }, {
+        ...(options.historyMessages === undefined ? {} : { messages: options.historyMessages }),
+        ...(options.historyScope === undefined ? {} : { scope: options.historyScope }),
+        ...(options.historyStorage === undefined ? {} : { storage: options.historyStorage }),
+        ...(conversationId === undefined ? {} : { conversationId }),
+    });
+    const setDraft = useCallback((next) => {
+        history.edit({});
+        commitDraft(next);
+    }, [commitDraft, history.edit]);
     // Lets the conversation-change effect below read the live draft without taking `draft` as a
     // dependency, which would re-run it on every keystroke.
     const draftRef = useRef(draft);
@@ -195,6 +206,7 @@ export function useComposer(options = {}) {
     const canSubmit = draft.trim().length > 0 || attachments.length > 0;
     return useMemo(() => ({
         draft,
+        history,
         setDraft,
         attachments,
         addAttachments,
@@ -209,6 +221,6 @@ export function useComposer(options = {}) {
         selectMention,
         canSubmit,
         reset,
-    }), [draft, setDraft, attachments, addAttachments, addAttachment, removeAttachment, clearAttachments, agent, mention, openMention, closeMention, selectMention, canSubmit, reset]);
+    }), [draft, history, setDraft, attachments, addAttachments, addAttachment, removeAttachment, clearAttachments, agent, mention, openMention, closeMention, selectMention, canSubmit, reset]);
 }
 //# sourceMappingURL=useComposer.js.map

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

@@ -0,0 +1,15 @@
+import type { ChatMessage } from '../../core/messages.js';
+import { type ComposerHistoryKeyInput, type ComposerHistoryStoragePort } from '../../core/composer-history.js';
+export interface ComposerHistoryController {
+    navigate: (input: ComposerHistoryKeyInput, optional?: {}) => boolean;
+    edit: (required: {}, optional?: {}) => void;
+}
+export declare function useComposerHistory({ setRecalledDraft }: {
+    setRecalledDraft: (text: string) => void;
+}, { messages, scope, storage, conversationId }?: {
+    messages?: readonly ChatMessage[];
+    scope?: string;
+    storage?: ComposerHistoryStoragePort;
+    conversationId?: string | null;
+}): ComposerHistoryController;
+//# sourceMappingURL=useComposerHistory.hooks.d.ts.map

package/dist/react/hooks/useComposerHistory.hooks.js

@@ -0,0 +1,90 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { composerHistoryKeyAction, createComposerHistoryState, mergeComposerHistory, normalizeComposerHistory, transitionComposerHistory, } from '../../core/composer-history.js';
+import { browserComposerHistoryStorage } from './composer-history-storage.js';
+const EMPTY_MESSAGES = [];
+export function useComposerHistory({ setRecalledDraft }, { messages = EMPTY_MESSAGES, scope = 'default', storage = browserComposerHistoryStorage, conversationId } = {}) {
+    const browseRef = useRef(createComposerHistoryState({}));
+    const [recent, setRecent] = useState([]);
+    const hydratedPortRef = useRef(null);
+    const [hydratedScope, setHydratedScope] = useState(null);
+    const pendingRef = useRef([]);
+    const conversationRef = useRef(conversationId);
+    const scopeRef = useRef(scope);
+    const seenRef = useRef(new Set(messages.map((message) => message.id)));
+    const writeQueueRef = useRef(Promise.resolve());
+    const current = useMemo(() => messages.filter((message) => message.role === 'user').map((message) => message.content), [messages]);
+    const entries = mergeComposerHistory({ recent, current });
+    useEffect(() => {
+        let cancelled = false;
+        pendingRef.current = [];
+        hydratedPortRef.current = null;
+        setRecent([]);
+        setHydratedScope(null);
+        browseRef.current = createComposerHistoryState({});
+        // Read after this hook's outstanding writes so an injected async store cannot return stale
+        // entries when a scope is revisited. A remounted hook's default storage writes synchronously.
+        void writeQueueRef.current.then(() => storage.read({ scope }, {})).catch(() => []).then((loaded) => {
+            if (cancelled)
+                return;
+            // Bootstrap an empty recent store from the already-sent current transcript. This
+            // makes opening a new chat useful immediately after installing recall; opening an
+            // older transcript later does not reorder an established recent list.
+            const seed = loaded.length > 0 ? loaded : current;
+            setRecent(normalizeComposerHistory({ entries: [...seed, ...pendingRef.current] }));
+            hydratedPortRef.current = storage;
+            setHydratedScope(scope);
+        });
+        return () => { cancelled = true; };
+    }, [scope, storage]);
+    useEffect(() => {
+        const adopted = conversationRef.current == null && conversationId != null && scopeRef.current === scope;
+        conversationRef.current = conversationId;
+        scopeRef.current = scope;
+        if (adopted)
+            return;
+        browseRef.current = createComposerHistoryState({});
+        // A conversation's existing turns are available for navigation, but merely opening old
+        // conversations must not reorder the cross-conversation recent list.
+        seenRef.current = new Set(messages.map((message) => message.id));
+        // messages is deliberately absent: newly appended turns are handled below, not reseeded.
+    }, [conversationId, scope]);
+    useEffect(() => {
+        const added = [];
+        for (const message of messages) {
+            if (!seenRef.current.has(message.id) && message.role === 'user')
+                added.push(message.content);
+            seenRef.current.add(message.id);
+        }
+        if (added.length === 0)
+            return;
+        pendingRef.current.push(...added);
+        pendingRef.current = normalizeComposerHistory({ entries: pendingRef.current });
+        setRecent((previous) => normalizeComposerHistory({ entries: [...previous, ...added] }));
+    }, [messages]);
+    useEffect(() => {
+        if (hydratedScope !== scope || hydratedPortRef.current !== storage)
+            return;
+        // Serialize writes; a slow earlier write must not overwrite a later prompt.
+        writeQueueRef.current = writeQueueRef.current.then(() => storage.write({ scope, entries: recent }, {})).catch(() => { });
+    }, [hydratedScope, recent, scope, storage]);
+    const navigate = useCallback((input, _optional = {}) => {
+        const action = composerHistoryKeyAction(input);
+        if (action === null)
+            return false;
+        const transition = transitionComposerHistory({ state: browseRef.current, action, text: input.text, entries });
+        if (!transition.handled)
+            return false;
+        browseRef.current = transition.state;
+        // Recall is a view, not an edit to the cached working draft. Reload while copying a
+        // recalled entry still restores what the operator was writing before they browsed.
+        setRecalledDraft(transition.text);
+        return true;
+    }, [entries, setRecalledDraft]);
+    const edit = useCallback((_required, _optional = {}) => {
+        // The first edit leaves history. Its text is now the working draft; stored entries and
+        // the original browsing snapshot are never edited in place.
+        browseRef.current = createComposerHistoryState({});
+    }, []);
+    return useMemo(() => ({ navigate, edit }), [navigate, edit]);
+}
+//# sourceMappingURL=useComposerHistory.hooks.js.map

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

@@ -0,0 +1,9 @@
+import { type KeyboardEvent, type RefObject } from 'react';
+import type { UseComposerResult } from './useComposer.js';
+export declare function useComposerHistoryKeys({ composer, textareaRef }: {
+    composer: UseComposerResult;
+    textareaRef: RefObject<HTMLTextAreaElement | null>;
+}, { popupOpen }?: {
+    popupOpen?: boolean;
+}): (event: KeyboardEvent<HTMLTextAreaElement>) => boolean;
+//# sourceMappingURL=useComposerHistoryKeys.hooks.d.ts.map

package/dist/react/hooks/useComposerHistoryKeys.hooks.js

@@ -0,0 +1,90 @@
+import { useLayoutEffect, useReducer, useRef } from 'react';
+/** Measures visual lines as well as newlines, so a wrapped paragraph keeps native arrow motion. */
+function visualLineBounds({ textarea }) {
+    if (textarea.clientWidth === 0)
+        return {};
+    const computed = getComputedStyle(textarea);
+    const mirror = document.createElement('div');
+    for (const property of ['font', 'letter-spacing', 'word-spacing', 'line-height', 'text-indent', 'padding', 'tab-size', 'word-break', 'overflow-wrap', 'direction']) {
+        mirror.style.setProperty(property, computed.getPropertyValue(property));
+    }
+    mirror.style.position = 'fixed';
+    mirror.style.visibility = 'hidden';
+    mirror.style.pointerEvents = 'none';
+    mirror.style.whiteSpace = 'pre-wrap';
+    mirror.style.overflowWrap = 'break-word';
+    mirror.style.boxSizing = 'border-box';
+    mirror.style.width = `${textarea.clientWidth}px`;
+    const text = document.createTextNode(textarea.value);
+    mirror.append(text, document.createTextNode('\u200b'));
+    document.body.append(mirror);
+    try {
+        function lineAt(offset) {
+            const range = document.createRange();
+            range.setStart(text, offset);
+            range.setEnd(text, offset);
+            return range.getBoundingClientRect().top;
+        }
+        const first = lineAt(0);
+        const last = lineAt(text.length);
+        // Both selection endpoints must be on the boundary visual line. Selecting across soft
+        // wraps should stay native just like selecting across explicit newline characters.
+        const start = lineAt(textarea.selectionStart);
+        const end = lineAt(textarea.selectionEnd);
+        return { firstLine: Math.abs(start - first) < 1 && Math.abs(end - first) < 1, lastLine: Math.abs(start - last) < 1 && Math.abs(end - last) < 1 };
+    }
+    finally {
+        mirror.remove();
+    }
+}
+export function useComposerHistoryKeys({ composer, textareaRef }, { popupOpen = false } = {}) {
+    const pendingCaretRef = useRef(null);
+    // A duplicate history entry can equal the current value, so setDraft may bail out.
+    // Still commit the caret request now rather than carrying it into the next real edit.
+    const [, requestCaretCommit] = useReducer((revision) => revision + 1, 0);
+    useLayoutEffect(() => {
+        if (!pendingCaretRef.current)
+            return;
+        const placement = pendingCaretRef.current;
+        pendingCaretRef.current = null;
+        const textarea = textareaRef.current;
+        if (textarea) {
+            const offset = placement === 'start' ? 0 : textarea.value.length;
+            textarea.setSelectionRange(offset, offset);
+        }
+    });
+    return (event) => {
+        if (event.shiftKey || event.ctrlKey || event.altKey || event.metaKey)
+            return false;
+        if (event.defaultPrevented || popupOpen || event.nativeEvent.isComposing || event.nativeEvent.keyCode === 229)
+            return false;
+        if (!['ArrowUp', 'ArrowDown', 'Escape'].includes(event.key))
+            return false;
+        const textarea = event.currentTarget;
+        const handled = composer.history?.navigate({
+            key: event.key,
+            text: textarea.value,
+            selectionStart: textarea.selectionStart,
+            selectionEnd: textarea.selectionEnd,
+            shiftKey: event.shiftKey,
+            ctrlKey: event.ctrlKey,
+            altKey: event.altKey,
+            metaKey: event.metaKey,
+            ...visualLineBounds({ textarea }),
+        }) ?? false;
+        if (handled) {
+            event.preventDefault();
+            // React's controlled value lands on the following commit. Placing the caret before
+            // that commit clamps it to the OLD draft's length and breaks multiline Down gating.
+            // Up stays on the first line of even a multiline recall so repeated Up can browse
+            // older entries. Down/Escape go to the end, including when restoring the draft.
+            pendingCaretRef.current = event.key === 'ArrowUp' ? 'start' : 'end';
+            requestCaretCommit();
+            // Recalling an identical string may not cause a render; the existing value is safe.
+            const offset = pendingCaretRef.current === 'start' ? 0 : textarea.value.length;
+            textarea.setSelectionRange(offset, offset);
+        }
+        return handled;
+    };
+}
+//# sourceMappingURL=useComposerHistoryKeys.hooks.js.map

package/dist/react/hooks/useConversation.js

@@ -1,3 +1,4 @@
+import { preserveAssistantContent, mergeRunEvents } from '../../core/durable-projection.js';
 /**
  * @module useConversation
  *
@@ -113,8 +114,9 @@ export function useConversation(options) {
             return {
                 ...m,
                 ...(nextRunId !== undefined ? { runId: nextRunId } : {}),
-                events: run.events,
-                content: assistantContentFromEvents({ events: run.events }),
+                events: mergeRunEvents({ saved: m.events, incoming: run.events }, {}),
+                // Replayed completion prefixes cannot erase a saved interrupted segment.
+                content: preserveAssistantContent({ saved: m.content, incoming: assistantContentFromEvents({ events: run.events }) }, {}),
                 runStatus,
                 ...(isTerminalRunStatus({ status: runStatus }) ? { endedAt: Date.now() } : {}),
             };
@@ -160,6 +162,7 @@ export function useConversation(options) {
         setMessagesState((prev) => [...prev, userMessage, assistantMessage]);
         setScrollIntent(true);
         await run.start({
+            assistantMessageId: assistantMessage.id,
             history,
             ...(resolvedAgentId !== undefined ? { agentId: resolvedAgentId } : {}),
             conversationId,
@@ -191,6 +194,7 @@ export function useConversation(options) {
         // attachment beside the user turn, the failure reads as the model ignoring it rather than as
         // the client never having sent it.
         await run.start({
+            assistantMessageId: resetAssistant.id,
             history,
             ...(resolvedAgentId !== undefined ? { agentId: resolvedAgentId } : {}),
             conversationId,

package/dist/react/hooks/useRunStream.js

@@ -17,6 +17,7 @@
  * comparison can't do this — `start()`'s handlers must exist before the
  * transport's promise resolves with the real id).
  */
+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);
@@ -77,6 +78,15 @@ export function useRunStream({ transport }) {
     const makeHandlers = useCallback((generation) => {
         const isStale = () => generationRef.current !== generation;
         return {
+            onCheckpoint: (message) => {
+                if (isStale())
+                    return;
+                const statuses = { queued: 'streaming', running: 'streaming', succeeded: 'done', failed: 'error', canceled: 'canceled' };
+                setState((prev) => ({ ...prev, runId: message.runId ?? prev.runId,
+                    status: message.runStatus ? statuses[message.runStatus] : prev.status,
+                    events: mergeRunEvents({ saved: prev.events, incoming: message.events ?? [] }, {}),
+                }));
+            },
             onEvent: (ev) => {
                 if (isStale())
                     return;
@@ -93,12 +103,12 @@ export function useRunStream({ transport }) {
             onError: (err) => {
                 if (isStale())
                     return;
-                setState((prev) => ({ ...prev, status: 'error', error: err }));
+                setState((prev) => ({ ...prev, status: 'error', error: err, events: [...prev.events, { kind: 'status', code: 'run_terminal', label: err.message }] }));
             },
             onDone: (finalEvents) => {
                 if (isStale())
                     return;
-                setState((prev) => ({ ...prev, status: prev.status === 'error' ? prev.status : 'done', events: finalEvents }));
+                setState((prev) => ({ ...prev, status: prev.status === 'error' || prev.status === 'canceled' ? prev.status : 'done', events: mergeRunEvents({ saved: prev.events, incoming: finalEvents }, {}) }));
             },
         };
     }, []);

package/dist/react/index.d.ts

@@ -163,4 +163,6 @@ export type { JiniChatProviderProps, JiniChatSlots } from './components/JiniChat
 export { createFrontendSessionBridge } from './agent-bridge/frontend-session-bridge.js';
 export type { FrontendSessionBridge, FrontendSessionBridgeArgs, FrontendSessionBridgeOptions, } from './agent-bridge/frontend-session-bridge.js';
 export { createDomPageDriver, currentAgentPage, type DomPageDriverOptions } from '@jini-ai/agentic/dom';
+export { createBrowserComposerHistoryStorage } from './hooks/composer-history-storage.js';
+export type { ComposerHistoryStoragePort } from '../core/composer-history.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/react/index.js

@@ -121,4 +121,5 @@ export { JiniChatProvider, useJiniChatSlots, useOnFeedback } from './components/
  */
 export { createFrontendSessionBridge } from './agent-bridge/frontend-session-bridge.js';
 export { createDomPageDriver, currentAgentPage } from '@jini-ai/agentic/dom';
+export { createBrowserComposerHistoryStorage } from './hooks/composer-history-storage.js';
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/chat",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Jini's chat/artifact frontend, consolidated into one package with two subpaths: framework-free chat vocabulary and pure parsers in `/core`, headless hooks + presentational components + slots in `/react`. Import only the layer you need.",
   "license": "Apache-2.0",
   "repository": {
@@ -145,10 +145,10 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@jini-ai/agentic": "^0.4.2",
+    "@jini-ai/protocol": "^0.4.1",
+    "@jini-ai/core": "^0.4.1",
     "@jini-ai/ui": "^0.4.4",
-    "@jini-ai/protocol": "^0.4.0",
-    "@jini-ai/core": "^0.4.1"
+    "@jini-ai/agentic": "^0.4.2"
   },
   "peerDependencies": {
     "react": "^18.3.0 || ^19.0.0",
@@ -238,8 +238,8 @@
     "@electric-sql/pglite": "0.5.8",
     "pg": "8.23.0",
     "@ag-ui/core": "0.0.58",
-    "@jini-ai/db": "0.3.0",
-    "@jini-ai/agent-runtime": "0.4.0"
+    "@jini-ai/agent-runtime": "0.4.1",
+    "@jini-ai/db": "0.3.0"
   },
   "typesVersions": {
     "*": {