@jini-ai/chat 0.5.6 → 0.5.7

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

@@ -24,5 +24,7 @@ export declare function terminalMessageNotice({ message }: {
  * visible text can justify a Continued divider; the recovery marker still records the attempt. */
 export declare function recoveredRunEvents({ saved }: {
     saved: readonly AgentEvent[];
-}, _optional?: {}): AgentEvent[];
+}, { notice }?: {
+    notice?: 'visible' | 'silent';
+}): AgentEvent[];
 //# sourceMappingURL=durable-projection.d.ts.map

package/dist/core/durable-projection.js

@@ -1,4 +1,4 @@
-function identity(event) {
+function identity(event, usageOccurrences) {
     const wire = event;
     if (wire.eventId !== undefined)
         return `event:${wire.eventId}`;
@@ -8,7 +8,15 @@ function identity(event) {
         return `use:${event.id}`;
     if (event.kind === 'tool_result')
         return `result:${event.toolUseId}`;
-    return JSON.stringify(event);
+    const snapshot = JSON.stringify(event);
+    if (event.kind === 'usage') {
+        // Two segments can have identical counters. Match occurrence-for-occurrence during replay,
+        // rather than treating equal charges as the same event and silently dropping one segment.
+        const occurrence = (usageOccurrences.get(snapshot) ?? 0) + 1;
+        usageOccurrences.set(snapshot, occurrence);
+        return `usage:${snapshot}:${occurrence}`;
+    }
+    return snapshot;
 }
 function textOf(events) {
     return events.filter((event) => event.kind === 'text').map((event) => event.text).join('');
@@ -18,7 +26,9 @@ function textOf(events) {
 export function mergeRunEvents({ saved, incoming }, _optional = {}) {
     const previous = saved ?? [];
     const result = [...previous];
-    const keys = new Set(previous.map(identity));
+    const savedUsage = new Map();
+    const incomingUsage = new Map();
+    const keys = new Set(previous.map(event => identity(event, savedUsage)));
     const before = textOf(previous);
     const after = textOf(incoming);
     let skip = after.startsWith(before) ? before.length : after.length;
@@ -29,9 +39,12 @@ export function mergeRunEvents({ saved, incoming }, _optional = {}) {
             if (text)
                 result.push({ ...event, text });
         }
-        else if (!keys.has(identity(event))) {
-            keys.add(identity(event));
-            result.push(event);
+        else {
+            const key = identity(event, incomingUsage);
+            if (!keys.has(key)) {
+                keys.add(key);
+                result.push(event);
+            }
         }
     }
     return result;
@@ -44,6 +57,9 @@ export function continuingRunNotice({ events, active }, _optional = {}) {
     const marker = list.findLastIndex((event) => event.kind === 'status' && event.code === 'run_recovering');
     if (marker < 0)
         return null;
+    const markerEvent = list[marker];
+    if (markerEvent?.kind === 'status' && markerEvent.label === '')
+        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…';
 }
@@ -63,7 +79,24 @@ export function terminalMessageNotice({ message }, _optional = {}) {
 }
 /** 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 = {}) {
+export function recoveredRunEvents({ saved }, { notice = 'visible' } = {}) {
+    if (notice === 'silent') {
+        // A missing rollout is an expected reconstruction fallback, not a failed user turn. Keep an
+        // invisible attempt marker for fencing/diagnostic offsets, and preserve all unrelated work.
+        const attemptStart = saved.findLastIndex(event => event.kind === 'status' && event.code === 'run_recovering') + 1;
+        const diagnostic = saved.findIndex((event, index) => index >= attemptStart && ((event.kind === 'status' && /no rollout found for thread id/.test(`${event.label}\n${event.detail ?? ''}`)) ||
+            (event.kind === 'raw' && /no rollout found for thread id/.test(event.line))));
+        const events = saved.filter((event, index) => {
+            if (diagnostic < 0 || index < attemptStart)
+                return true;
+            if (event.kind === 'raw')
+                return !/no rollout found for thread id/.test(event.line);
+            if (event.kind === 'status')
+                return event.label !== 'Run failed — the agent process exited without answering' && !/no rollout found for thread id/.test(`${event.label}\n${event.detail ?? ''}`);
+            return true;
+        });
+        return [...events, { kind: 'status', code: 'run_recovering', label: '' }];
+    }
     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…' }];

package/dist/core/index.d.ts

@@ -8,6 +8,7 @@ export * from './messages.js';
 export * from './partial-json.js';
 export * from './tool-events.js';
 export * from './tool-output.js';
+export * from './tool-call-detail.js';
 export * from './transport.js';
 export * from './tools.js';
 export * from './todos.js';

package/dist/core/index.js

@@ -8,6 +8,7 @@ export * from './messages.js';
 export * from './partial-json.js';
 export * from './tool-events.js';
 export * from './tool-output.js';
+export * from './tool-call-detail.js';
 export * from './transport.js';
 export * from './tools.js';
 export * from './todos.js';

package/dist/core/run-events/entry.d.ts

@@ -293,6 +293,15 @@ export interface RunFrameOutcome {
     readonly error?: Error;
     readonly terminal?: Extract<ChatRunStatus, "succeeded" | "failed" | "canceled">;
 }
+/**
+ * Per-connection memory for {@link translateRunFrame}: which channels are mid-way through an echo
+ * line. Only a line's first chunk carries the {@link ECHO_LINE} prefix, so without it the rest of a
+ * split `user` echo stays as `raw` — tool-result prose that durable recovery then reads as executor
+ * diagnostics. Pass one fresh `{}` per daemon connection (each connection replays from event 0).
+ */
+export interface RunFrameCarry {
+    openEchoChannels?: Set<string>;
+}
 /**
  * Translates one named daemon SSE frame (`event:` name plus raw `data:` text) into its effect on the
  * turn. The browser's `subscribeToRun` dispatches the result to `RunHandlers`; the server finalizer
@@ -309,5 +318,7 @@ export declare function translateRunFrame({ kind, raw, notices }: {
     kind: string;
     raw: string | undefined;
     notices: RunNotices;
-}, _options?: Record<string, never>): RunFrameOutcome;
+}, { carry }?: {
+    carry?: RunFrameCarry;
+}): RunFrameOutcome;
 //# sourceMappingURL=entry.d.ts.map

package/dist/core/run-events/entry.js

@@ -439,19 +439,30 @@ function heartbeatStatus(line) {
 const ECHO_LINE = /^\{"type":"(?:stream_event|assistant|user)"/;
 /**
  * One CLI stdout/stderr chunk → events. Every JSON line that is a heartbeat also yields a typed
- * `status` event; echo lines ({@link ECHO_LINE}) are dropped; everything else stays in ONE `raw`
- * event, verbatim. A chunk with no JSON lines at all (a plain-format CLI) is one `raw` event, as before.
+ * `status` event; echo lines ({@link ECHO_LINE}) are dropped — with a `carry`, including the later
+ * chunks of a split one; everything else stays in ONE `raw` event, verbatim. A chunk with no JSON
+ * lines at all (a plain-format CLI) is one `raw` event, as before.
  */
-function chunkEvent(raw) {
+function chunkEvent(raw, channel, carry) {
     const frame = parseWire(raw);
     if (!frame)
         return [];
     const chunk = wireString(frame.payload?.chunk);
+    const open = carry ? (carry.openEchoChannels ??= new Set()) : undefined;
     const statuses = [];
     let kept = "";
     let droppedAny = false;
+    let first = true;
     for (const piece of chunk.split(/(?<=\n)/)) {
-        if (ECHO_LINE.test(piece.trimStart())) {
+        // Only a chunk's first piece can continue the previous chunk's line; splitting on "\n" starts
+        // every later piece on a fresh line. Channels are tracked apart: stderr can interleave mid-line.
+        const echo = (first && open?.has(channel) === true) || ECHO_LINE.test(piece.trimStart());
+        first = false;
+        if (echo && !piece.endsWith("\n"))
+            open?.add(channel);
+        else
+            open?.delete(channel);
+        if (echo) {
             droppedAny = true;
             continue;
         }
@@ -497,7 +508,7 @@ function endOutcome(raw, notices) {
 // where the daemon's plain pre-spawn reason ("The assistant could not start: ...") and the
 // host's start refusals reach the user.
 /** Fold one named daemon frame into events, a failure and an optional terminal status. */
-export function translateRunFrame({ kind, raw, notices }, _options = {}) {
+export function translateRunFrame({ kind, raw, notices }, { carry } = {}) {
     switch (kind) {
         case "agent": {
             const frame = parseWire(raw);
@@ -506,7 +517,7 @@ export function translateRunFrame({ kind, raw, notices }, _options = {}) {
         }
         case "stdout":
         case "stderr":
-            return { events: chunkEvent(raw) };
+            return { events: chunkEvent(raw, kind, carry) };
         case "error": {
             const frame = parseWire(raw);
             const message = wireString(frame?.payload?.message) || "agent run failed";

package/dist/core/tool-call-detail.d.ts

@@ -0,0 +1,36 @@
+import { type RedactUserText } from './user-text-redaction.js';
+/** The note keys a row shows instead of (or beside) a result. English text doubles as the i18n key, as everywhere else in this package. */
+export type ToolCallDetailNote = 'Waiting for the result or answer…' | 'No result was recorded for this call.' | 'The run ended before this call returned a result.' | 'Finished with no output.' | 'Failed without an error message.';
+export interface ToolCallDetail {
+    /** The call's input, pretty-printed and redacted; `null` when there is none or it cannot be serialized. */
+    readonly inputText: string | null;
+    /** The result's text, re-indented when JSON and redacted; `null` when there is no result text. */
+    readonly outputText: string | null;
+    /** Why there is no output, when there is none; `null` when the output says it all. */
+    readonly noteKey: ToolCallDetailNote | null;
+}
+export interface ToolCallDetailOptions {
+    readonly runStreaming?: boolean;
+    readonly runSucceeded?: boolean;
+    /** Per-block display cap; a longer input or output is cut with an ellipsis. Defaults to 10 000. */
+    readonly maxChars?: number;
+    /** Defaults to the chat text policy, so a tool call never shows a key the rest of the chat would hide. */
+    readonly redact?: RedactUserText;
+}
+/**
+ * Builds the readable detail for one tool call.
+ *
+ * @param required.input - The `tool_use` event's input, any shape.
+ * @param required.result - The paired `tool_result`, when one arrived.
+ * @param options - Run state that explains a missing result, the display cap, and the redactor.
+ * @returns Display-ready input and output text plus a note when the output is absent.
+ * @complexity O(n) in the serialized input plus result length.
+ */
+export declare function describeToolCallDetail({ input, result }: {
+    readonly input: unknown;
+    readonly result?: {
+        readonly content: string;
+        readonly isError?: boolean;
+    } | undefined;
+}, { runStreaming, runSucceeded, maxChars, redact }?: ToolCallDetailOptions): ToolCallDetail;
+//# sourceMappingURL=tool-call-detail.d.ts.map

package/dist/core/tool-call-detail.js

@@ -0,0 +1,49 @@
+/**
+ * The expanded body of a tool-call row: what the agent sent, what came back, and — when nothing
+ * came back — why. Shared by every card in `react/components/ToolCard.tsx` so no row kind (a CLI
+ * built-in like WebFetch, an unknown MCP tool, a card tool such as `assistant_ask_choice` still
+ * waiting on the person's answer) is left without a readable call.
+ */
+import { formatToolOutputForDisplay } from './tool-output.js';
+import { redactUserText } from './user-text-redaction.js';
+const DEFAULT_MAX_CHARS = 10_000;
+/**
+ * Builds the readable detail for one tool call.
+ *
+ * @param required.input - The `tool_use` event's input, any shape.
+ * @param required.result - The paired `tool_result`, when one arrived.
+ * @param options - Run state that explains a missing result, the display cap, and the redactor.
+ * @returns Display-ready input and output text plus a note when the output is absent.
+ * @complexity O(n) in the serialized input plus result length.
+ */
+export function describeToolCallDetail({ input, result }, { runStreaming = false, runSucceeded = false, maxChars = DEFAULT_MAX_CHARS, redact = redactUserText } = {}) {
+    const show = (text) => (text === null ? null : truncate(redact({ text: text }).text, maxChars));
+    const inputText = show(serializeInput(input));
+    if (!result)
+        return { inputText, outputText: null, noteKey: missingResultNote({ runStreaming, runSucceeded }) };
+    if (!result.content.trim())
+        return { inputText, outputText: null, noteKey: result.isError ? 'Failed without an error message.' : 'Finished with no output.' };
+    return { inputText, outputText: show(formatToolOutputForDisplay({ text: result.content })), noteKey: null };
+}
+function missingResultNote({ runStreaming, runSucceeded }) {
+    if (runStreaming)
+        return 'Waiting for the result or answer…';
+    return runSucceeded ? 'No result was recorded for this call.' : 'The run ended before this call returned a result.';
+}
+/** A string input is shown as given (re-indented only when it is itself a JSON object/array); anything else is pretty JSON, or `null` when it has no JSON form (circular, a function). */
+function serializeInput(input) {
+    if (input === null || input === undefined)
+        return null;
+    if (typeof input === 'string')
+        return formatToolOutputForDisplay({ text: input });
+    try {
+        return JSON.stringify(input, null, 2) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function truncate(text, max) {
+    return text.length <= max ? text : text.slice(0, max - 1) + '…';
+}
+//# sourceMappingURL=tool-call-detail.js.map

package/dist/core/turn-usage.d.ts

@@ -0,0 +1,11 @@
+import type { AgentEvent } from './events.js';
+type UsageEvent = Extract<AgentEvent, {
+    kind: 'usage';
+}>;
+/** Sum per-segment usage for the whole turn, including aborted segments and recovered attempts.
+ * Missing fields stay absent; monetary charges are never inferred. O(n) time, O(1) space. */
+export declare function turnUsage({ events }: {
+    events: readonly AgentEvent[] | undefined;
+}, _optional?: {}): UsageEvent | undefined;
+export {};
+//# sourceMappingURL=turn-usage.d.ts.map

package/dist/core/turn-usage.js

@@ -0,0 +1,17 @@
+/** Sum per-segment usage for the whole turn, including aborted segments and recovered attempts.
+ * Missing fields stay absent; monetary charges are never inferred. O(n) time, O(1) space. */
+export function turnUsage({ events }, _optional = {}) {
+    let total;
+    for (const event of events ?? []) {
+        if (event.kind !== 'usage')
+            continue;
+        total ??= { kind: 'usage' };
+        for (const field of ['inputTokens', 'outputTokens', 'costUsd', 'durationMs']) {
+            const value = event[field];
+            if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
+                total[field] = (total[field] ?? 0) + value;
+        }
+    }
+    return total;
+}
+//# sourceMappingURL=turn-usage.js.map

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

@@ -16,6 +16,6 @@
  * `@deprecated`, so every existing `import { ChatPane } from '@jini-ai/chat/react'` keeps working
  * unchanged. New code should import from this subpath directly.
  */
-export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './features/chat-pane/index.js';
-export type { AgentRuntimePickerProps, ByokRuntimeSummary, ChatPaneActivity, ChatPaneAgent, ChatPaneAgentBridgeAccess, ChatPaneAgentControlOptions, ChatPaneAgentOption, ChatPaneAgentSelection, ChatPaneAgentToolAction, ChatPaneAgentToolDef, ChatPaneAgentToolInputSchema, ChatPaneAgentToolRisk, ChatPaneAttachmentUploadOptions, ChatPaneComposerHandle, ChatPaneProps, ChatPaneRunContext, ChatPaneRunContextInput, ChatPaneRuntimeAccess, ChatPaneVariant, ChatPaneWorkingDirectoryAccess, CreateDaemonAttachmentUploaderOptions, CreateMcpUiToolCallerOptions, CreateTypedAnswerPosterOptions, DeliverTypedAnswer, McpUiToolCallRequest, RuntimePickerPlacement, TypedAnswerDelivery, TypedAnswerNotice, UseChatPaneAgentControlOptions, UseChatPaneOptions, UseChatPaneResult, UseChatPaneRuntimeInventoryOptions, UseChatPaneRuntimeInventoryResult, UseChatPaneWorkingDirectoryOptions, UseChatPaneWorkingDirectoryResult, } from './features/chat-pane/index.js';
+export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createMidRunMessagePoster, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './features/chat-pane/index.js';
+export type { AgentRuntimePickerProps, ByokRuntimeSummary, ChatPaneActivity, ChatPaneAgent, ChatPaneAgentBridgeAccess, ChatPaneAgentControlOptions, ChatPaneAgentOption, ChatPaneAgentSelection, ChatPaneAgentToolAction, ChatPaneAgentToolDef, ChatPaneAgentToolInputSchema, ChatPaneAgentToolRisk, ChatPaneAttachmentUploadOptions, ChatPaneComposerHandle, ChatPaneProps, ChatPaneRunContext, ChatPaneRunContextInput, ChatPaneRuntimeAccess, ChatPaneVariant, ChatPaneWorkingDirectoryAccess, CreateDaemonAttachmentUploaderOptions, CreateMcpUiToolCallerOptions, CreateMidRunMessagePosterOptions, CreateTypedAnswerPosterOptions, DeliverMidRunMessage, DeliverTypedAnswer, McpUiToolCallRequest, MidRunMessageDelivery, RuntimePickerPlacement, TypedAnswerDelivery, TypedAnswerNotice, UseChatPaneAgentControlOptions, UseChatPaneOptions, UseChatPaneResult, UseChatPaneRuntimeInventoryOptions, UseChatPaneRuntimeInventoryResult, UseChatPaneWorkingDirectoryOptions, UseChatPaneWorkingDirectoryResult, } from './features/chat-pane/index.js';
 //# sourceMappingURL=chat-pane.d.ts.map

package/dist/react/chat-pane.js

@@ -16,5 +16,5 @@
  * `@deprecated`, so every existing `import { ChatPane } from '@jini-ai/chat/react'` keeps working
  * unchanged. New code should import from this subpath directly.
  */
-export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './features/chat-pane/index.js';
+export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, createMidRunMessagePoster, createTypedAnswerPoster, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './features/chat-pane/index.js';
 //# sourceMappingURL=chat-pane.js.map

package/dist/react/components/Composer.d.ts

@@ -19,6 +19,8 @@ export interface ComposerProps {
      * separately placed cancel affordance elsewhere in the pane. Always clickable when true,
      * regardless of `disabled`/`sendDisabled`/`composer.canSubmit`: those all gate *submitting a new
      * draft*, which has nothing to do with whether a caller may cancel the run already in flight.
+     * Once the draft is submittable (and neither gate refuses it), Send comes back beside Stop, so a
+     * message can go out mid-run without stopping anything.
      */
     running?: boolean;
     /** Cancels the in-flight run. Required when `running` is true; ignored otherwise. */

package/dist/react/components/Composer.js

@@ -338,7 +338,10 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
                     composer.setDraft(e.target.value);
                     setSlashActiveIndex(0);
                     setDismissedSlashDraft(null);
-                }, onKeyDown: handleKeyDown, onPaste: handleAttachmentPaste, "aria-controls": slashOpen ? 'jini-composer-slash-menu' : undefined, "aria-expanded": slashOpen, "aria-activedescendant": slashOpen
+                }, onKeyDown: handleKeyDown, 
+                // Draft persistence is debounced (see `DRAFT_PERSIST_DEBOUNCE_MS`); leaving the field is a
+                // natural point to make it durable now.
+                onBlur: () => composer.flushDraft?.(), onPaste: handleAttachmentPaste, "aria-controls": slashOpen ? 'jini-composer-slash-menu' : undefined, "aria-expanded": slashOpen, "aria-activedescendant": slashOpen
                     ? `jini-composer-slash-option-${Math.min(slashActiveIndex, slashMatches.length - 1)}`
                     : undefined, rows: 3 }), slashOpen ? (_jsx(ComposerSlashMenu, { matches: slashMatches, activeIndex: Math.min(slashActiveIndex, slashMatches.length - 1), onSelect: (item) => selectSlashItem(slashMatches.findIndex((match) => match.item === item)), showFilterHint: showSlashFilterHint, style: slashMenuPosition, t: t })) : null, _jsxs("div", { className: "jini-composer-footer", children: [attachmentPicker && !hasDiscoveryItems ? (_jsxs("div", { className: "jini-composer-attachment-picker", children: [_jsx("input", { ref: attachmentInputRef, className: "jini-composer-file-input", "data-testid": "composer-attachment-input", type: "file", multiple: true, "aria-label": t('Attach files'), accept: attachmentPicker.accept, disabled: disabled || attachmentPicker.uploading, onChange: handleAttachmentChange }), _jsx("button", { type: "button", className: "jini-composer-attach", disabled: disabled || attachmentPicker.uploading, onClick: () => attachmentInputRef.current?.click(), title: t(attachmentPicker.uploading ? 'Attaching files…' : 'Attach files'), "aria-label": t(attachmentPicker.uploading ? 'Attaching files…' : 'Attach files'), children: _jsx(RemixIcon, { name: attachmentPicker.uploading ? 'refresh-line' : 'add-line', size: 20, ...(attachmentPicker.uploading ? { className: 'jini-composer-spinner' } : {}) }) })] })) : null, hasDiscoveryItems ? (_jsx(ComposerDiscoveryMenu, { groups: discoveryGroups, open: discoveryMenuOpen, disabled: disabled, ...(attachmentPicker ? { attachmentPicker } : {}), attachmentInputRef: attachmentInputRef, onToggle: () => setDiscoveryMenuOpen((open) => !open), onClose: () => setDiscoveryMenuOpen(false), onSelect: selectPlusItem, onAttachmentChange: handleAttachmentChange, style: discoveryMenuPosition, t: t })) : null, slots?.footerLeadingAccessory ? (_jsx("div", { className: "jini-composer-footer-leading", children: slots.footerLeadingAccessory })) : null, onChangeWorkingDirectory || onPickWorkingDirectory ? (_jsxs("div", { className: "jini-composer-workdir", "data-testid": "composer-workdir", children: [_jsx("button", { type: "button", className: "jini-composer-attach", "data-testid": "composer-workdir-trigger", disabled: disabled, onClick: onPickWorkingDirectory ? () => onPickWorkingDirectory() : toggleWorkdir, ...(onPickWorkingDirectory ? {} : { 'aria-haspopup': 'dialog', 'aria-expanded': workdirOpen }), title: workingDirectory ?? t('Set working directory'), "aria-label": workingDirectory
                                     ? t('Working directory: {dir}', { dir: workingDirectory })
@@ -351,6 +354,6 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
                                                 e.preventDefault();
                                                 setWorkdirOpen(false);
                                             }
-                                        }, placeholder: t('Working directory path'), "aria-label": t('Working directory path'), autoFocus: true }), _jsx("button", { type: "button", className: "jini-composer-workdir-confirm", "data-testid": "composer-workdir-confirm", onClick: confirmWorkdir, children: t('Set') })] })) : null] })) : null, slots?.footerAccessories ? (_jsx("div", { className: "jini-composer-footer-accessories", children: slots.footerAccessories })) : null, slots?.plusMenuItems && slots.plusMenuItems.length > 0 ? (_jsx("div", { className: "jini-composer-plus-menu", children: slots.plusMenuItems.map((item) => (_jsxs("button", { type: "button", className: "jini-composer-plus-item", onClick: () => runComposerHostEffect('plusMenuItems.onSelect', () => item.onSelect()), title: t(item.label), children: [item.icon ?? null, _jsx("span", { children: t(item.label) })] }, item.id))) })) : null, running ? (_jsx("button", { type: "button", className: "jini-composer-send jini-composer-send--stop", onClick: onCancel, title: t('Stop run'), "aria-label": t('Stop run'), children: _jsx(RemixIcon, { name: "stop-fill", size: 14 }) })) : (_jsx("button", { type: "button", className: "jini-composer-send", disabled: disabled || sendDisabled || !composer.canSubmit, onClick: onSend, title: t('Send'), "aria-label": t('Send'), children: _jsx(RemixIcon, { name: "send-plane-2-line", size: 16 }) }))] })] }));
+                                        }, placeholder: t('Working directory path'), "aria-label": t('Working directory path'), autoFocus: true }), _jsx("button", { type: "button", className: "jini-composer-workdir-confirm", "data-testid": "composer-workdir-confirm", onClick: confirmWorkdir, children: t('Set') })] })) : null] })) : null, slots?.footerAccessories ? (_jsx("div", { className: "jini-composer-footer-accessories", children: slots.footerAccessories })) : null, slots?.plusMenuItems && slots.plusMenuItems.length > 0 ? (_jsx("div", { className: "jini-composer-plus-menu", children: slots.plusMenuItems.map((item) => (_jsxs("button", { type: "button", className: "jini-composer-plus-item", onClick: () => runComposerHostEffect('plusMenuItems.onSelect', () => item.onSelect()), title: t(item.label), children: [item.icon ?? null, _jsx("span", { children: t(item.label) })] }, item.id))) })) : null, _jsxs("span", { className: "jini-composer-send-group", children: [!running || (!disabled && !sendDisabled && composer.canSubmit) ? (_jsx("button", { type: "button", className: "jini-composer-send", disabled: disabled || sendDisabled || !composer.canSubmit, onClick: onSend, title: t('Send'), "aria-label": t('Send'), children: _jsx(RemixIcon, { name: "send-plane-2-line", size: 16 }) })) : null, running ? (_jsx("button", { type: "button", className: "jini-composer-send jini-composer-send--stop", onClick: onCancel, title: t('Stop run'), "aria-label": t('Stop run'), children: _jsx(RemixIcon, { name: "stop-fill", size: 14 }) })) : null] })] })] }));
 }
 //# sourceMappingURL=Composer.js.map

