@jini-ai/chat 0.6.7 → 0.6.10

package/CHANGELOG.md

@@ -1,3 +1,127 @@
+## 0.6.10
+
+### Patch Changes
+
+- f9d9894: Hide recovered tool failures when tool calls are hidden. Keep unrecovered failures in one compact, localized disclosure per reply, preserving their existing details.
+- 8ff5653: Make the chat-pane transcript readable from outside the component — a must-have for an AI (or an
+  e2e harness) verifying that commands it gave the pane (create a form, add a user, change a
+  permission) actually happened.
+
+  Before this, `<ChatPane>` fully encapsulated its conversation state: `useConversation()`'s
+  `messages` never left the component, `ChatPaneProps` had no callback that reported the live message
+  list, and the rendered transcript (`MessageList`/`MessageRow`/`ToolCard`) carried zero
+  `data-agent-element` tags — unlike every other interactive surface in this app's reference pages.
+
+  - `ChatPaneProps.onMessagesChange?: (messages: ChatMessage[]) => void` — fires with the full message
+    array on every change, mirroring the existing `onActivityChange` pattern. Each `ChatMessage`
+    already carries its `events` array (`tool_use`/`tool_result`), so a subscriber gets complete,
+    structured tool-call data for free — no DOM parsing needed.
+  - `data-agent-element="chat-transcript"` (role `list`) on the message-list container, and
+    `data-agent-element="chat-message-<id>"` (role `region`) on every message row, so `page.*` DOM
+    tools can enumerate the transcript the same way they read everything else in this app.
+  - `ToolCard` now wraps whatever it renders (any of its dozen built-in card variants, or a host's own
+    custom-registered renderer) in one `data-agent-element="tool-call-<use.id>"` (role `region`)
+    element — added at the single dispatch point every branch already funnels through, so no
+    individual card variant's own markup changed. The collapsed-by-default accordion detail (args/
+    result JSON) sits inside this tagged element, not gated behind expanding it: `textContent` (what
+    the `page.*` DOM driver actually reads) is layout-agnostic, so the full detail is readable whether
+    or not anything has been clicked open.
+
+- 3fe4d14: Add compatibility regression fixtures for legacy inline image results, media-only saved events and delegated echo notes; runtime behavior is unchanged.
+- 8ff5653: Add `createDaemonAttachmentUploader`, so composer drag-and-drop is one line instead of 160.
+
+  `ChatPane` has always gated its drop target and file picker on `uploadAttachments` being supplied — but
+  supplying it meant writing the client half yourself: a bounded-concurrency worker pool that preserves
+  input order, per-turn quota accounting, abort and timeout plumbing, and cleanup of files that already
+  landed when a later one fails. Every host would write the same ~160 lines, and the ordering and
+  cleanup details are exactly the ones that get skipped.
+
+  ```tsx
+  <ChatPane
+    transport={transport}
+    uploadAttachments={createDaemonAttachmentUploader(daemonUrl)}
+  />
+  ```
+
+  That talks to `@jini-ai/http-kit`'s `POST`/`DELETE /api/attachments`. Pass `''` when a dev-server proxy
+  already forwards `/api` from the page's own origin. `maxAttachmentBytes`, `maxAttachmentCount`,
+  `maxBatchBytes`, `timeoutMs`, and `concurrency` are all configurable and all default to the daemon side's
+  own limits, so the client's early rejection matches what the daemon would have said anyway.
+
+  Client-side quotas are a courtesy, never the boundary — telling a user their 400 MB video is too large
+  before the browser streams it, not after. The daemon re-derives every one of them.
+
+  Two behavioral notes for anyone porting hand-rolled code onto this:
+
+  - **The request always sends `content-type: application/octet-stream`**, not `file.type`. The daemon
+    sniffs the real kind from the bytes and ignores the header, so forwarding the browser's guess buys
+    nothing — and breaks real uploads: a dropped `.json` file arrives as `application/json`, which an
+    app-wide `express.json()` on the daemon then claims, draining the request stream before the upload
+    route can read a byte.
+  - **Batch accounting is per uploader instance**, not module-global, so two panes pointed at two daemons
+    cannot consume each other's per-turn quota. Reservations are rolled back on failure, so a retry of a
+    failed turn is not refused for quota it never actually used.
+
+- 72ea04d: Folded `@jini-ai/renderers-react` into `@jini-ai/ui` as an independently-importable, tree-shakeable
+  `./renderers` subpath, and retired the package.
+
+  Real (non-comment) imports of `@jini-ai/renderers-react` anywhere in the repo were exactly 3 files,
+  2 symbols, all inside `@jini-ai/ui`'s own `features/html-viewer` — `openSandboxedPreviewInNewTab`
+  and `useSandboxBridge`. `@jini-ai/ui` was already the package's only real consumer, so a standalone
+  package bought nothing, the same reasoning that folded `@jini-ai/ui-core` into `./core` and
+  `@jini-ai/composio` into `@jini-ai/admin`. The whole `src/**` tree (registry, renderers, srcDoc
+  host, annotation-canvas, preview-modal-shell, i18n) moves to `packages/ui/src/renderers/` as one
+  `git mv`, unchanged in shape; `html-viewer`'s two consumers switch from the package-qualified
+  import to a relative one, since they're now in the same package.
+
+  **The `@jini-ai/renderers-react → @jini-ai/chat` dependency was dropped first, before the move,
+  not after.** `registry.ts` imported `ArtifactManifest`/`inferLegacyManifest` from `@jini-ai/chat`,
+  and `types.ts` re-exported five manifest types from there. `@jini-ai/chat` already depends on
+  `@jini-ai/ui`, so folding renderers-react into `ui` unchanged would have created a real `ui ↔ chat`
+  package cycle. The five manifest types (`ArtifactManifest`, `ArtifactKind`, `ArtifactRendererId`,
+  `ArtifactExportKind`, `ArtifactStatus`) are now defined locally in `types.ts`, copied verbatim from
+  `@jini-ai/chat`'s `src/core/util/types.ts` — a small duplicated-type cost, accepted because a
+  renderer package must not depend on a chat package.
+
+  **`resolveArtifactManifest` no longer infers a legacy manifest from a file's name/extension** — a
+  real, disclosed API behavior change. It now returns `file.manifest ?? null`. Manifest inference
+  (guessing kind/renderer from `.md`/`.html`/`.svg`/`.tsx`, etc.) is a caller concern that depends on
+  a product's own naming conventions, not something a generic renderer registry should do on a
+  caller's behalf; a caller that still wants that inference should resolve a manifest for the file
+  itself (see `@jini-ai/chat`'s `inferLegacyManifest`) before handing it to this registry. Verified
+  zero external callers of `RendererRegistry`/`resolveArtifactManifest`/`createDefaultRendererRegistry`
+  anywhere in Jini or Tovu before making this change — `@jini-ai/chat`'s own `RendererRegistry` is an
+  unrelated, locally-defined class in `artifact-types.ts`, and `@jini-ai/artifacts`' own
+  `resolveArtifactManifest` is an unrelated 3-argument function; both are same-name coincidences, not
+  real dependents. The four bundled renderers (`HtmlRenderer`, `MarkdownRenderer`, `SvgRenderer`,
+  `ReactComponentRenderer`) gate `canRender` on a resolvable manifest before falling back to any
+  `file.kind`/extension heuristic of their own, so this ripples into every test that exercised
+  default-registry routing via a bare file name with no explicit `manifest` — all updated to attach
+  one, with the extension-inference-specific assertions flipped to assert the removed behavior no
+  longer fires. No test was weakened or deleted: every changed assertion now tests the new,
+  documented contract, or restores a manifest to keep testing what it always meant to test.
+
+  **`@jini-ai/renderers-react` is retired, not versioned forward.** It was published (0.1.2), and
+  `packages/renderers-react` is deleted from this workspace. Deleting the source does not unpublish
+  anything, so whoever runs the next release should follow up with:
+
+  ```
+  npm deprecate @jini-ai/renderers-react "Merged into @jini-ai/ui; import from '@jini-ai/ui/renderers' instead."
+  ```
+
+  `@jini-ai/chat`'s dead `@jini-ai/renderers-react` dependency (declared, never imported — its own
+  `react/artifact-types.ts` defines a local placeholder registry instead, per its
+  `TODO(renderers-react)` header, left untouched here as out of scope) is removed from its
+  `package.json`, hence the accompanying patch bump.
+
+- 0c247a8: Fix visitor chat streaming announcements, resumed focus, frame batching, persistence and lazy mount/retry handling. Document the additive A2uiSurfaceCard registry prop for host validation and rendering.
+- e16a907: Clear floating-point noise in displayed costs, reconcile resumed counter resets and revisited sessions, and expose reported output tokens to assistive technology.
+- ea8d883: Release modal semantics when focus leaves chat, announce bounded rendered reply text, and retry opening without reloading mounted assets.
+- Updated dependencies [22f0619]
+- Updated dependencies [82ed2d3]
+- Updated dependencies [5a3de86]
+  - @jini-ai/core@0.6.10
+
 ## 0.6.7 — 2026-10-22
 
 - 2026-10-22: Memory fixes (durable run store reads its own row, ledger parses events once), shared settings segmented control, Slack token rule restored, coverage.
