@jini-ai/chat 0.3.11 → 0.5.1

package/dist/react/hooks/useConversation.js

@@ -24,7 +24,7 @@ export function useConversation(options) {
     const { transport, conversationId = null, agentId, createMessageId = defaultCreateMessageId } = options;
     const [messages, setMessagesState] = useState(options.initialMessages ?? []);
     const [scrollIntent, setScrollIntent] = useState(false);
-    const run = useRunStream(transport);
+    const run = useRunStream({ transport });
     // The assistant message id the currently-active run is writing into.
     const activeAssistantIdRef = useRef(null);
     const messagesRef = useRef(messages);
@@ -32,6 +32,58 @@ export function useConversation(options) {
     const setMessages = useCallback((updater) => {
         setMessagesState((prev) => (typeof updater === 'function' ? updater(prev) : updater));
     }, []);
+    /**
+     * The mount-time snapshot of `initialMessages`, captured once — the same "read once, never react
+     * to a later identity change" contract `messages`'s own `useState` initializer above already has
+     * for this same prop. A host's `initialMessages` array is expected to be a fresh identity on every
+     * render (`ChatPane` remounts the whole pane with a fresh `key` on a real conversation switch
+     * rather than pushing a new array into a live one), so depending on it directly in the effect below
+     * would re-fire on every render of a host that does not itself memoize the prop.
+     */
+    const initialMessagesRef = useRef(options.initialMessages);
+    /**
+     * Resumes an interrupted run on mount instead of leaving it frozen forever.
+     *
+     * `run.reattach` (`useRunStream.ts`) has existed since 2026-07-29 and is fully implemented —
+     * generation-guarded against double-subscription, abortable, race-safe — but until this effect,
+     * nothing in this package or any host ever called it. The gap it left: once a browser's live
+     * subscription to a run is torn down for ANY reason (this hook unmounting, a host remount, an HMR
+     * reload, a daemon restart), the run keeps going server-side and nothing ever tells the browser
+     * about it again — no more events, no more persistence, no error, just a frozen pane. The 2026-09-11 incident showed that teardown without remount reattachment
+     * leaves a running server task invisible to the browser. Reattaching needs a durably-recorded, non-terminal `runId` to find
+     * in `initialMessages` in the first place — the host is responsible for that half by persisting the run stub before starting the subscription.
+     *
+     * Mount-only (`[]` deps), by design: `useConversation` owns exactly one `useRunStream` instance for
+     * its whole lifetime, and a host that wants a different transcript remounts the pane with a fresh
+     * `key` rather than pushing a new `initialMessages` into a live one (see `initialMessagesRef`'s own
+     * doc) — so "the moment this hook mounts" IS "the moment a stale subscription needs recovering",
+     * and there is no later point in this hook's life that also needs this check.
+     *
+     * `activeAssistantIdRef.current` is set BEFORE calling `reattach`, not after: the reconciliation
+     * effect below (`applyRunToAssistantMessage`) no-ops whenever that ref is `null` — a reattach whose
+     * first event arrived before this assignment landed would be silently dropped on the floor instead
+     * of reaching the message it belongs to.
+     *
+     * A message with a `runId` but no `runStatus` at all is treated as nothing to reattach to, not as
+     * "assume non-terminal" — `useConversation`'s own reconciliation always writes both together, so
+     * the combination only arises from data this hook did not itself produce (a host's legacy rows, a
+     * different producer entirely), and there is no positive evidence there of an in-flight run worth
+     * the network round trip.
+     */
+    useEffect(() => {
+        const last = initialMessagesRef.current?.at(-1);
+        if (!last || last.role !== 'assistant')
+            return;
+        if (last.runId === undefined || last.runStatus === undefined)
+            return;
+        if (isTerminalRunStatus({ status: last.runStatus }))
+            return;
+        activeAssistantIdRef.current = last.id;
+        void run.reattach(last.runId, last.events);
+        // Mount-only: see this effect's own doc for why `run` is deliberately not listed — it is a
+        // `useCallback` (`useRunStream.ts`), stable for this hook instance's whole lifetime, so omitting
+        // it changes nothing about correctness.
+    }, []);
     const applyRunToAssistantMessage = useCallback(() => {
         const assistantId = activeAssistantIdRef.current;
         if (!assistantId)
@@ -62,9 +114,9 @@ export function useConversation(options) {
                 ...m,
                 ...(nextRunId !== undefined ? { runId: nextRunId } : {}),
                 events: run.events,
-                content: assistantContentFromEvents(run.events),
+                content: assistantContentFromEvents({ events: run.events }),
                 runStatus,
-                ...(isTerminalRunStatus(runStatus) ? { endedAt: Date.now() } : {}),
+                ...(isTerminalRunStatus({ status: runStatus }) ? { endedAt: Date.now() } : {}),
             };
         }));
         setScrollIntent(true);
@@ -104,7 +156,7 @@ export function useConversation(options) {
         // the same commit as the reconciliation effect that just marked the previous turn terminal.
         // Replacing the array with the snapshot threw that pending update away, leaving the finished
         // turn `running` forever — and never persisted, since hosts persist only terminal turns
-        // (Tovu stuck-chat investigation, 2026-09-27).
+        // (host stuck-chat investigation, 2026-09-27).
         setMessagesState((prev) => [...prev, userMessage, assistantMessage]);
         setScrollIntent(true);
         await run.start({

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

@@ -15,5 +15,9 @@ export interface ExtEventGroup {
  * @param slotOf - Which render slot an event belongs to. Defaults to its `name`, the one-slot-per-name
  *   grouping this hook always had; `MessageRow` passes the registry's `extEventSlot`.
  */
-export declare function useExtEventGroups(events: AgentEvent[] | undefined, slotOf?: (name: string, data: unknown) => string): ExtEventGroup[];
+export declare function useExtEventGroups({ events }: {
+    events: AgentEvent[] | undefined;
+}, { slotOf }?: {
+    slotOf?: ((name: string, data: unknown) => string) | undefined;
+}): ExtEventGroup[];
 //# sourceMappingURL=useExtEventGroups.d.ts.map

package/dist/react/hooks/useExtEventGroups.js

@@ -15,7 +15,7 @@ import { useMemo } from 'react';
  * @param slotOf - Which render slot an event belongs to. Defaults to its `name`, the one-slot-per-name
  *   grouping this hook always had; `MessageRow` passes the registry's `extEventSlot`.
  */
-export function useExtEventGroups(events, slotOf = (name) => name) {
+export function useExtEventGroups({ events }, { slotOf = (name) => name } = {}) {
     return useMemo(() => {
         const order = [];
         const bySlot = new Map();

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

@@ -14,12 +14,17 @@ export interface LatestOperation {
      * `onError` is invoked only for a genuine failure of an operation that is *still* current — a
      * superseded or unmounted one is discarded silently, which is what the hand-written guards did.
      */
-    run(body: (token: OperationToken) => Promise<void>, onError: (error: Error) => void): Promise<void>;
+    run(args: {
+        body: (token: OperationToken) => Promise<void>;
+        onError: (error: Error) => void;
+    }): Promise<void>;
     /** Supersedes whatever is in flight without starting a new operation. */
     supersede(): void;
 }
 /** Preserves native Error objects while normalizing opaque host-bridge rejections. */
-export declare function normalizeOperationError(error: unknown): Error;
+export declare function normalizeOperationError({ error }: {
+    error: unknown;
+}): Error;
 /**
  * Owns the mounted flag and the generation counter that decide which async attempt is allowed to
  * write state. One instance per hook: every operation started through it supersedes the previous
@@ -27,5 +32,5 @@ export declare function normalizeOperationError(error: unknown): Error;
  *
  * @complexity Time/space: O(1).
  */
-export declare function useLatestOperation(): LatestOperation;
+export declare function useLatestOperation(_requiredArgs: Record<string, never>): LatestOperation;
 //# sourceMappingURL=useLatestOperation.d.ts.map

package/dist/react/hooks/useLatestOperation.js

@@ -24,7 +24,7 @@ class SupersededOperation extends Error {
     }
 }
 /** Preserves native Error objects while normalizing opaque host-bridge rejections. */
-export function normalizeOperationError(error) {
+export function normalizeOperationError({ error }) {
     return error instanceof Error ? error : new Error(String(error));
 }
 /**
@@ -34,7 +34,7 @@ export function normalizeOperationError(error) {
  *
  * @complexity Time/space: O(1).
  */
-export function useLatestOperation() {
+export function useLatestOperation(_requiredArgs) {
     const mountedRef = useRef(true);
     const generationRef = useRef(0);
     useEffect(() => {
@@ -47,7 +47,7 @@ export function useLatestOperation() {
     const supersede = useCallback(() => {
         generationRef.current += 1;
     }, []);
-    const run = useCallback(async (body, onError) => {
+    const run = useCallback(async ({ body, onError }) => {
         const generation = ++generationRef.current;
         const isCurrent = () => mountedRef.current && generation === generationRef.current;
         const token = {
@@ -66,7 +66,7 @@ export function useLatestOperation() {
         catch (error) {
             if (!isCurrent())
                 return;
-            onError(normalizeOperationError(error));
+            onError(normalizeOperationError({ error: error }));
         }
     }, []);
     return useMemo(() => ({ run, supersede }), [run, supersede]);

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

@@ -11,5 +11,7 @@ export interface UsePinnedTodosResult {
     /** Dismisses the currently-pinned card. Only meaningful once `allComplete`; re-appears automatically once the plan changes again. */
     dismiss: () => void;
 }
-export declare function usePinnedTodos(messages: ReadonlyArray<ChatMessage> | undefined): UsePinnedTodosResult;
+export declare function usePinnedTodos({ messages }: {
+    messages: ReadonlyArray<ChatMessage> | undefined;
+}): UsePinnedTodosResult;
 //# sourceMappingURL=usePinnedTodos.d.ts.map

package/dist/react/hooks/usePinnedTodos.js

@@ -12,10 +12,10 @@
  */
 import { useCallback, useMemo, useState } from 'react';
 import { latestTodoWriteInputForPinnedCard, parseTodoWriteInput } from '../../core/index.js';
-export function usePinnedTodos(messages) {
+export function usePinnedTodos({ messages }) {
     const [dismissedKey, setDismissedKey] = useState(null);
-    const rawInput = useMemo(() => latestTodoWriteInputForPinnedCard(messages), [messages]);
-    const todos = useMemo(() => parseTodoWriteInput(rawInput), [rawInput]);
+    const rawInput = useMemo(() => latestTodoWriteInputForPinnedCard({ messages: messages }), [messages]);
+    const todos = useMemo(() => parseTodoWriteInput({ input: rawInput }), [rawInput]);
     const key = useMemo(() => (rawInput === null ? null : safeStableKey(rawInput)), [rawInput]);
     const total = todos.length;
     const completed = todos.filter((t) => t.status === 'completed').length;

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

@@ -18,11 +18,16 @@ export interface UseQuestionFormsResult {
     /** Formats `answers` into the prose user-message text the host sends back. */
     buildSubmission: (form: QuestionForm, answers: QuestionFormAnswers) => string;
 }
-export declare function useQuestionForms(messages: ReadonlyArray<ChatMessage> | undefined): UseQuestionFormsResult;
+export declare function useQuestionForms({ messages }: {
+    messages: ReadonlyArray<ChatMessage> | undefined;
+}): UseQuestionFormsResult;
 /**
  * Reverse of `formatFormAnswers` — given the user message that (maybe)
  * answered `form`, recover the answers map so the form can render in its
  * locked "answered" state with the user's picks visible.
  */
-export declare function parseSubmittedAnswers(form: QuestionForm, userMessageContent: string): QuestionFormAnswers | null;
+export declare function parseSubmittedAnswers({ form, userMessageContent }: {
+    form: QuestionForm;
+    userMessageContent: string;
+}): QuestionFormAnswers | null;
 //# sourceMappingURL=useQuestionForms.d.ts.map

package/dist/react/hooks/useQuestionForms.js

@@ -17,7 +17,7 @@
  */
 import { useCallback, useMemo } from 'react';
 import { findFirstQuestionForm, formOptionValueForLabel, formatFormAnswers } from '../../core/index.js';
-export function useQuestionForms(messages) {
+export function useQuestionForms({ messages }) {
     const forms = useMemo(() => {
         if (!messages || messages.length === 0)
             return [];
@@ -26,11 +26,11 @@ export function useQuestionForms(messages) {
             const message = messages[i];
             if (!message || message.role !== 'assistant')
                 continue;
-            const found = findFirstQuestionForm(message.content);
+            const found = findFirstQuestionForm({ input: message.content });
             if (!found)
                 continue;
             const nextMessage = messages[i + 1];
-            const submittedAnswers = nextMessage && nextMessage.role === 'user' ? parseSubmittedAnswers(found.form, nextMessage.content) ?? undefined : undefined;
+            const submittedAnswers = nextMessage && nextMessage.role === 'user' ? parseSubmittedAnswers({ form: found.form, userMessageContent: nextMessage.content }) ?? undefined : undefined;
             const interactive = submittedAnswers === undefined && i === messages.length - 1;
             out.push({ form: found.form, raw: found.raw, messageId: message.id, interactive, submittedAnswers });
         }
@@ -44,7 +44,7 @@ export function useQuestionForms(messages) {
         }
         return null;
     }, [forms]);
-    const buildSubmission = useCallback((form, answers) => formatFormAnswers(form, answers), []);
+    const buildSubmission = useCallback((form, answers) => formatFormAnswers({ form: form, answers: answers }), []);
     return { forms, activeForm, buildSubmission };
 }
 /**
@@ -52,7 +52,7 @@ export function useQuestionForms(messages) {
  * answered `form`, recover the answers map so the form can render in its
  * locked "answered" state with the user's picks visible.
  */
-export function parseSubmittedAnswers(form, userMessageContent) {
+export function parseSubmittedAnswers({ form, userMessageContent }) {
     // `String.prototype.split` always returns an array of length >= 1 (even
     // `''.split('\n')` is `['']`), so `lines` can never be empty here — no
     // `lines.length === 0` guard is needed (removed as provably-dead). Index 0
@@ -97,9 +97,9 @@ function decodeAnswerValue(question, value) {
             .split(',')
             .map((s) => s.trim())
             .filter((s) => s.length > 0 && s.toLowerCase() !== '(skipped)')
-            .map((s) => formOptionValueForLabel(question, parseSubmittedOptionToken(s)));
+            .map((s) => formOptionValueForLabel({ question: question, labelOrValue: parseSubmittedOptionToken(s) }));
     }
-    return value.toLowerCase() === '(skipped)' ? '' : formOptionValueForLabel(question, parseSubmittedOptionToken(value));
+    return value.toLowerCase() === '(skipped)' ? '' : formOptionValueForLabel({ question: question, labelOrValue: parseSubmittedOptionToken(value) });
 }
 function parseSubmittedOptionToken(raw) {
     const match = /\s+\[value:\s*([^\]]+)\]\s*$/i.exec(raw);

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

@@ -8,5 +8,10 @@ export type NowFn = () => number;
  * @returns The activity line's text, or `null` when `active` is false.
  * @complexity O(n) in events per render (memoized on the events array).
  */
-export declare function useRunActivity(events: readonly AgentEvent[] | undefined, active: boolean, now?: NowFn): string | null;
+export declare function useRunActivity({ events, active }: {
+    events: readonly AgentEvent[] | undefined;
+    active: boolean;
+}, { now }?: {
+    now?: (NowFn) | undefined;
+}): string | null;
 //# sourceMappingURL=useRunActivity.d.ts.map

package/dist/react/hooks/useRunActivity.js

@@ -15,9 +15,9 @@ import { useT } from './context.js';
  * @returns The activity line's text, or `null` when `active` is false.
  * @complexity O(n) in events per render (memoized on the events array).
  */
-export function useRunActivity(events, active, now = Date.now) {
+export function useRunActivity({ events, active }, { now = Date.now } = {}) {
     const t = useT();
-    const state = useMemo(() => deriveRunActivity(events), [events]);
+    const state = useMemo(() => deriveRunActivity({ events: events }), [events]);
     const [, setTick] = useState(0);
     const signal = useRef(null);
     const visible = useRef(null);
@@ -39,6 +39,6 @@ export function useRunActivity(events, active, now = Date.now) {
         visible.current = { count: state.visibleCount, at };
     const localSeconds = (at - signal.current.at) / 1000;
     const reported = state.activity.kind === 'running-tool' ? (state.activity.reportedSeconds ?? 0) : 0;
-    return describeRunActivity(state.activity, { seconds: Math.max(localSeconds, reported), idleMs: at - visible.current.at }, t);
+    return describeRunActivity({ activity: state.activity, clock: { seconds: Math.max(localSeconds, reported), idleMs: at - visible.current.at }, t: t });
 }
 //# sourceMappingURL=useRunActivity.js.map

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

@@ -23,5 +23,7 @@ export interface UseRunStreamResult extends RunStreamState {
     /** Clears all state back to `idle` without touching the transport (e.g. moving to a fresh turn). */
     reset: () => void;
 }
-export declare function useRunStream(transport: ChatTransport): UseRunStreamResult;
+export declare function useRunStream({ transport }: {
+    transport: ChatTransport;
+}): UseRunStreamResult;
 //# sourceMappingURL=useRunStream.d.ts.map

package/dist/react/hooks/useRunStream.js

@@ -48,7 +48,7 @@ const INITIAL_STATE = {
     error: null,
     toolInputDeltas: {},
 };
-export function useRunStream(transport) {
+export function useRunStream({ transport }) {
     const [state, setState] = useState(INITIAL_STATE);
     const subscriptionAbortRef = useRef(null);
     const cancelAbortRef = useRef(null);

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

@@ -28,6 +28,8 @@ export interface UseToolTimelineResult {
     expandAll: () => void;
     collapseAll: () => void;
 }
-export declare function useToolTimeline(events: AgentEvent[] | undefined, options?: UseToolTimelineOptions): UseToolTimelineResult;
+export declare function useToolTimeline({ events }: {
+    events: AgentEvent[] | undefined;
+}, options?: UseToolTimelineOptions): UseToolTimelineResult;
 export {};
 //# sourceMappingURL=useToolTimeline.d.ts.map

package/dist/react/hooks/useToolTimeline.js

@@ -10,17 +10,17 @@
  */
 import { useCallback, useMemo, useState } from 'react';
 import { dedupeToolUsesById, deriveToolStatus } from '../../core/index.js';
-export function useToolTimeline(events, options = {}) {
+export function useToolTimeline({ events }, options = {}) {
     const { runStreaming = false, runSucceeded = false, defaultExpanded = false } = options;
     const [overrides, setOverrides] = useState({});
-    const deduped = useMemo(() => dedupeToolUsesById(events), [events]);
+    const deduped = useMemo(() => dedupeToolUsesById({ events: events }), [events]);
     const rows = useMemo(() => {
         const out = [];
         for (const ev of deduped) {
             if (ev.kind !== 'tool_use')
                 continue;
             const result = deduped.find((r) => r.kind === 'tool_result' && r.toolUseId === ev.id);
-            const status = deriveToolStatus(result, runStreaming, runSucceeded);
+            const status = deriveToolStatus({ result: result, runStreaming: runStreaming }, { runSucceeded: runSucceeded });
             out.push({
                 id: ev.id,
                 name: ev.name,

package/dist/react/index.d.ts

@@ -2,11 +2,11 @@
  * @jini-ai/chat-react — headless hooks + presentational components + slots for
  * a chat/artifact frontend, built on `@jini-ai/chat/core`'s framework-free
  * vocabulary. See ADS-memory/reports/jini-port/recon/r4b-webui-design.md §1/§2/§4 for the
- * spec this package implements, and source-map.md for provenance.
+ * spec this package implements, and archived provenance ledger for provenance.
  *
  * This barrel is filled in incrementally as each layer lands (hooks first,
  * then presentational components, then the `<JiniChatProvider>` composition
- * root) — see source-map.md's "Status" section for what's shipped so far.
+ * root) — see archived provenance ledger's "Status" section for what's shipped so far.
  *
  * ## Every export here is explicit. Do not reintroduce `export *`.
  *
@@ -104,7 +104,7 @@ export { TodoCard } from './components/TodoCard.js';
 export type { TodoCardProps } from './components/TodoCard.js';
 /**
  * The conversation switcher — new / select / delete / search / rename-on-double-click. Storage
- * agnostic: it takes data plus callbacks, so a host backs it with `@jini-ai/sqlite`'s
+ * agnostic: it takes data plus callbacks, so a host backs it with `@jini-ai/sqlite-chat`'s
  * `ChatHistoryStore`, an HTTP endpoint, or a plain array. Drop it into `ChatPane`'s
  * `leadingAccessory` slot; it needs no changes to `ChatPane` itself.
  */
@@ -153,6 +153,6 @@ export type { JiniChatProviderProps, JiniChatSlots } from './components/JiniChat
  * extraction — re-exported here so existing `@jini-ai/chat-react` importers keep working.
  */
 export { createFrontendSessionBridge } from './agent-bridge/frontend-session-bridge.js';
-export type { FrontendSessionBridge, FrontendSessionBridgeOptions, } from './agent-bridge/frontend-session-bridge.js';
+export type { FrontendSessionBridge, FrontendSessionBridgeArgs, FrontendSessionBridgeOptions, } from './agent-bridge/frontend-session-bridge.js';
 export { createDomPageDriver, currentAgentPage, type DomPageDriverOptions } from '@jini-ai/agentic/dom';
 //# sourceMappingURL=index.d.ts.map

package/dist/react/index.js

@@ -14,11 +14,11 @@ export { clearExtEventRenderers, extEventSlot, getExtEventRenderer, registerExtE
 // this package's re-export. See ADS-memory/reports/refactor/2026-08-05-ref-001-steps-bcd-proposal.md
 // §2.4 for the full trace and §9 for the re-confirmation against the post-BYOK tree.
 //
-// The feature itself is not deleted — `./features/model-picker/index.js` still exists and still
-// works for anything inside this package that wants it (nothing currently does). This removes only
-// the root barrel's re-export of it. A future consumer that genuinely needs it gets a real ADR-worthy
-// decision (its own subpath, most likely, following Step C's pattern) instead of a standing
-// "just in case" export nobody asked for.
+// The unused feature was deleted on 2026-10-02 after re-confirming that no import or export
+// outside its own tests reached it. Model/provider selection belongs to the host-injected
+// `ModelAgentPickerSlot`, not chat's domain. A future standalone picker needs a real consumer
+// and an explicit API decision (its own subpath, most likely, following Step C's pattern)
+// instead of a standing "just in case" export nobody asked for.
 /**
  * @deprecated REF-001 Step C (2026-08-05): `ChatPane` and its companions moved to their own
  * subpath, `@jini-ai/chat/react/chat-pane` — import from there in new code. Re-exported here,
@@ -80,7 +80,7 @@ export { interleaveMessageBlocks } from './message-blocks.js';
 export { TodoCard } from './components/TodoCard.js';
 /**
  * The conversation switcher — new / select / delete / search / rename-on-double-click. Storage
- * agnostic: it takes data plus callbacks, so a host backs it with `@jini-ai/sqlite`'s
+ * agnostic: it takes data plus callbacks, so a host backs it with `@jini-ai/sqlite-chat`'s
  * `ChatHistoryStore`, an HTTP endpoint, or a plain array. Drop it into `ChatPane`'s
  * `leadingAccessory` slot; it needs no changes to `ChatPane` itself.
  */

package/dist/react/message-blocks.d.ts

@@ -84,8 +84,14 @@ export type MessageBlock<Row> = {
  */
 export declare function interleaveMessageBlocks<Row extends {
     id: string;
-}>(events: readonly AgentEvent[] | undefined, content: string, rows: readonly Row[], slotOf?: (ev: {
-    readonly name: string;
-    readonly data: unknown;
-}) => string): MessageBlock<Row>[] | null;
+}>({ events, content, rows }: {
+    events: readonly AgentEvent[] | undefined;
+    content: string;
+    rows: readonly Row[];
+}, { slotOf }?: {
+    slotOf?: (ev: {
+        readonly name: string;
+        readonly data: unknown;
+    }) => string;
+}): MessageBlock<Row>[] | null;
 //# sourceMappingURL=message-blocks.d.ts.map

package/dist/react/message-blocks.js

@@ -11,7 +11,7 @@ import { assistantContentFromEvents, legacyAssistantContentFromEvents } from '..
  * @returns Ordered blocks, or `null` to signal "render the flat layout instead".
  * @complexity O(n + m) in the event and row counts.
  */
-export function interleaveMessageBlocks(events, content, rows, slotOf = (ev) => ev.name) {
+export function interleaveMessageBlocks({ events, content, rows }, { slotOf = (ev) => ev.name } = {}) {
     if (!events || events.length === 0)
         return null;
     const hasExtEvent = events.some((ev) => ev.kind === 'ext');
@@ -21,7 +21,7 @@ export function interleaveMessageBlocks(events, content, rows, slotOf = (ev) =>
     // was built from. Anything else and the offsets below are fiction.
     // Both producers' shapes count: today's (a paragraph break between steps, see
     // `assistantContentFromEvents`) and the old plain concatenation older saved rows carry.
-    if (content !== assistantContentFromEvents(events) && content !== legacyAssistantContentFromEvents(events))
+    if (content !== assistantContentFromEvents({ events }) && content !== legacyAssistantContentFromEvents({ events: events }))
         return null;
     const rowById = new Map(rows.map((row) => [row.id, row]));
     const blocks = [];

package/dist/react/styles/reference.css

@@ -1,9 +1,9 @@
 /**
  * @jini-ai/chat-react reference stylesheet — structural layout only.
  *
- * NOT applied by default and not exported by package.json — see this package's README for why.
+ * Not applied by default; exported for opt-in use — see this package's README for why.
  * Kept here as a documented starting point for a host writing their own CSS against this
- * package's `jini-*` class names, not as something to `import` as-is.
+ * package's `jini-*` class names. Hosts may import it explicitly for structural layout.
  *
  * Every rule here exists because, without it, a plain-HTML default (inline elements that don't
  * stack, an inline-block that doesn't shrink to fit a narrow parent, a block box that forces a
@@ -153,7 +153,7 @@
 /* ---- ChatPane (features/chat-pane/react/components/ChatPane.tsx) ---- */
 
 /*
- * The two traps from tovu-learnings.md §7:
+ * The two layout traps recorded during host integration (§7 of the original learning notes):
  *
  * __controls wraps the suggestions row, status banners, and composer area (via
  * ChatPaneComposerArea's fragment) as siblings. It renders with no inline style at all, so a

package/dist/react/tool-renderer-registry.d.ts

@@ -34,8 +34,13 @@ export type ToolRenderer = (props: ToolRenderProps) => ReactNode;
  * against `tool_use.name`. Re-registering the same name overwrites — last
  * writer wins.
  */
-export declare function registerToolRenderer(name: string, renderer: ToolRenderer): () => void;
-export declare function getToolRenderer(name: string): ToolRenderer | undefined;
+export declare function registerToolRenderer({ name, renderer }: {
+    name: string;
+    renderer: ToolRenderer;
+}): () => void;
+export declare function getToolRenderer({ name }: {
+    name: string;
+}): ToolRenderer | undefined;
 /** Visible mainly for tests. */
-export declare function clearToolRenderers(): void;
+export declare function clearToolRenderers(_requiredArgs: Record<string, never>): void;
 //# sourceMappingURL=tool-renderer-registry.d.ts.map

package/dist/react/tool-renderer-registry.js

@@ -5,18 +5,18 @@ const renderers = new Map();
  * against `tool_use.name`. Re-registering the same name overwrites — last
  * writer wins.
  */
-export function registerToolRenderer(name, renderer) {
+export function registerToolRenderer({ name, renderer }) {
     renderers.set(name, renderer);
     return () => {
         if (renderers.get(name) === renderer)
             renderers.delete(name);
     };
 }
-export function getToolRenderer(name) {
+export function getToolRenderer({ name }) {
     return renderers.get(name);
 }
 /** Visible mainly for tests. */
-export function clearToolRenderers() {
+export function clearToolRenderers(_requiredArgs) {
     renderers.clear();
 }
 //# sourceMappingURL=tool-renderer-registry.js.map

package/dist/react/util/defined-props.d.ts

@@ -27,5 +27,7 @@ export type DefinedProps<T> = {
  *
  * @complexity Time: O(n) in the key count; space: O(n) for the returned object.
  */
-export declare function definedProps<T extends object>(source: T): DefinedProps<T>;
+export declare function definedProps<T extends object>({ source }: {
+    source: T;
+}): DefinedProps<T>;
 //# sourceMappingURL=defined-props.d.ts.map

package/dist/react/util/defined-props.js

@@ -17,7 +17,7 @@
  *
  * @complexity Time: O(n) in the key count; space: O(n) for the returned object.
  */
-export function definedProps(source) {
+export function definedProps({ source }) {
     const result = {};
     for (const [key, value] of Object.entries(source)) {
         if (value !== undefined)

package/dist/server/run-finalizer/entry.d.ts

@@ -0,0 +1,47 @@
+import type { Clock } from '@jini-ai/core/primitives';
+/** Saves completed run output independently of a connected client, through host ports. */
+import type { ChatMessage } from '../../core/messages.js';
+import { type RunNotices } from '../../core/run-events/entry.js';
+import type { RunDaemonClient, RunLedger, Scheduler, RunIdClassifier } from './ports.js';
+export type { RunDaemonClient, RunLedger, Scheduler, RunIdClassifier, RunRef, RunProgress, RunSettlement } from './ports.js';
+/** All infrastructure and host messages are explicit; this factory opens no storage. */
+export interface AssistantRunFinalizerArgs {
+    readonly ledger: RunLedger;
+    readonly daemon: RunDaemonClient;
+    readonly clock: Clock;
+    readonly scheduler: Scheduler;
+    readonly runIdClassifier: RunIdClassifier;
+    readonly notices: RunNotices;
+    readonly onError: (args: {
+        operation: 'checkpoint' | 'watch';
+        runId: string;
+        error: unknown;
+    }) => void;
+}
+/** Reconnect delay: 2000ms; retry count: 30; checkpoint interval: 1000ms. */
+export interface AssistantRunFinalizerOptions {
+    readonly reconnectDelayMs?: number;
+    readonly maxReconnects?: number;
+    readonly checkpointIntervalMs?: number;
+}
+export interface AssistantRunFinalizer {
+    /** Ignore non-assistant, terminal, missing-status and externally held runs; deduplicate by run ID. */
+    watch(input: {
+        principalId: string;
+        conversationId: string;
+        message: ChatMessage;
+    }): void;
+    /** Wait for current watches to finish; terminal writes may overtake pending checkpoints. */
+    idle(args: Record<string, never>): Promise<void>;
+    activeCount(args: Record<string, never>): number;
+}
+/** Follow replayable run streams and save through atomic host ledger operations.
+ * The host retains authorization, owner scope, kernel transactions, boot reconciliation, HTTP
+ * credentials and excluded run-ID prefixes. Replay starts at zero; error-before-success and
+ * reconnect exhaustion must not falsely settle a run. Checkpoints are throttled with a trailing
+ * write, and checkpoint/settle atomically reject other runs or terminal rows: first terminal wins.
+ * Frame vocabulary, paragraph boundaries and compaction are shared with the run-event reducer.
+ * Non-success bodies are cancelled and progress scheduling stops at completion. Real database
+ * restart/race coverage remains a host responsibility; this factory never opens storage. */
+export declare function createAssistantRunFinalizer(args: AssistantRunFinalizerArgs, options?: AssistantRunFinalizerOptions): AssistantRunFinalizer;
+//# sourceMappingURL=entry.d.ts.map