package/dist/react/components/Markdown.js

@@ -389,16 +389,16 @@ const INLINE_RE = new RegExp(String.raw `(\x60[^\x60]+\x60)|(${MD_LINK})|(\*\*[^
 // Only these targets become anchors; anything else (`javascript:`, `data:`, protocol-relative
 // `//host`) stays literal text, since the text is untrusted model output.
 const SAFE_LINK_HREF = /^(?:https?:\/\/|mailto:|\/(?!\/)|#)/iu;
-// Off-site links open in a new tab; a same-origin path stays in the tab so the host's in-app link
-// interceptor (an SPA router) can take it without a reload.
-const OFFSITE_LINK_HREF = /^(?:https?:|mailto:)/iu;
+// Every link opens in a new tab — an in-app path too, so following one never navigates the tab the
+// chat lives in (owner 2026-10-08). Only a `#` same-document anchor stays in place. ChatPane's
+// click guard (`useChatPaneNewTabLinks`) covers links this renderer does not draw.
+const NEW_TAB = { target: '_blank', rel: 'noopener noreferrer' };
 function renderMarkdownLink(source, key) {
     // `MD_LINK` already matched `source`, so these two groups always capture.
     const [, label, href] = MD_LINK_PARTS.exec(source);
     if (!SAFE_LINK_HREF.test(href))
         return source;
-    const offsite = OFFSITE_LINK_HREF.test(href);
-    return (_jsx("a", { href: href, ...(offsite ? { target: '_blank', rel: 'noreferrer' } : {}), children: renderInline(label) }, key));
+    return (_jsx("a", { href: href, ...(href.startsWith('#') ? {} : NEW_TAB), children: renderInline(label) }, key));
 }
 function renderInline(text) {
     const nodes = [];
@@ -421,7 +421,7 @@ function renderInline(text) {
         else if (italic)
             nodes.push(_jsx("em", { children: italic.slice(1, -1) }, key++));
         else if (link)
-            nodes.push(_jsx("a", { href: link, target: "_blank", rel: "noreferrer", children: link }, key++));
+            nodes.push(_jsx("a", { href: link, ...NEW_TAB, children: link }, key++));
         // `whole` is `match[0]` — a successful `RegExpExecArray` always has a
         // defined (if possibly empty) full-match string at index 0, so this
         // fallback is unreachable (same dead-fallback reasoning as above).

package/dist/react/components/MessageList.d.ts

@@ -1,14 +1,3 @@
-/**
- * @module MessageList
- *
- * Renders a conversation's messages via `<MessageRow>`, and — matching
- * `useConversation`'s `scrollIntent` flag (see
- * `ADS-memory/reports/jini-port/recon/r4b-webui-design.md` §4: "message array, optimistic
- * user message, scroll-intent flag") — auto-scrolls to the newest content
- * whenever `scrollIntent` is true, calling `onScrolled` once it has. The
- * scroll-anchoring state lives in `useMessageListAutoScroll`
- * (`MessageList.hooks.ts`); see that file for why it is presentational.
- */
 import type { ChatMessage } from '../../core/index.js';
 import { type MessageRowProps } from './MessageRow.js';
 export interface MessageListProps extends Pick<MessageRowProps, 'projectFileNames' | 'onRequestOpenFile' | 'renderAttachment'> {
@@ -35,5 +24,11 @@ export interface MessageListProps extends Pick<MessageRowProps, 'projectFileName
         onCancel: () => void;
     } | null;
 }
-export declare function MessageList({ messages, isStreaming, scrollIntent, onScrolled, activeQuestionFormMessageId, questionFormSubmittedAnswersByMessageId, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, renderAttachment, pendingPrompt, }: MessageListProps): import("react").JSX.Element;
+/**
+ * Memoized: the pane re-renders on every composer keystroke, and re-rendering a long transcript
+ * (hundreds of tool rows, MCP-UI cards, markdown) per key made typing lag (owner report
+ * 2026-10-08). Callers must pass stable props — `ChatPane` memoizes `pendingPrompt` and
+ * `projectFileNames` for exactly this.
+ */
+export declare const MessageList: import("react").NamedExoticComponent<MessageListProps>;
 //# sourceMappingURL=MessageList.d.ts.map

package/dist/react/components/MessageList.js

@@ -1,9 +1,27 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @module MessageList
+ *
+ * Renders a conversation's messages via `<MessageRow>`, and — matching
+ * `useConversation`'s `scrollIntent` flag (see
+ * `ADS-memory/reports/jini-port/recon/r4b-webui-design.md` §4: "message array, optimistic
+ * user message, scroll-intent flag") — auto-scrolls to the newest content
+ * whenever `scrollIntent` is true, calling `onScrolled` once it has. The
+ * scroll-anchoring state lives in `useMessageListAutoScroll`
+ * (`MessageList.hooks.ts`); see that file for why it is presentational.
+ */
+import { memo } from 'react';
 import { isTerminalRunStatus } from '../../core/index.js';
 import { useT } from '../hooks/context.js';
 import { useMessageListAutoScroll } from './MessageList.hooks.js';
 import { MessageRow } from './MessageRow.js';
-export function MessageList({ messages, isStreaming = false, scrollIntent = false, onScrolled, activeQuestionFormMessageId = null, questionFormSubmittedAnswersByMessageId, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, renderAttachment, pendingPrompt = null, }) {
+/**
+ * Memoized: the pane re-renders on every composer keystroke, and re-rendering a long transcript
+ * (hundreds of tool rows, MCP-UI cards, markdown) per key made typing lag (owner report
+ * 2026-10-08). Callers must pass stable props — `ChatPane` memoizes `pendingPrompt` and
+ * `projectFileNames` for exactly this.
+ */
+export const MessageList = memo(function MessageList({ messages, isStreaming = false, scrollIntent = false, onScrolled, activeQuestionFormMessageId = null, questionFormSubmittedAnswersByMessageId, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, renderAttachment, pendingPrompt = null, }) {
     const t = useT();
     const { containerRef, onScroll } = useMessageListAutoScroll({ messages, scrollIntent }, onScrolled !== undefined ? { onScrolled } : {});
     return (_jsxs("div", { className: "jini-message-list", ref: containerRef, onScroll: onScroll, "data-agent-element": "chat-transcript", "data-agent-role": "list", "data-agent-label": "The conversation transcript, oldest message first", children: [messages.map((message) => {
@@ -11,5 +29,5 @@ export function MessageList({ messages, isStreaming = false, scrollIntent = fals
                 const runStreaming = isLast && isStreaming && !isTerminalRunStatus({ status: message.runStatus });
                 return (_jsx(MessageRow, { message: message, runStreaming: runStreaming, runSucceeded: message.runStatus === 'succeeded', questionFormInteractive: message.id === activeQuestionFormMessageId, ...(questionFormSubmittedAnswersByMessageId?.[message.id] !== undefined ? { questionFormSubmittedAnswers: questionFormSubmittedAnswersByMessageId[message.id] } : {}), ...(onQuestionFormSubmit !== undefined ? { onQuestionFormSubmit: (text, answers) => onQuestionFormSubmit(message.id, text, answers) } : {}), ...(projectFileNames !== undefined ? { projectFileNames } : {}), ...(onRequestOpenFile !== undefined ? { onRequestOpenFile } : {}), ...(renderAttachment !== undefined ? { renderAttachment } : {}) }, message.id));
             }), pendingPrompt ? (_jsxs("div", { className: "jini-chat-pane__queued", role: "status", "aria-label": t('Message queued — not yet sent, will send once the current run finishes'), "data-testid": "chat-pane-queued", "data-agent-element": "chat-message-pending", "data-agent-role": "region", "data-agent-label": "A message queued to send once the current run finishes", children: [_jsx("div", { className: "jini-chat-pane__queued-text", children: pendingPrompt.text }), _jsx("div", { className: "jini-chat-pane__queued-actions", children: _jsx("button", { type: "button", className: "jini-chat-pane__queued-cancel", onClick: pendingPrompt.onCancel, title: t('Cancel queued message'), children: t('Cancel') }) })] })) : null] }));
-}
+});
 //# sourceMappingURL=MessageList.js.map

package/dist/react/components/MessageRow.d.ts

@@ -64,5 +64,10 @@ export interface MessageRowProps {
     /** Host-supplied renderer for a `ChatAttachment` chip. Falls back to a plain filename chip. */
     renderAttachment?: (attachment: ChatAttachment) => ReactNode;
 }
-export declare function MessageRow({ message, runStreaming, runSucceeded, questionFormInteractive, questionFormSubmittedAnswers, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, renderAttachment, }: MessageRowProps): React.JSX.Element;
+/**
+ * Memoized so a transcript re-render (a streaming update to the newest message, or a parent that
+ * re-renders per composer keystroke) only re-renders rows whose props actually changed. Messages
+ * are replaced, never mutated, so identity is a sound change signal.
+ */
+export declare const MessageRow: React.NamedExoticComponent<MessageRowProps>;
 //# sourceMappingURL=MessageRow.d.ts.map

package/dist/react/components/MessageRow.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { terminalMessageNotice, continuingRunNotice } from '../../core/durable-projection.js';
+import { turnUsage } from '../../core/turn-usage.js';
 /**
  * @module MessageRow
  *
@@ -50,7 +51,7 @@ import { terminalMessageNotice, continuingRunNotice } from '../../core/durable-p
  * not appear until the whole message is done, not merely until its current
  * chunk stopped arriving.
  */
-import React, { useState } from 'react';
+import React, { memo, useState } from 'react';
 import { isAwaitingAnswer, isTerminalRunStatus, splitOnQuestionForms, stripArtifact } from '../../core/index.js';
 import { useToolTimeline } from '../hooks/useToolTimeline.js';
 import { useExtEventGroups } from '../hooks/useExtEventGroups.js';
@@ -154,7 +155,12 @@ function CopyMessageButton({ text, label }) {
                     void copy(text);
                 }, children: _jsx(Icon, { name: copied ? 'check' : 'copy' }) }), _jsx("span", { className: "jini-message-copy-status", "aria-live": "polite", children: copied ? t('Copied to clipboard') : '' })] }));
 }