@@ -118,7 +242,6 @@
 - Correct renderer priority and opt-in stylesheet documentation; retain the layout rationale with neutral provenance.
 - BREAKING: replace the local finalizer Clock with core Clock.nowMs(); core/React helpers and ext-event slot-key callbacks take required objects.
 
-
 - BREAKING: ChatStore methods use required argument objects; paging options move to the second bag. ChatHistoryMaintenance and ChatStoreFactory follow the same convention.
 - BREAKING: SQLite/Postgres/PGlite factories use core `Clock` through `{ clock }` rather than `{ now }`; system-time defaults and SQL behavior are preserved.
 
@@ -208,5 +331,6 @@
   - @jini-ai/agentic@0.1.1
 
 ### C2 storage ownership
+
 - Added `./store/legacy` and `./store/legacy/sqlite`; preserved sync local project chat CRUD and schema.
 - Retained the original owner-isolation suite on the concern adapter after draining the old package.

package/dist/core/assistant-client/transport.js

@@ -103,7 +103,9 @@ export function createAssistantTransportClient({ ports }, _options = {}) {
      * `events_json` is the sole durable record of why a run died (exit code, signal, the CLI's own
      * stderr) once the daemon's in-memory event log is gone, and the pane renders it on reload — so
      * dropping the row trades a history bug for a forensics hole. The skip belongs here, on the read
-     * side. See {@link historyForTranscript} and `assistant-chats.ts`'s `persistableMessages`.
+     * side. The transcript's hidden-tool mode likewise filters only recovered tool failures and keeps
+     * unrecovered failures behind a compact disclosure; it never deletes this durable evidence.
+     * See {@link historyForTranscript} and `assistant-chats.ts`'s `persistableMessages`.
      */
     function isAnsweredAssistantTurn(message) {
         return message.runStatus === undefined || message.runStatus === "succeeded";

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

@@ -63,7 +63,7 @@ export interface MessageRowProps {
      * included (a host's "Done line" display choice, 2026-10-11). */
     showUsageLine?: boolean;
     /** How tool calls show (`../tool-call-display.ts`): every card (`'show'`, the default), one
-     * fold-up line per turn (`'collapsed'`), or only failed ones (`'hidden'`). */
+     * fold-up line per turn (`'collapsed'`), or compact unrecovered failures (`'hidden'`). */
     toolCallDisplay?: ToolCallDisplay;
     /** Show the model's reasoning (`thinking` events) as a fold-up block where it happened. Off by
      * default — the transcript never showed it before this option. Needs the interleaved layout; a

package/dist/react/components/MessageRow.js

@@ -54,7 +54,7 @@ import { usageLayout, usageLineMeetsActions, useMessageUsage, useUsageSummary }
  * chunk stopped arriving.
  */
 import React, { memo, useMemo } from 'react';
-import { isAwaitingAnswer, isTerminalRunStatus, splitOnQuestionForms, stripArtifact } from '../../core/index.js';
+import { assistantContentFromEvents, isAwaitingAnswer, isTerminalRunStatus, splitOnQuestionForms, stripArtifact } from '../../core/index.js';
 import { useToolTimeline } from '../hooks/useToolTimeline.js';
 import { useExtEventGroups } from '../hooks/useExtEventGroups.js';
 import { useCopyToClipboard } from '../hooks/useCopyToClipboard.js';
@@ -118,16 +118,25 @@ function UsageSummary({ usage, showTotal }) {
         return null;
     return (_jsxs("div", { className: "jini-message-usage", title: title, role: "note", "aria-label": ariaLabel, children: [_jsx("span", { className: "jini-message-usage-dot", "aria-hidden": true, children: "\u25CF" }), t('Done'), " \u00B7 ", text] }));
 }
-function messageBlocks({ visibleContent, message, rows, registry }, { toolCallDisplay = 'show', includeThinking = false } = {}) {
-    // 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;
-    const blocks = interleaveMessageBlocks({ events: message.events, content: message.content, rows }, { slotOf: (ev) => registry.slot({ name: ev.name, data: ev.data }), includeThinking });
-    return blocks ? applyToolCallDisplay({ blocks, mode: toolCallDisplay }) : null;
+function messageBlocks({ message, rows, registry, content = message.content }, { toolCallDisplay = 'show', includeThinking = false } = {}) {
+    const blocks = interleaveMessageBlocks({ events: message.events, content, rows }, { slotOf: (ev) => registry.slot({ name: ev.name, data: ev.data }), includeThinking });
+    return blocks ? applyToolCallDisplay({ blocks, mode: toolCallDisplay }, { runFailed: message.runStatus === 'failed' }) : null;
+}
+/**
+ * The flat layout's tool groups. Even when host text prevents interleaving, event ordering can still
+ * prove tool recovery and reply boundaries, so hidden mode reconstructs the blocks from the events —
+ * only for this display decision; the host's text is never replaced. Otherwise one flat list.
+ * @complexity O(n) in events + rows.
+ */
+function flatToolGroups({ message, rows, registry, displayBlocks }, { toolCallDisplay }) {
+    if (toolCallDisplay === 'hidden') {
+        const recovery = displayBlocks
+            ?? messageBlocks({ message, rows, registry, content: assistantContentFromEvents({ events: message.events ?? [] }) }, { toolCallDisplay });
+        if (recovery)
+            return recovery.flatMap((block) => (block.kind === 'tools' ? [{ rows: block.rows, key: block.key }] : []));
+    }
+    const flat = toolRowsForDisplay({ rows, mode: toolCallDisplay }, { runFailed: message.runStatus === 'failed' });
+    return flat.length > 0 ? [{ rows: flat, key: 'tools' }] : [];
 }
 /** The model's reasoning, folded under a "Thinking" summary so it never crowds the answer. */
 function ThinkingBlock({ text }) {
@@ -191,18 +200,21 @@ function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageL
     const answeredCards = useAnsweredCards({ slotOf: registry.slot, events: message.events ?? [], groups: extGroups, runStreaming, runStatus: message.runStatus });
     const terminalNotice = terminalMessageNotice({ message }, {});
     const visibleContent = stripArtifact({ content: message.content });
-    const blocks = messageBlocks({ visibleContent, message, rows: timeline.rows, registry }, { toolCallDisplay, includeThinking: showThinking });
+    const displayBlocks = messageBlocks({ message, rows: timeline.rows, registry }, { toolCallDisplay, includeThinking: showThinking });
+    // Artifact stripping trims/replaces text, invalidating the event offsets for rendering. Keep the
+    // flat layout there; displayBlocks still supplies the recovery decision from the original events.
+    const blocks = visibleContent === message.content ? displayBlocks : null;
     const pending = isPendingWithNoContent(message, visibleContent, timeline.rows.length);
     const runInProgress = isRunInProgress(message.runStatus);
     const awaitingAnswer = messageAwaitingAnswer({ runStreaming, runInProgress, events: message.events }, { isAnsweredCard: answeredCards.isAnsweredCard });
     const usage = usageLayout({ usage: messageUsage, interleaved: blocks !== null, runInProgress }, { runStreaming });
     const footerUsage = showUsageLine ? usage.footer : undefined;
     const renderToolCard = (row) => (_jsx(ToolCard, { use: row.use, result: row.result, runStreaming: runStreaming, runSucceeded: runSucceeded, ...(projectFileNames !== undefined ? { projectFileNames } : {}), ...(onRequestOpenFile !== undefined ? { onRequestOpenFile } : {}) }, row.id));
-    // One turn's cards: a fold-up line when collapsed, the plain card list otherwise.
-    const renderTools = (rows, key) => (toolCallDisplay === 'collapsed'
-        ? _jsx(ToolCallGroup, { rows: rows, renderRow: renderToolCard }, key)
+    // Hidden mode reuses the same disclosure and card renderer for unrecovered failures.
+    const renderTools = (rows, key) => (toolCallDisplay !== 'show'
+        ? _jsx(ToolCallGroup, { rows: rows, renderRow: renderToolCard, failureOnly: toolCallDisplay === 'hidden' }, key)
         : _jsx("div", { className: "jini-message-tools", children: rows.map(renderToolCard) }, key));
-    const flatToolRows = toolRowsForDisplay({ rows: timeline.rows, mode: toolCallDisplay });
+    const flatTools = flatToolGroups({ message, rows: timeline.rows, registry, displayBlocks }, { toolCallDisplay });
     const renderExtGroup = (group) => {
         const renderer = registry.get({ name: group.name });
         if (!renderer && group.name === MID_RUN_USER_MESSAGE_EXT_EVENT_NAME)
@@ -254,7 +266,7 @@ function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageL
             ? 'jini-message jini-message-assistant jini-message-assistant--usage-actions'
             : 'jini-message jini-message-assistant', "data-message-id": message.id, "data-run-status": message.runStatus, "data-agent-element": `chat-message-${message.id}`, "data-agent-role": "region", "data-agent-label": "A reply from the assistant", children: [message.agentName ? _jsx("div", { className: "jini-message-agent", children: message.agentName }) : null, blocks
                 ? blocks.map(renderBlock)
-                : (_jsxs(_Fragment, { children: [renderTextSegments(visibleContent, 'text'), flatToolRows.length > 0 ? renderTools(flatToolRows) : null, extGroups.length > 0 ? _jsx("div", { className: "jini-message-ext-events", children: extGroups.map(renderExtGroup) }) : null] })), _jsx(AssistantMessageFooter, { message, usageEvent: footerUsage, showUsageTotal, terminalNotice, pending, runInProgress, runStreaming, visibleContent, isAnsweredCard: answeredCards.isAnsweredCard })] }));
+                : (_jsxs(_Fragment, { children: [renderTextSegments(visibleContent, 'text'), flatTools.map((group) => renderTools(group.rows, group.key)), extGroups.length > 0 ? _jsx("div", { className: "jini-message-ext-events", children: extGroups.map(renderExtGroup) }) : null] })), _jsx(AssistantMessageFooter, { message, usageEvent: footerUsage, showUsageTotal, terminalNotice, pending, runInProgress, runStreaming, visibleContent, isAnsweredCard: answeredCards.isAnsweredCard })] }));
 }
 /**
  * The live "what is it doing" line under a running reply (see `core/run-activity.ts`). Replaces the

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

@@ -2,11 +2,12 @@ import type { ReactNode } from 'react';
 import type { ToolDisplayRow } from '../tool-call-display.js';
 /**
  * One turn's tool cards folded into a single line ("Used 3 tools ▸") that opens on click — the
- * `toolCallDisplay: 'collapsed'` layout. Props in, JSX out; state and copy are in
- * `useToolCallGroup`.
+ * `toolCallDisplay: 'collapsed'` layout, or the compact failure notice in 'hidden'. The disclosure
+ * state lives in `useToolCallGroup`; copy uses the host's translator.
  */
