@jini-ai/chat 0.6.15-rc.2 → 0.6.16

package/dist/react/features/chat-pane/styles.js

@@ -427,6 +427,13 @@ export const CHAT_PANE_STYLES = `
   border-radius: 8px;
   font-size: 12px;
 }
+.jini-chat-pane__status--dismissible {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 10px;
+}
+.jini-chat-pane__status--dismissible > button { flex: none; }
 .jini-chat-pane__drop-target {
   position: relative;
   margin: -8px -8px -8px;
@@ -717,10 +724,15 @@ export const CHAT_PANE_STYLES = `
   .jini-chat-pane.jini-chat-pane .jini-composer-input { font-size: 16px; }
 }
 .jini-chat-pane .jini-composer-input::placeholder { color: var(--jini-chat-faint); }
+/* Wraps as a last resort: the leading slot gives way first (below), then the model label truncates,
+   and only then does the trailing group move to its own line whole. Unwrapped, a picked-folder chip
+   in the leading slot squeezed the model picker until send sat on its label (owner report,
+   2026-10-29); wrapping on the group's full width put picker and send on a second row whenever the
+   untruncated labels did not fit (owner, 2026-10-30: one line). */
 .jini-chat-pane .jini-composer-footer {
   display: flex;
+  flex-wrap: wrap;
   align-items: center;
-  justify-content: space-between;
   min-height: 42px;
   gap: 6px;
   padding: 6px 8px 8px;
@@ -730,7 +742,14 @@ export const CHAT_PANE_STYLES = `
 /* Host controls slotted at the start of the footer row, right after the attach/discovery "+"
    trigger above -- see ComposerSlots.footerLeadingAccessory's own doc (slots.ts) for why this
    exists as a third footer slot alongside footerAccessories/plusMenuItems. */
-.jini-chat-pane .jini-composer-footer-leading { display: inline-flex; align-items: center; }
+/* Basis 0, so a line break is decided on the slot's min-content, not its full width: a chip in it
+   truncates before the trailing group wraps. It grows back to its content, never past it. */
+.jini-chat-pane .jini-composer-footer-leading {
+  display: inline-flex;
+  flex: 1 1 0%;
+  align-items: center;
+  max-width: max-content;
+}
 /* NOT 'position: relative' — the discovery popover (below) anchors off '.jini-composer' itself
    (the nearest positioned ancestor once this wrapper opts out), not off this small trigger-button
    wrapper. Anchoring to the wrapper put the popover's bottom edge at the wrapper's own top edge —
@@ -951,9 +970,21 @@ export const CHAT_PANE_STYLES = `
   color: var(--jini-chat-muted);
   font-size: 12px;
 }
+/* Picker, plus menu and send: one group at the trailing edge that wraps as a unit. Basis 0 with an
+   automatic minimum, like the leading slot: the line break is decided on the group's min-content
+   (model label truncated, below), so the label gives way before the group wraps. It grows back to
+   its content, never past it. */
+.jini-chat-pane .jini-composer-footer-trailing {
+  display: flex;
+  flex: 1 1 0%;
+  align-items: center;
+  gap: 6px;
+  max-width: max-content;
+  margin-left: auto;
+}
 /* Always pushed to the trailing edge. This also covers a footer with no attach/accessory controls
    before the send group (a public visitor chat), which would otherwise leave the lone send button
-   at the start under the footer's space-between. */
+   at the start of the row. */
 .jini-chat-pane .jini-composer-send-group {
   display: flex;
   flex-shrink: 0;
@@ -1177,6 +1208,9 @@ export const CHAT_PANE_STYLES = `
   cursor: pointer;
 }
 .jini-runtime-trigger { gap: 6px; padding: 3px 4px; }
+/* The model label truncates, but the trigger keeps room for its chevron and a few characters;
+   at the shared 'min-width: 0' it shrank to 12px and the chevron spilled onto the effort label. */
+.jini-runtime-picker .jini-runtime-dropup-trigger { min-width: 4.5em; }
 /* Local mode's trigger is the icon alone, so it has nothing to give way: shrunk under the shared
    \`min-width: 0\` on a narrow bar, the 22px icon spilled over the model/effort labels beside it
    (owner report, 2026-10-21). API mode keeps shrinking -- its model label ellipsizes. */
@@ -1206,6 +1240,16 @@ export const CHAT_PANE_STYLES = `
   text-overflow: ellipsis;
   white-space: nowrap;
 }