-export function MessageRow({ message, runStreaming = false, runSucceeded = false, questionFormInteractive = false, questionFormSubmittedAnswers, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, renderAttachment, }) {
+/**
+ * Memoized so a transcript re-render (a streaming update to the newest message, or a parent that
+ * re-renders per composer keystroke) only re-renders rows whose props actually changed. Messages
+ * are replaced, never mutated, so identity is a sound change signal.
+ */
+export const MessageRow = memo(function MessageRow({ message, runStreaming = false, runSucceeded = false, questionFormInteractive = false, questionFormSubmittedAnswers, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, renderAttachment, }) {
     const t = useT();
     const timeline = useToolTimeline({ events: message.events }, { runStreaming, runSucceeded });
     const extGroups = useExtEventGroups({ events: message.events }, { slotOf: (name, data) => extEventSlot({ name, data }) });
@@ -168,7 +174,7 @@ export function MessageRow({ message, runStreaming = false, runSucceeded = false
     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();
+    const usageEvent = turnUsage({ events: message.events }, {});
     const blocks = messageBlocks({ visibleContent, message, rows: timeline.rows }, {});
     const pending = isPendingWithNoContent(message, visibleContent, timeline.rows.length);
     const runInProgress = isRunInProgress(message.runStatus);
@@ -210,7 +216,7 @@ export function MessageRow({ message, runStreaming = false, runSucceeded = false
                     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] })), _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
  * old "Thinking…" placeholder, which vanished for good as soon as the first tool row appeared.

package/dist/react/components/MidRunUserMessage.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @module MidRunUserMessage
+ *
+ * Renders a message the human sent while a run was going (`ChatPane`'s `deliverMidRunMessage`) as a
+ * user bubble inside the running turn, at the point in the stream where the live agent received it.
+ * The daemon records each one as a `user_message` run event (`AgentExecutor.sendUserMessage`), which
+ * the run-event translator surfaces as `kind: 'ext'` with that name; this claims it.
+ *
+ * It is an event of the assistant turn, not a `ChatMessage` of its own, because the agent folded it
+ * into the turn it was already running — there is no separate reply to hang off it.
+ */
+import { type ExtEventRenderProps } from '../ext-event-renderer-registry.js';
+/** The ext-event name the daemon's mid-run `user_message` run event arrives under. */
+export declare const MID_RUN_USER_MESSAGE_EXT_EVENT_NAME = "user_message";
+/** One slot per message id, so each mid-run message renders where it arrived rather than folding into the first. */
+export declare function midRunUserMessageSlotKey({ data }: {
+    data: unknown;
+}): string | undefined;
+/** The bubble for one mid-run message — the same classes as a sent user message, so it reads as one. */
+export declare function MidRunUserMessage({ events }: Pick<ExtEventRenderProps, 'events'>): import("react").JSX.Element | null;
+/**
+ * Registers {@link MidRunUserMessage} against the ext-event registry.
+ *
+ * @returns An unregister handle, so a test or a hot reload can dispose cleanly.
+ */
+export declare function registerMidRunUserMessageRenderer(): () => void;
+//# sourceMappingURL=MidRunUserMessage.d.ts.map

package/dist/react/components/MidRunUserMessage.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @module MidRunUserMessage
+ *
+ * Renders a message the human sent while a run was going (`ChatPane`'s `deliverMidRunMessage`) as a
+ * user bubble inside the running turn, at the point in the stream where the live agent received it.
+ * The daemon records each one as a `user_message` run event (`AgentExecutor.sendUserMessage`), which
+ * the run-event translator surfaces as `kind: 'ext'` with that name; this claims it.
+ *
+ * It is an event of the assistant turn, not a `ChatMessage` of its own, because the agent folded it
+ * into the turn it was already running — there is no separate reply to hang off it.
+ */
+import { registerExtEventRenderer } from '../ext-event-renderer-registry.js';
+/** The ext-event name the daemon's mid-run `user_message` run event arrives under. */
+export const MID_RUN_USER_MESSAGE_EXT_EVENT_NAME = 'user_message';
+function field(data, key) {
+    const value = typeof data === 'object' && data !== null ? data[key] : undefined;
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}
+/** One slot per message id, so each mid-run message renders where it arrived rather than folding into the first. */
+export function midRunUserMessageSlotKey({ data }) {
+    return field(data, 'id');
+}
+/** The bubble for one mid-run message — the same classes as a sent user message, so it reads as one. */
+export function MidRunUserMessage({ events }) {
+    const text = field(events.at(-1), 'text');
+    if (text === undefined)
+        return null;
+    return (_jsx("div", { className: "jini-message jini-message-user jini-message-user--mid-run", "data-agent-role": "region", "data-agent-label": "A message from the user, sent while the agent was working", children: _jsx("div", { className: "jini-message-content", children: text }) }));
+}
+/**
+ * Registers {@link MidRunUserMessage} against the ext-event registry.
+ *
+ * @returns An unregister handle, so a test or a hot reload can dispose cleanly.
+ */
+export function registerMidRunUserMessageRenderer() {
+    return registerExtEventRenderer({ name: MID_RUN_USER_MESSAGE_EXT_EVENT_NAME, renderer: (props) => _jsx(MidRunUserMessage, { events: props.events }) }, { slotKey: midRunUserMessageSlotKey });
+}
+//# sourceMappingURL=MidRunUserMessage.js.map