-export declare function ToolCallGroup<Row extends ToolDisplayRow>({ rows, renderRow }: {
+export declare function ToolCallGroup<Row extends ToolDisplayRow>({ rows, renderRow, failureOnly }: {
     rows: readonly Row[];
+    failureOnly?: boolean;
     renderRow: (row: Row) => ReactNode;
 }): import("react").JSX.Element;
 //# sourceMappingURL=ToolCallGroup.d.ts.map

package/dist/react/components/ToolCallGroup.js

@@ -1,13 +1,15 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useToolCallGroup } from './ToolCallGroup.hooks.js';
+import { useT } from '../hooks/context.js';
 import { Icon } from './Icon.js';
 /**
  * One turn's tool cards folded into a single line ("Used 3 tools ▸") that opens on click — the
- * `toolCallDisplay: 'collapsed'` layout. Props in, JSX out; state and copy are in
- * `useToolCallGroup`.
+ * `toolCallDisplay: 'collapsed'` layout, or the compact failure notice in 'hidden'. The disclosure
+ * state lives in `useToolCallGroup`; copy uses the host's translator.
  */
-export function ToolCallGroup({ rows, renderRow }) {
+export function ToolCallGroup({ rows, renderRow, failureOnly = false }) {
     const group = useToolCallGroup({ rows });
-    return (_jsxs("div", { className: "jini-tool-group", "data-failed": group.failed ? 'true' : undefined, children: [_jsxs("button", { type: "button", className: "jini-tool-group__toggle", "aria-expanded": group.open, onClick: group.toggle, children: [_jsx("span", { className: `jini-tool-group__label${group.running ? ' shimmer-text' : ''}`, children: group.label }), _jsx(Icon, { name: group.open ? 'chevron-down' : 'chevron-right', size: 12 })] }), group.open ? _jsx("div", { className: "jini-message-tools", children: rows.map(renderRow) }) : null] }));
+    const t = useT();
+    return (_jsxs("div", { className: "jini-tool-group", "data-failed": group.failed ? 'true' : undefined, children: [failureOnly ? _jsxs("span", { className: "jini-tool-group__label", children: [t('A step failed'), " "] }) : null, _jsxs("button", { type: "button", className: "jini-tool-group__toggle", "aria-expanded": group.open, onClick: group.toggle, children: [_jsx("span", { className: `jini-tool-group__label${group.running ? ' shimmer-text' : ''}`, children: failureOnly ? t('Show') : group.label }), _jsx(Icon, { name: group.open ? 'chevron-down' : 'chevron-right', size: 12 })] }), group.open ? _jsx("div", { className: "jini-message-tools", children: rows.map(renderRow) }) : null] }));
 }
 //# sourceMappingURL=ToolCallGroup.js.map

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

@@ -312,7 +312,8 @@ export interface ChatPaneProps extends UserTextRedactionOptions {
     /**
      * Transcript display choices (a host's chat settings, 2026-10-11), passed straight to
      * `MessageList`: how tool calls show (`'show'` default, `'collapsed'` one line per turn, `'hidden'`
-     * all but failed ones — see `tool-call-display.ts`), whether the "Done · time · cost" lines show
+     * hides recovered calls and folds unrecovered failures — see `tool-call-display.ts`), whether the
+     * "Done · time · cost" lines show
      * (default `true`), and whether the model's reasoning shows (default `false`).
      */
     toolCallDisplay?: ToolCallDisplay;

package/dist/react/tool-call-display.d.ts

@@ -6,8 +6,8 @@
  * - `'show'`      — every tool card, where it happened. The layout every host had before this.
  * - `'collapsed'` — each turn's tool cards fold into ONE line ("Used 3 tools") that expands on
  *   click; while a tool runs the line names it instead ("Running Bash…").
- * - `'hidden'`    — no tool cards at all, EXCEPT a failed one: an error must never vanish from the
- *   transcript just because the reader asked for a quieter view.
+ * - `'hidden'`    — recovered failures disappear with successful calls. Unrecovered failures stay
+ *   behind one compact disclosure per reply: work that stopped must never vanish silently.
  *
  * Pure rules over `interleaveMessageBlocks`' output (or the flat row list when that refused), kept
  * out of `MessageRow.tsx` so every mode is testable without rendering.
@@ -25,7 +25,7 @@ export interface ToolDisplayRow {
     };
 }
 /**
- * Whether a row is a failure the reader must always see: the tool returned an error, or the run
+ * Whether a row failed: the tool returned an error, or the run
  * ended without the tool ever answering (`deriveToolStatus` maps both to `'error'`).
  * @complexity O(1).
  */
@@ -41,7 +41,8 @@ export declare function isFailedToolRow({ row }: {
  * one line per reply. Keeping the first block's key keeps the line's open/closed state across
  * streaming updates, since later blocks append after it.
  *
- * `'hidden'` keeps only failed rows and drops `tools` blocks left empty.
+ * `'hidden'` keeps unrecovered failures in one block per reply. Later assistant text or a successful
+ * tool proves recovery; running tools and reasoning do not. An errored final reply keeps its failures.
  *
  * @param input.blocks - `interleaveMessageBlocks` output.
  * @param input.mode - The display mode.
@@ -51,15 +52,20 @@ export declare function isFailedToolRow({ row }: {
 export declare function applyToolCallDisplay<Row extends ToolDisplayRow>({ blocks, mode }: {
     blocks: readonly MessageBlock<Row>[];
     mode: ToolCallDisplay;
+}, { runFailed }?: {
+    runFailed?: boolean;
 }): readonly MessageBlock<Row>[];
 /**
- * The flat layout's counterpart (used when `interleaveMessageBlocks` refused): `'hidden'` keeps only
- * failed rows; the other modes keep every row (`'collapsed'` folds them into one line at render).
+ * Row-level recovery scan, also used by the flat fallback. Without trustworthy text ordering,
+ * only later successful rows prove recovery. Other modes keep every row.
  * @complexity O(n) in rows.
  */
 export declare function toolRowsForDisplay<Row extends ToolDisplayRow>({ rows, mode }: {
     rows: readonly Row[];
     mode: ToolCallDisplay;
+}, { recovered, runFailed }?: {
+    recovered?: boolean;
+    runFailed?: boolean;
 }): readonly Row[];
 /** What a collapsed tool line says: the tool running now, or how many ran (and how many failed). */
 export type ToolGroupSummary = {

package/dist/react/tool-call-display.js

@@ -1,6 +1,6 @@
 import { humanizeToolName } from '../core/index.js';
 /**
- * Whether a row is a failure the reader must always see: the tool returned an error, or the run
+ * Whether a row failed: the tool returned an error, or the run
  * ended without the tool ever answering (`deriveToolStatus` maps both to `'error'`).
  * @complexity O(1).
  */
@@ -20,31 +20,48 @@ function isRunningToolRow(row) {
  * one line per reply. Keeping the first block's key keeps the line's open/closed state across
  * streaming updates, since later blocks append after it.
  *
- * `'hidden'` keeps only failed rows and drops `tools` blocks left empty.
+ * `'hidden'` keeps unrecovered failures in one block per reply. Later assistant text or a successful
+ * tool proves recovery; running tools and reasoning do not. An errored final reply keeps its failures.
  *
  * @param input.blocks - `interleaveMessageBlocks` output.
  * @param input.mode - The display mode.
  * @returns New blocks; the input is never mutated. `'show'` returns `blocks` itself.
  * @complexity O(n) in blocks + rows.
  */
-export function applyToolCallDisplay({ blocks, mode }) {
+export function applyToolCallDisplay({ blocks, mode }, { runFailed = false } = {}) {
     if (mode === 'show')
         return blocks;
-    return mode === 'hidden' ? hideToolCalls({ blocks }) : collapseToolCalls({ blocks });
+    return mode === 'hidden' ? hideToolCalls({ blocks, runFailed }) : collapseToolCalls({ blocks });
 }
-/** `'hidden'`: keeps only failed rows and drops `tools` blocks left empty. */
-function hideToolCalls({ blocks }) {
+/**
+ * Scan backwards so only later content in the SAME reply can prove recovery. Failures stay visible
+ * while streaming until that evidence arrives. This is a display filter, never a deletion from the
+ * durable events: see assistant-client/transport.ts's forensics rationale.
+ * @complexity O(n) in blocks + rows, excluding the shared grouping pass.
+ */
+function hideToolCalls({ blocks, runFailed }) {
     const out = [];
-    for (const block of blocks) {
+    let recovered = false;
+    let failedReply = runFailed;
+    for (let i = blocks.length - 1; i >= 0; i -= 1) {
+        const block = blocks[i];
+        if (block.kind === 'reply-end') {
+            recovered = false;
+            failedReply = false;
+        }
+        if (block.kind === 'text' && block.text.trim())
+            recovered = true;
         if (block.kind !== 'tools') {
             out.push(block);
             continue;
         }
-        const failed = block.rows.filter((row) => isFailedToolRow({ row }));
-        if (failed.length > 0)
-            out.push({ kind: 'tools', rows: failed, key: block.key });
+        const rows = toolRowsForDisplay({ rows: block.rows, mode: 'hidden' }, { recovered, runFailed: failedReply });
+        if (rows.length > 0)
+            out.push({ ...block, rows });
+        if (block.rows.some((row) => row.status === 'complete'))
+            recovered = true;
     }
-    return out;
+    return collapseToolCalls({ blocks: out.reverse() });
 }
 /** `'collapsed'`: merges every `tools` block of a turn into the turn's first one (see above). */
 function collapseToolCalls({ blocks }) {
@@ -65,12 +82,22 @@ function collapseToolCalls({ blocks }) {
     return out;
 }
 /**
- * The flat layout's counterpart (used when `interleaveMessageBlocks` refused): `'hidden'` keeps only
- * failed rows; the other modes keep every row (`'collapsed'` folds them into one line at render).
+ * Row-level recovery scan, also used by the flat fallback. Without trustworthy text ordering,
+ * only later successful rows prove recovery. Other modes keep every row.
  * @complexity O(n) in rows.
  */
-export function toolRowsForDisplay({ rows, mode }) {
-    return mode === 'hidden' ? rows.filter((row) => isFailedToolRow({ row })) : rows;
+export function toolRowsForDisplay({ rows, mode }, { recovered = false, runFailed = false } = {}) {
+    if (mode !== 'hidden')
+        return rows;
+    const failed = [];
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+        const row = rows[i];
+        if (isFailedToolRow({ row }) && (runFailed || !recovered))
+            failed.push(row);
+        if (row.status === 'complete')
+            recovered = true;
+    }
+    return failed.reverse();
 }
 /**
  * Summarises one turn's tool rows. The LAST running row wins, so a line over several in-flight calls

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/chat",
-  "version": "0.6.7",
+  "version": "0.6.10",
   "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": {
@@ -196,12 +196,12 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.9"
+    "@jini-ai/core": "^0.6.10"
   },
   "peerDependencies": {
     "react": "^18.3.0 || ^19.0.0",
     "react-dom": "^18.3.0 || ^19.0.0",
-    "@jini-ai/db": "^0.3.2",
+    "@jini-ai/db": "^0.6.10",
     "kysely": "^0.29.6",
     "better-sqlite3": "^13.0.0",
     "@electric-sql/pglite": "0.5.8",
@@ -213,11 +213,11 @@
     "@radix-ui/react-radio-group": "^1.4.7",
     "@radix-ui/react-select": "^2.3.7",
     "@radix-ui/react-slot": "^1.3.3",
-    "@jini-ai/agent-runtime": "^0.4.5",
-    "@jini-ai/agentic": "^0.4.4",
-    "@jini-ai/protocol": "^0.4.4",
-    "@jini-ai/ui": "^0.5.0",
-    "@jini-ai/diagnostics": "^0.5.2"
+    "@jini-ai/agent-runtime": "^0.6.10",
+    "@jini-ai/agentic": "^0.6.10",
+    "@jini-ai/protocol": "^0.6.10",
+    "@jini-ai/ui": "^0.6.10",
+    "@jini-ai/diagnostics": "^0.6.10"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -303,13 +303,13 @@
     "pg": "8.23.0",
     "@ag-ui/core": "0.0.58",
     "fast-check": "4.3.0",
-    "@jini-ai/agentic": "^0.4.5",
-    "@jini-ai/agent-runtime": "0.4.12",
-    "@jini-ai/protocol": "^0.4.5",
-    "@jini-ai/core": "^0.4.9",
-    "@jini-ai/db": "0.3.6",
-    "@jini-ai/diagnostics": "^0.5.4",
-    "@jini-ai/ui": "^0.5.6"
+    "@jini-ai/agentic": "^0.6.10",
+    "@jini-ai/db": "0.6.10",
+    "@jini-ai/agent-runtime": "0.6.10",
+    "@jini-ai/ui": "^0.6.10",
+    "@jini-ai/core": "^0.6.10",
+    "@jini-ai/diagnostics": "^0.6.10",
+    "@jini-ai/protocol": "^0.6.10"
   },
   "typesVersions": {
     "*": {