+/* In the composer footer: one clamped line that may break anywhere, so its min-content is one
+   character and the trailing group's min-content (\`.jini-composer-footer-trailing\`) counts the label
+   at the trigger's 4.5em floor, not its full text. */
+.jini-chat-pane .jini-composer-footer-trailing .jini-runtime-dropup-trigger__label {
+  display: -webkit-box;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 1;
+  white-space: normal;
+  word-break: break-all;
+}
 .jini-runtime-trigger__chevron { flex: none; }
 /* The effort label is short; the model label is the one that gives way on a narrow bar. */
 .jini-runtime-dropup-trigger--effort { flex: none; }
@@ -1367,6 +1411,26 @@ export const CHAT_PANE_STYLES = `
   text-overflow: ellipsis;
   white-space: nowrap;
 }
+/* An agent's full-access note (FullAccessNoteTip): a danger-tinted warning icon whose InfoTip holds
+   the text, in place of the paragraph that squeezed the composer row. 24px hit target; flex: none
+   so it never shrinks or wraps the row. The popover is portalled out of .jini-chat-pane, hence the
+   fallback colour. */
+.jini-runtime-access-note { display: inline-flex; flex: none; }
+.jini-runtime-access-note .info-tip { margin-left: 0; }
+.jini-runtime-access-note .info-tip-icon,
+.jini-runtime-access-note .info-tip:hover .info-tip-icon,
+.jini-runtime-access-note .info-tip:focus-within .info-tip-icon {
+  width: 24px;
+  height: 24px;
+  color: var(--jini-chat-danger, #e5484d);
+  border-radius: 6px;
+}
+.jini-runtime-access-note .info-tip-icon:hover { background: var(--jini-chat-subtle); }
+.jini-runtime-access-note .info-tip-icon:focus-visible { outline: 2px solid var(--jini-chat-accent); outline-offset: 1px; border-radius: 6px; }
+/* The note's icon sits beside its radio, not inside it (a control may not nest in a button). */
+.jini-runtime-agent-row { display: flex; align-items: center; }
+.jini-runtime-agent-row > .jini-runtime-agent { flex: 1; min-width: 0; }
+.jini-runtime-agent-row > .jini-runtime-access-note { margin-right: 4px; }
 .jini-runtime-empty { padding: 10px 11px; color: var(--jini-chat-muted); font-size: 12px; }
 .jini-runtime-models {
   display: flex;
@@ -1453,8 +1517,22 @@ export const CHAT_PANE_STYLES = `
 .jini-chat-pane .op-status { display: inline-flex; flex-shrink: 0; }
 .jini-chat-pane .op-status-ok { color: #4e875f; }
 .jini-chat-pane .op-status-error { color: var(--danger); }
+.jini-chat-pane .op-status-retried { color: var(--jini-chat-muted); }
 .jini-chat-pane .op-status-running { color: var(--jini-chat-accent); }
-.jini-chat-pane .op-title { font-weight: 600; flex-shrink: 0; }
+/* The name truncates before the target does (owner bug 11-01: "Content Read Content…" squeezed the
+   target out — the target was flex: 1 with a 0 basis beside a name that would not shrink). A generic
+   row's target (.op-target, ToolCard's ToolRowHead) keeps its own width up to 35% of the row; both
+   carry their full text as a title. Family cards keep .op-meta filling the row after a short name.
+   35%, not 40%: on the ~333px dock 40% still cut "Content Post Update" to "Content Post Upd…"
+   (checked in Chrome 11-01); 35% shows the whole name and ~12 characters of target. */
+.jini-chat-pane .op-title {
+  font-weight: 600;
+  flex: 0 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
 .jini-chat-pane .shimmer-text { animation: jini-chat-shimmer 1.6s ease-in-out infinite; }
 @keyframes jini-chat-shimmer { 0%, 100% { opacity: 1; } 50% { opacity: .45; } }
 @media (prefers-reduced-motion: reduce) { .jini-chat-pane .shimmer-text { animation: none; opacity: .6; } }
@@ -1466,7 +1544,19 @@ export const CHAT_PANE_STYLES = `
   flex: 1;
   min-width: 0;
 }
-.jini-chat-pane .op-expand-chev { flex-shrink: 0; color: var(--jini-chat-faint); }
+.jini-chat-pane .op-meta.op-target { flex: 0 0 auto; max-width: 35%; }
+/* ToolRowHead's "Tool call · " prefix: screen readers still hear it, the ~333px dock row doesn't spend
+   half its width on it (owner bug 11-01). Clipped, never display:none, so it stays in the accessible name. */
+.jini-chat-pane .op-sr-prefix {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  clip-path: inset(50%);
+}
+.jini-chat-pane .op-expand-chev { flex-shrink: 0; margin-left: auto; color: var(--jini-chat-faint); }
 /* Collapsed by default: 0 max-height clips the inner content, no display:none — keeps the height
    transition instead of an instant jump cut. */
 .jini-chat-pane .accordion-collapsible { max-height: 0; overflow: hidden; transition: max-height .15s ease; }

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

@@ -1,4 +1,5 @@
 import type { UserTextRedactionOptions } from '../../../core/user-text-redaction.js';
+import type { NativeToolPolicyInput } from '@jini-ai/agent-runtime/native-tool-policy';
 import type { CSSProperties, ReactNode, RefObject } from 'react';
 import type { ChatAttachment, ChatMessage } from '@jini-ai/chat';
 import type { ComposerSlots } from '../../slots.js';
@@ -57,6 +58,10 @@ export interface ChatPaneAgent {
      * as `true` — no badge — since there is no signal either way.
      */
     supportsTools?: boolean;
+    /** Native OFF switches can be enforced and audited; absence fails closed when limits exist. */
+    supportsNativeToolAccess?: boolean;
+    fullCliAccessOnly?: boolean;
+    fullCliAccessNote?: string;
 }
 export interface ChatPaneAgentSelection {
     agentId: string;
@@ -194,6 +199,11 @@ export type DeliverMidRunMessage = (input: {
 }) => Promise<MidRunMessageDelivery>;
 export interface ChatPaneProps extends UserTextRedactionOptions {
     transport: ChatTransport;
+    /** Host-localized text shown verbatim while the active run is awaiting acceptance.
+     * Omit to use the translated `Sending…` label; ignored once sending ends. */
+    sendingLabel?: string;
+    /** Current effective host limits, used for a warning before the first message is sent. */
+    nativeToolPolicy?: NativeToolPolicyInput;
     agents?: readonly ChatPaneAgent[];
     /** Optional host effects for package-owned inventory, rescan, and health polling. */
     runtimeAccess?: ChatPaneRuntimeAccess;
@@ -401,6 +411,7 @@ export interface ByokRuntimeSummary {
 }
 export interface AgentRuntimePickerProps {
     agents: readonly ChatPaneAgent[];
+    nativeToolPolicy?: NativeToolPolicyInput;
     value: ChatPaneAgentSelection;
     onChange: (selection: ChatPaneAgentSelection) => void;
     onRescan?: () => void;

package/dist/react/hooks/assistant-chats.js

@@ -414,7 +414,8 @@ export function createAssistantChatsClient({ ports }, _options = {}) {
          * conversation that no longer exists and every subsequent message is written at a dead row.
          */
         const refresh = useCallback(async () => {
-            const seq = ++listSeqRef.current;
+            listSeqRef.current += 1;
+            const seq = listSeqRef.current;
             // `null` marks a failed read, so the mount-time restore can tell "not listed" from "no list".
             const read = await portRef.current.listConversations({}, {}).catch(() => null);
             const listed = read ?? [];
@@ -515,12 +516,13 @@ export function createAssistantChatsClient({ ports }, _options = {}) {
          * once, already knowing what it holds and what has been persisted.
          */
         const select = useCallback((id) => {
-            const seq = ++switchSeqRef.current;
+            switchSeqRef.current += 1;
+            const seq = switchSeqRef.current;
             const commit = (messages) => {
                 // A slower load for a conversation the user has since navigated away from must not land.
                 if (switchSeqRef.current !== seq)
                     return;
-                writtenRef.current.set(id, new Set(messages.map(message => messageWriteKey({ message }, {}))));
+                writtenRef.current.set(id, new Set(messages.map(savedMessageWriteKey)));
                 setInitialMessages(messages);
                 commitActiveId(id);
                 // A user-initiated switch is exactly when remounting the pane IS the intent.
@@ -579,7 +581,8 @@ export function createAssistantChatsClient({ ports }, _options = {}) {
              * The conversation row is still created either way. That is deliberate — it exists server-side,
              * and abandoning it silently would be worse than leaving an empty chat in the list.
              */
-            const seq = ++switchSeqRef.current;
+            switchSeqRef.current += 1;
+            const seq = switchSeqRef.current;
             const conversation = await portRef.current.createConversation({}, {});
             // Both branches insert locally, so both have to invalidate an in-flight `refresh` — otherwise a
             // list snapshot taken before this POST lands overwrites the row that was just added.
@@ -660,9 +663,10 @@ export function createAssistantChatsClient({ ports }, _options = {}) {
             markListMutated();
             // Held until the PATCH settles, so any refresh landing in between re-applies this title
             // instead of trusting a server read that has not caught up yet.
-            const version = ++renameVersionRef.current;
+            renameVersionRef.current += 1;
+            const version = renameVersionRef.current;
             pendingRenamesRef.current.set(id, { version, title });
-            setConversations((current) => current.map((c) => (c.id === id ? { ...c, title, titleSource: "manual" } : c)));
+            setConversations((current) => renamedConversations({ current, id, title }));
             try {
                 await portRef.current.renameConversation({ id, title }, {});
             }
@@ -685,9 +689,10 @@ export function createAssistantChatsClient({ ports }, _options = {}) {
             const existing = pending.get(key);
             if (existing)
                 return existing;
+            const isDisposed = () => disposedRef.current;
             const write = (async () => {
                 await runStubPendingRef.current.get(conversationId)?.get(key);
-                return saveWithRetry(portRef.current, conversationId, message, () => disposedRef.current);
+                return saveWithRetry(portRef.current, conversationId, message, isDisposed);
             })();
             pending.set(key, write);
             void write.then(() => {
@@ -879,7 +884,7 @@ export function createAssistantChatsClient({ ports }, _options = {}) {
                 .createConversation({}, {})
                 .then((conversation) => {
                 markListMutated();
-                setConversations((current) => [conversation, ...current]);
+                setConversations(prependConversation(conversation));
                 writtenRef.current.set(conversation.id, new Set());
                 // Superseded: the row exists and shows up in the list, but the pane that asked for it is
                 // gone, so pointing `activeId` at it would send the NEXT pane's writes here. The caller's
@@ -964,4 +969,13 @@ export function createAssistantChatsClient({ ports }, _options = {}) {
         useAssistantChats: ({ port }, options = {}) => useAssistantChats(port, options),
     };
 }
+function savedMessageWriteKey(message) {
+    return messageWriteKey({ message }, {});
+}
+function renamedConversations({ current, id, title }) {
+    return current.map(conversation => conversation.id === id ? { ...conversation, title, titleSource: "manual" } : conversation);
+}
+function prependConversation(conversation) {
+    return (current) => [conversation, ...current];
+}
 //# sourceMappingURL=assistant-chats.js.map

package/dist/react/hooks/useArtifactStream.js

@@ -32,8 +32,9 @@ function collectCompleted(head, { registry }) {
     for (const ev of parseArtifacts({ content: head })) {
         if (ev.type === 'artifact:start') {
             meta = { identifier: ev.identifier, artifactType: ev.artifactType, title: ev.title };
+            continue;
         }
-        else if (ev.type === 'artifact:end') {
+        if (ev.type === 'artifact:end') {
             items.push(toItem({ ...meta, content: ev.fullContent, status: 'complete' }, { registry }));
         }
     }

package/dist/react/hooks/useComposer.js

@@ -186,12 +186,12 @@ export function useComposer(options = {}) {
         const validate = validateAttachmentsRef.current;
         if (!validate || !conversationId) {
             attachmentsHydratedForRef.current = conversationId;
-            return;
+            return undefined;
         }
         const cached = readCachedAttachments({ conversationId: conversationId });
         if (cached === null || cached.length === 0) {
             attachmentsHydratedForRef.current = conversationId;
-            return;
+            return undefined;
         }
         let cancelled = false;
         void (async () => {

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

@@ -19,12 +19,12 @@ function visualLineBounds({ textarea }) {
     mirror.append(text, document.createTextNode('\u200b'));
     document.body.append(mirror);
     try {
-        function lineAt(offset) {
+        const 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

package/dist/react/hooks/useConversation.js

@@ -52,7 +52,7 @@ export function useConversation(options) {
     useEffect(() => {
         const source = options.refreshSignal;
         if (!source || run.isStreaming)
-            return;
+            return undefined;
         let disposed = false, pending = false, timer;
         const refresh = async () => {
             if (pending)
@@ -61,7 +61,7 @@ export function useConversation(options) {
             try {
                 const saved = await source.loadMessages();
                 if (!disposed)
-                    setMessagesState(prev => [...new Map([...prev, ...saved].map(message => [message.id, message])).values()]);
+                    setMessagesState(prev => mergeSavedMessages({ previous: prev, saved }));
             }
             catch (error) {
                 if (!disposed)
@@ -143,14 +143,14 @@ export function useConversation(options) {
                 return m;
             // A plain if/else chain (not a nested ternary) — deliberately, so
             // each of the four mapped statuses is its own independently
-            // trackable branch under coverage instrumentation. The initial
+            // trackable branch under coverage instrumentation. The fallback
             // value is asserted non-null: this reconciliation effect only ever
             // runs after `sendMessage`/`retry` has called `run.start()`/
             // `reattach` (both set the message's `runStatus: 'queued'` via
             // `activeAssistantIdRef` first), so `m.runStatus` is always defined
             // and `run.status` is never `'idle'` by the time this callback
             // fires — one of the four branches below always reassigns it.
-            let runStatus = m.runStatus;
+            let runStatus;
             if (run.status === 'streaming')
                 runStatus = 'running';
             else if (run.status === 'done')
@@ -159,6 +159,8 @@ export function useConversation(options) {
                 runStatus = 'failed';
             else if (run.status === 'canceled')
                 runStatus = 'canceled';
+            else
+                runStatus = m.runStatus;
             const nextRunId = run.runId ?? m.runId;
             const events = projectAcceptedInputEvents({ events: mergeRunEvents({ saved: m.events, incoming: run.events }, {}) });
             return {
@@ -274,4 +276,7 @@ export function useConversation(options) {
         suppressScroll,
     }), [messages, conversationId, run.isStreaming, run.error, sendRefused, scrollIntent, sendMessage, cancel, retry, setMessages, acknowledgeScroll, suppressScroll]);
 }
+function mergeSavedMessages({ previous, saved }) {
+    return [...new Map([...previous, ...saved].map(message => [message.id, message])).values()];
+}
 //# sourceMappingURL=useConversation.js.map

package/dist/react/hooks/useExtEventGroups.js

@@ -26,12 +26,14 @@ function addExtEvent(state, { name, data }) {
 function visitEvent(state, ev) {
     if (ev.kind === 'tool_use') {
         state.openCalls.set(ev.id, { name: ev.name, input: ev.input });
+        return;
     }
-    else if (ev.kind === 'tool_result') {
+    if (ev.kind === 'tool_result') {
         state.openCalls.delete(ev.toolUseId);
         state.results.set(ev.toolUseId, { content: ev.content, isError: ev.isError });
+        return;
     }
-    else if (ev.kind === 'ext') {
+    if (ev.kind === 'ext') {
         addExtEvent(state, ev);
     }
 }

package/dist/react/hooks/useLatestOperation.js

@@ -48,7 +48,8 @@ export function useLatestOperation(_requiredArgs) {
         generationRef.current += 1;
     }, []);
     const run = useCallback(async ({ body, onError }) => {
-        const generation = ++generationRef.current;
+        generationRef.current += 1;
+        const generation = generationRef.current;
         const isCurrent = () => mountedRef.current && generation === generationRef.current;
         const token = {
             isCurrent,

package/dist/react/hooks/useQuestionForms.js

@@ -66,23 +66,17 @@ export function parseSubmittedAnswers({ form, userMessageContent }) {
         // `i < lines.length` is the loop condition, so this index is always
         // in-bounds and defined — same reasoning as `header` above.
         const line = lines[i];
-        const m = /^[-*]\s*([^:]+):\s*(.*)$/.exec(line);
-        if (!m)
+        const parsed = submittedAnswerLine({ line });
+        if (!parsed)
             continue;
-        // Both capture groups are required (non-optional) in this pattern, so
-        // they're always defined once `m` is non-null — TS just can't express
-        // that for regex capture groups.
-        const labelKey = m[1].trim().toLowerCase();
-        const value = m[2].trim();
-        const id = labelToId.get(labelKey);
-        if (!id)
-            continue;
-        // `id` only ever comes from `labelToId`, which was populated from this
-        // same `form.questions` array immediately above, so a question with
-        // this exact `id` is always found — the `!` reflects that invariant
-        // rather than gaming an untestable defensive branch.
-        const question = form.questions.find((x) => x.id === id);
-        answers[id] = decodeAnswerValue(question, value);
+        const id = labelToId.get(parsed.labelKey);
+        if (id) {
+            // `id` only ever comes from `labelToId`, populated from this same `form.questions` array,
+            // so this exact question exists; the assertion reflects that invariant rather than adding
+            // an untestable defensive branch.
+            const question = form.questions.find((x) => x.id === id);
+            answers[id] = decodeAnswerValue(question, parsed.value);
+        }
     }
     return Object.keys(answers).length > 0 ? answers : null;
 }
@@ -97,12 +91,28 @@ function decodeAnswerValue(question, value) {
     return value.toLowerCase() === '(skipped)' ? '' : formOptionValueForLabel({ question: question, labelOrValue: parseSubmittedOptionToken(value) });
 }
 function parseSubmittedOptionToken(raw) {
-    const match = /\s+\[value:\s*([^\]]+)\]\s*$/i.exec(raw);
-    if (!match)
+    const trimmed = raw.trimEnd();
+    if (!trimmed.endsWith(']'))
+        return raw.trim();
+    const end = trimmed.length - 1;
+    // The value cannot cross an earlier ']'; search the remaining suffix once, from the start
+    // of each whitespace run, retaining the first eligible (possibly nested) value marker.
+    const base = trimmed.lastIndexOf(']', end - 1) + 1;
+    const marker = /(?<!\s)\s+\[value:/i.exec(trimmed.slice(base, end));
+    if (!marker)
         return raw.trim();
-    // The single capture group is non-optional in this pattern, so it's
-    // always defined once `match` is non-null — same regex-capture-group
-    // caveat as `parseSubmittedAnswers` above.
-    return match[1].trim();
+    const value = trimmed.slice(base + marker.index + marker[0].length, end);
+    return value.length > 0 ? value.trim() : raw.trim();
+}
+function submittedAnswerLine({ line }) {
+    const label = /^[-*]([^:]+):/.exec(line);
+    if (!label)
+        return null;
+    const value = /^(.*)$/.exec(line.slice(label[0].length).trimStart());
+    if (!value)
+        return null;
+    // Each capture is required in its own pattern and is defined after a successful match;
+    // TypeScript cannot express that invariant for RegExpExecArray's numeric capture slots.
+    return { labelKey: label[1].trim().toLowerCase(), value: value[1].trim() };
 }
 //# sourceMappingURL=useQuestionForms.js.map

package/dist/react/hooks/useRunStream.js

@@ -118,7 +118,8 @@ export function useRunStream({ transport }) {
     }, []);
     const start = useCallback(async (input) => {
         teardownSubscription();
-        const generation = ++generationRef.current;
+        generationRef.current += 1;
+        const generation = generationRef.current;
         runIdRef.current = null;
         const subscriptionAbort = new AbortController();
         const cancelAbort = new AbortController();
@@ -150,7 +151,8 @@ export function useRunStream({ transport }) {
     }, [makeHandlers, teardownSubscription, transport]);
     const reattach = useCallback(async (runId, initialEvents = []) => {
         teardownSubscription();
-        const generation = ++generationRef.current;
+        generationRef.current += 1;
+        const generation = generationRef.current;
         runIdRef.current = runId;
         const subscriptionAbort = new AbortController();
         const cancelAbort = new AbortController();

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

@@ -7,5 +7,6 @@ export declare function useUserTextGuard(options: UserTextRedactionOptions, _opt
     }, _options?: {}) => import("../index.js").UserTextRedaction;
     redactText: (text: string) => string;
     notifyRedaction: (signal: SecretRedactionSignal) => void;
+    clearNotice: () => void;
 };
 //# sourceMappingURL=useUserTextGuard.d.ts.map

package/dist/react/hooks/useUserTextGuard.js

@@ -14,6 +14,8 @@ export function useUserTextGuard(options, _optional = {}) {
         return result;
     }, [options.redactUserText, notifyRedaction]);
     const redactText = useCallback((text) => redact({ text }, {}).text, [redact]);
-    return { secretRedacted, redact, redactText, notifyRedaction };
+    /** The notice is about one message: the pane clears it when the person sends the next one (a key in that one sets it again) or dismisses it. */
+    const clearNotice = useCallback(() => setSecretRedacted(false), []);
+    return { secretRedacted, redact, redactText, notifyRedaction, clearNotice };
 }
 //# sourceMappingURL=useUserTextGuard.js.map

package/dist/react/message-blocks.js

@@ -100,9 +100,11 @@ function placeEvent({ state, ev }, { slotOf, includeThinking }) {
     // Emitted per boundary, before any slot dedupe below, so every reply gets its own end marker.
     if (isReplyBoundary({ event: ev }))
         placeReplyEnd({ state });
-    if (ev.kind === 'ext')
+    if (ev.kind === 'ext') {
         placeExt({ state, ev }, { slotOf });
-    else if (ev.kind === 'tool_use')
+        return;
+    }
+    if (ev.kind === 'tool_use')
         placeToolUse({ state, id: ev.id });
 }
 /**

package/dist/react/styles/reference.css

@@ -43,6 +43,15 @@
   min-width: 0;
 }
 
+/* The picker, plus menu and send share this <div>; flex keeps them on one line, and it wraps
+   whole to its own line when the footer runs out of room. */
+.jini-composer-footer-trailing {
+  display: flex;
+  align-items: center;
+  min-width: 0;
+  margin-left: auto;
+}
+
 /* The grouped add menu and slash autocomplete anchor to the composer rather than escaping the
    host's layout. Visual tokens remain the host's responsibility. */
 .jini-composer,

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

@@ -32,6 +32,17 @@ export interface ToolDisplayRow {
 export declare function isFailedToolRow({ row }: {
     row: Pick<ToolDisplayRow, 'status'>;
 }): boolean;
+/**
+ * Ids of failed rows that a LATER successful call of the same tool and target retried (owner, 2026-10-31: a
+ * red "HTTP 400 … page was NOT written" row and "· 2 failed" stayed on screen after the immediate
+ * retry wrote the page). Those rows render as a neutral "Retried" and are not counted as failed;
+ * a failure nothing later succeeded at stays red. Inputs without target coordinates match by
+ * tool alone; a targetless success cannot clear a failure naming a target. Pass one turn's rows.
+ * @complexity O(n + target bytes) time and space.
+ */
+export declare function retriedToolRowIds({ rows }: {
+    rows: readonly ToolDisplayRow[];
+}, _options?: {}): ReadonlySet<string>;
 /**
  * Applies a display mode to an interleaved message.
  *

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

@@ -1,4 +1,4 @@
-import { humanizeToolName } from '../core/index.js';
+import { humanizeToolName, isDelegatedWrapperToolName } from '../core/index.js';
 /**
  * Whether a row failed: the tool returned an error, or the run
  * ended without the tool ever answering (`deriveToolStatus` maps both to `'error'`).
@@ -7,6 +7,62 @@ import { humanizeToolName } from '../core/index.js';
 export function isFailedToolRow({ row }) {
     return row.status === 'error';
 }
+/** The tool a row called: a delegated wrapper's `input.toolId`, else its own name (wrappers share one name). */
+function toolIdentity(row) {
+    if (!isDelegatedWrapperToolName({ name: row.name }))
+        return row.name;
+    const input = row.use?.input;
+    const toolId = typeof input === 'object' && input !== null ? input.toolId : undefined;
+    return typeof toolId === 'string' && toolId ? toolId : row.name;
+}
+/** Prefer a stable id over editable slugs/paths; normalize input aliases within each kind.
+ * @complexity O(target bytes), fixed field count; pure, absent coordinates return undefined.
+ */
+function targetCoordinate({ input }, _options = {}) {
+    const kinds = [
+        ['id', ['postId', 'post_id', 'pageId', 'page_id', 'entryId', 'entry_id', 'id']],
+        ['slug', ['slug']],
+        ['path', ['path', 'filePath', 'file_path']],
+    ];
+    for (const [kind, fields] of kinds) {
+        const field = fields.find(key => typeof input[key] === 'number' || (typeof input[key] === 'string' && input[key] !== ''));
+        if (field !== undefined)
+            return [kind, input[field]];
+    }
+    return undefined;
+}
+/** Target coordinates only: corrected content must not prevent a retry from matching.
+ * Wrapper inputs belong to the delegated tool, whose identity toolIdentity already resolves.
+ * @complexity O(target bytes); the coordinate list is fixed. Pure, with no input mutation.
+ */
+function retryIdentity({ row }, _options = {}) {
+    const input = row.use?.input;
+    const record = typeof input === 'object' && input !== null ? input : {};
+    const target = isDelegatedWrapperToolName({ name: row.name }) ? record.input : record;
+    const coordinates = typeof target === 'object' && target !== null ? target : {};
+    return JSON.stringify([toolIdentity(row), targetCoordinate({ input: coordinates })]);
+}
+/**
+ * Ids of failed rows that a LATER successful call of the same tool and target retried (owner, 2026-10-31: a
+ * red "HTTP 400 … page was NOT written" row and "· 2 failed" stayed on screen after the immediate
+ * retry wrote the page). Those rows render as a neutral "Retried" and are not counted as failed;
+ * a failure nothing later succeeded at stays red. Inputs without target coordinates match by
+ * tool alone; a targetless success cannot clear a failure naming a target. Pass one turn's rows.
+ * @complexity O(n + target bytes) time and space.
+ */
+export function retriedToolRowIds({ rows }, _options = {}) {
+    const succeededLater = new Set();
+    const retried = new Set();
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+        const row = rows[i];
+        const tool = retryIdentity({ row });
+        if (row.status === 'complete')
+            succeededLater.add(tool);
+        else if (isFailedToolRow({ row }) && succeededLater.has(tool))
+            retried.add(row.id);
+    }
+    return retried;
+}
 /** Running = no result yet while the run streams (`'executing'`), or not started (`'inProgress'`). */
 function isRunningToolRow(row) {
     return row.status === 'executing' || row.status === 'inProgress';
@@ -109,7 +165,8 @@ export function summarizeToolGroup({ rows }) {
         if (isRunningToolRow(row))
             return { kind: 'running', name: humanizeToolName({ name: row.name }, { input: row.use?.input }) };
     }
-    return { kind: 'done', count: rows.length, failed: rows.filter((row) => isFailedToolRow({ row })).length };
+    const retried = retriedToolRowIds({ rows });
+    return { kind: 'done', count: rows.length, failed: rows.filter((row) => isFailedToolRow({ row }) && !retried.has(row.id)).length };
 }
 /**
  * The collapsed line's text. Each phrase is its own translation key (the English string is the key,