@jini-ai/chat 0.6.7 → 0.6.11

package/CHANGELOG.md

@@ -1,3 +1,137 @@
+## 0.6.11
+
+### Patch Changes
+
+- Honest turn footers (done / stopped / interrupted), answered question cards keep their question and chosen labels, readable conversation titles and counts; the usage tooltip reads "N output tokens".
+- Mid-run message relay for MCP-bridged engines (Codex, ACP, Antigravity): `registerMessageRelayRoutes` on `@jini-ai/daemon/http`; mid-run messages queue instead of interrupting, and recovery waits on an uncertain probe.
+- Updated dependencies
+- Updated dependencies
+  - @jini-ai/core@0.6.11
+
+## 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 +252,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 +341,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/accepted-input.d.ts

@@ -3,6 +3,8 @@ import type { ChatAttachment, ChatMessage } from './messages.js';
 export interface AcceptedChatInput {
     id: string;
     text: string;
+    /** Absent for legacy/ordinary inputs; consumed only after a CLI UUID receipt. */
+    deliveryState?: 'queued' | 'consumed';
     attachments?: ChatAttachment[];
     secretRedaction?: ChatMessage['secretRedaction'];
     /** Wire ids replaced by this receipt remain seen by recall. */

package/dist/core/accepted-input.js

@@ -50,8 +50,16 @@ function expandQuestionAnswers({ events }, _options = {}) {
     }));
     // MOVE: Persisted picks carry values; the original tool input retains their human-readable labels.
     const questions = new Map(events.flatMap(event => event.kind === 'tool_use' ? [[event.id, event.input]] : []));
-    return events.flatMap(event => {
+    const answers = new Map(events.flatMap(event => {
         const answer = questionAnswerEvent({ event, input: event.kind === 'tool_result' ? questions.get(event.toolUseId) : undefined });
+        return answer ? [[answer.data.toolUseId, answer]] : [];
+    }));
+    return events.flatMap(event => {
+        const receipt = acceptedInputEvent({ event });
+        const recorded = receipt?.data.toolUseId ? answers.get(receipt.data.toolUseId) : undefined;
+        if (receipt && recorded)
+            return [{ ...receipt, data: { ...receipt.data, text: recorded.data.text } }];
+        const answer = event.kind === 'tool_result' ? answers.get(event.toolUseId) : undefined;
         return answer && !savedAnswers.has(answer.data.toolUseId) ? [event, answer] : [event];
     });
 }
@@ -81,7 +89,7 @@ function matchOptimisticInput({ input, optimistic, seen }, _options = {}) {
 }
 function mergeAcceptedReceipt({ input, pending }, _options = {}) {
     return { ...input, data: { ...input.data, id: pending.data.id,
-            ...(pending.data.inputs ? { inputs: pending.data.inputs } : {}),
+            ...(pending.data.inputs ? { inputs: pending.data.inputs.map(item => ({ ...item, ...(input.data.deliveryState ? { deliveryState: input.data.deliveryState } : {}) })) } : {}),
             aliases: [...new Set([...(input.data.aliases ?? []), input.data.id, ...(pending.data.aliases ?? [])])] } };
 }
 function acceptedInputIds({ input }, _options = {}) {
@@ -114,13 +122,36 @@ function advanceOptimisticInput({ input, optimistic }, _options = {}) {
     if (candidates && !input.data.toolUseId)
         candidates.index += 1;
 }
+/** Fold state updates into the original bubble, preserving its position, local id and aliases.
+ * O(e + a + i) time/space for events, receipt aliases and expanded input constituents; equal text never establishes identity. */
+function collapseDeliveryReceipts({ events }, _options = {}) {
+    const result = [];
+    const positions = new Map();
+    for (const event of events) {
+        const input = acceptedInputEvent({ event });
+        const position = input ? positions.get(input.data.id) : undefined;
+        if (input && position !== undefined && input.data.deliveryState) {
+            const original = acceptedInputEvent({ event: result[position] });
+            // Replayed queue acceptance cannot undo confirmed consumption.
+            const deliveryState = original.data.deliveryState === 'consumed' ? 'consumed' : input.data.deliveryState;
+            result[position] = { ...original, data: { ...original.data, deliveryState,
+                    ...(original.data.inputs ? { inputs: original.data.inputs.map(input => ({ ...input, deliveryState })) } : {}) } };
+            continue;
+        }
+        if (input)
+            for (const id of acceptedInputIds({ input }))
+                positions.set(id, result.length);
+        result.push(event);
+    }
+    return result;
+}
 /** Projects saved answers and reconciles optimistic bubbles with wire events, occurrence for
  * occurrence. Legacy steering receipts have no client id: only unmatched optimistic input may
  * match by text; two real events with equal text always remain distinct.
  * @complexity O(e + u + a) time, O(e + u) space for e events, u user inputs and total answer-label lookup cost a.
  */
 export function projectAcceptedInputEvents({ events }, _options = {}) {
-    const expanded = expandQuestionAnswers({ events });
+    const expanded = expandQuestionAnswers({ events: collapseDeliveryReceipts({ events }) });
     const optimistic = collectOptimisticInputs({ events: expanded });
     const state = { replacements: new Map(), replaced: new Set(), seen: new Set() };
     for (const event of expanded)

package/dist/core/assistant-client/durable-run-subscription.d.ts

@@ -17,7 +17,7 @@ export interface DurableSubscriptionPorts {
         runId: string;
         cursor: string;
         frame: (kind: string, data: string, cursor: string) => void;
-        dropped: () => void;
+        dropped: (reason?: string) => void;
     }, optional: {}) => () => void;
     readonly schedule: (required: {
         work: () => void;
@@ -37,6 +37,8 @@ export declare function followDurableRun({ runId: initialRunId, handlers, signal
     ports: DurableSubscriptionPorts;
     notices: RunNotices;
     bindings: Map<string, DurableRunBinding>;
-}, _optional?: {}): () => void;
+}, { logger }?: {
+    logger?: Pick<Console, "info">;
+}): () => void;
 export {};
 //# sourceMappingURL=durable-run-subscription.d.ts.map

package/dist/core/assistant-client/durable-run-subscription.js

@@ -1,18 +1,21 @@
 import { translateRunFrame } from "../run-events/entry.js";
 /** SSE is a view of one attempt. The saved message owns terminal state and can point at a new
  * attempt after recovery; neither a browser 404 nor a closed stream may fail the logical run. */
-export function followDurableRun({ runId: initialRunId, handlers, signal, binding, ports, notices, bindings }, _optional = {}) {
+export function followDurableRun({ runId: initialRunId, handlers, signal, binding, ports, notices, bindings }, { logger = console } = {}) {
+    let streamEpoch = 0;
     let runId = initialRunId;
     let cursor = "";
     let stopped = false;
     let reading = false;
     let recoveryPending = true;
     let dropped = false;
+    let reconnectDelayMs = 0;
     let stopStream;
     let stopTimer;
     let messageId = binding?.messageId;
     function stop() {
         stopped = true;
+        streamEpoch += 1;
         stopStream?.();
         stopTimer?.();
         signal?.removeEventListener("abort", stop);
@@ -25,15 +28,42 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
         handlers.onDone(message.events ?? []);
     }
     function open() {
+        const epoch = ++streamEpoch;
         dropped = false;
         stopStream?.();
-        stopStream = ports.stream({ runId, cursor, frame, dropped: () => { dropped = true; recoveryPending = true; void read().catch(() => undefined); } }, {});
+        stopStream = ports.stream({ runId, cursor,
+            frame: (...args) => { if (epoch === streamEpoch)
+                frame(...args); },
+            dropped: reason => { if (epoch === streamEpoch)
+                disconnected(reason); },
+        }, {});
+    }
+    /** One timer owns reconnects, including faults during a checkpoint read. No cursor reset. */
+    function disconnected(reason = "stream-error") {
+        if (stopped || dropped)
+            return;
+        dropped = true;
+        streamEpoch += 1;
+        recoveryPending = true;
+        reconnectDelayMs = Math.min(30_000, Math.max(1_000, reconnectDelayMs * 2));
+        // Metadata only: neither frame contents nor saved user messages belong in transport logs.
+        logger.info("[durable-subscription] " + JSON.stringify({ runId, reason, cursor, retryDelayMs: reconnectDelayMs }));
+        stopStream?.();
+        if (!reading)
+            scheduleRead();
+    }
+    function scheduleRead() {
+        stopTimer?.();
+        stopTimer = ports.schedule({ work: () => void read().catch(() => undefined), delayMs: dropped ? reconnectDelayMs : 1_000 }, {});
     }
     function frame(kind, data, nextCursor) {
         if (stopped)
             return;
-        if (nextCursor)
+        if (nextCursor) {
+            if (nextCursor !== cursor)
+                reconnectDelayMs = 0;
             cursor = nextCursor;
+        }
         const outcome = translateRunFrame({ kind, raw: data, notices }, {});
         // An attempt's error/end may be followed by a continuation. Only the row can finalize it.
         if (outcome.terminal || outcome.error) {
@@ -70,10 +100,8 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
         finally {
             reading = false;
             if (!stopped) {
-                if (recoveryPending)
-                    void read().catch(() => undefined);
-                else
-                    stopTimer = ports.schedule({ work: () => void read().catch(() => undefined), delayMs: 1_000 }, {});
+                // Always schedule: an error arriving during read must not create a tight recovery loop.
+                scheduleRead();
             }
         }
     }
@@ -87,6 +115,7 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
         if (message.runId && message.runId !== runId) {
             runId = message.runId;
             cursor = "";
+            reconnectDelayMs = 0;
             if (binding)
                 bindings.set(runId, binding);
             dropped = true;

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/core/persistence/title.d.ts

@@ -10,18 +10,12 @@
  * better title asks its agent for one later and calls `rename(id, title, 'generated')`; the
  * store refuses to overwrite a `manual` title, so a user's own rename always wins.
  *
- * Ported from Open Design's `summarizeProjectNameFromPrompt` (`apps/web/src/utils/projectName.ts`),
- * which this generalizes from project names to conversation titles. Its behaviour is preserved
- * deliberately — including the CJK path, which is not decoration: the filler and punctuation
- * rules for Chinese prompts differ enough from the Latin ones that a shared code path produced
- * visibly worse titles in both.
- *
- * Two intentional divergences from the original, both fixing output the original gets wrong; each
- * is documented at its own declaration below:
- *   1. `LEADING_LATIN_FILLER` requires the separator inside the article group. The original's form
- *      let a bare `a` eat the first letter of the next word ("update app.tsx" → "Pp Tsx").
- *   2. `LATIN_NEVER_TRAILING` trims function words off the end. The original's word cap lands
- *      mid-clause on question-shaped prompts and strands them ("...Posts Do I").
+ * Ported from Open Design's `summarizeProjectNameFromPrompt` (`apps/web/src/utils/projectName.ts`).
+ * The Latin path has since diverged: it keeps the prompt's words, names and dotted domains (the
+ * original's stop-word removal and title casing turned "port example.com to jini" into "Port
+ * Example Com Jini"), and `LEADING_LATIN_FILLER` fixes the original's article bug, documented at
+ * its declaration. The CJK path keeps the original's filler and punctuation rules, which is not
+ * decoration: they differ enough from the Latin ones that a shared path produced worse titles in both.
  */
 /** Remove presentation markup from title text while preserving link labels and inline code.
  * Shared by prompt derivation, stored-title display and product naming adapters; no DOM or I/O.
@@ -45,10 +39,8 @@ export declare function stripConversationTitleMarkdown({ text }: {
  */
 export declare function deriveConversationTitle({ prompt }: {
     prompt: string;
-}, { casing }?: {
-    casing?: 'title' | 'sentence';
-}): string;
-/** Sentence-case only a known heuristic title using the original prompt's proper names/acronyms.
+}, _optional?: Record<string, never>): string;
+/** A known heuristic title is already display-ready: derivation keeps the prompt's own wording.
  * Manual names, model-authored names and unloaded transcripts keep their saved wording, with
  * presentation markup removed and the display ceiling applied; no writes.
  * @complexity O(n) time/space in the first prompt's length, using the existing bounded heuristic.

package/dist/core/persistence/title.js

@@ -10,26 +10,19 @@
  * better title asks its agent for one later and calls `rename(id, title, 'generated')`; the
  * store refuses to overwrite a `manual` title, so a user's own rename always wins.
  *
- * Ported from Open Design's `summarizeProjectNameFromPrompt` (`apps/web/src/utils/projectName.ts`),
- * which this generalizes from project names to conversation titles. Its behaviour is preserved
- * deliberately — including the CJK path, which is not decoration: the filler and punctuation
- * rules for Chinese prompts differ enough from the Latin ones that a shared code path produced
- * visibly worse titles in both.
- *
- * Two intentional divergences from the original, both fixing output the original gets wrong; each
- * is documented at its own declaration below:
- *   1. `LEADING_LATIN_FILLER` requires the separator inside the article group. The original's form
- *      let a bare `a` eat the first letter of the next word ("update app.tsx" → "Pp Tsx").
- *   2. `LATIN_NEVER_TRAILING` trims function words off the end. The original's word cap lands
- *      mid-clause on question-shaped prompts and strands them ("...Posts Do I").
+ * Ported from Open Design's `summarizeProjectNameFromPrompt` (`apps/web/src/utils/projectName.ts`).
+ * The Latin path has since diverged: it keeps the prompt's words, names and dotted domains (the
+ * original's stop-word removal and title casing turned "port example.com to jini" into "Port
+ * Example Com Jini"), and `LEADING_LATIN_FILLER` fixes the original's article bug, documented at
+ * its declaration. The CJK path keeps the original's filler and punctuation rules, which is not
+ * decoration: they differ enough from the Latin ones that a shared path produced worse titles in both.
  */
-const MAX_LATIN_WORDS = 6;
 const MAX_CJK_LENGTH = 18;
 /**
  * Hard character ceiling, because a word cap is not a length cap.
  *
- * Six "words" says nothing about their size: a pasted base64 blob or minified bundle is a single
- * enormous token, so it survived the word cap intact and became the title verbatim. That title is
+ * A word boundary says nothing about token size: a pasted base64 blob or minified bundle is a single
+ * enormous token, so it must not survive intact and become the title verbatim. That title is
  * then stored, listed, and re-rendered on every conversation-list read — megabytes of it. Applied to
  * the finished title so both the Latin and CJK paths are covered.
  */
@@ -51,33 +44,9 @@ const LEADING_CJK_FILLER = [
     /^(先)?(实现|做|做一下|创建|生成|设计|开发|新增|添加|优化|修复|改|更改|调整)(一下|一个|一版|下)?/,
     /^(一个|一份|这个|那个)/,
 ];
-const LATIN_STOP_WORDS = new Set([
-    'a', 'an', 'and', 'for', 'in', 'of', 'on', 'please', 'the', 'to', 'with', 'my',
-]);
-/**
- * Function words that are fine *inside* a title but never acceptable as its last word.
- *
- * These cannot go in `LATIN_STOP_WORDS`, because removing them everywhere mangles real titles —
- * "how many posts do I have" would lose the "how many" that makes it a question, and a prompt like
- * "make it work" would reduce to "Work". The problem is specifically the word-cap boundary: a
- * question-shaped prompt reliably spends its six words before reaching the noun, so the title got
- * cut mid-clause. Observed live: "how many published posts do I have?" produced
- * "How Many Published Posts Do I" — a dangling auxiliary plus a stranded pronoun, which in a narrow
- * dock also wrapped to leave a lone "I" on its own line.
- *
- * Trimming only the tail is what makes this safe: it can never shorten a title that already ended
- * on a content word, so no existing good title changes.
- */
-const LATIN_NEVER_TRAILING = new Set([
-    'do', 'does', 'did', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-    'have', 'has', 'had', 'can', 'could', 'should', 'would', 'will', 'shall', 'may', 'might', 'must',
-    'i', 'me', 'you', 'we', 'us', 'it', 'they', 'them', 'he', 'she',
-    'that', 'this', 'these', 'those', 'but', 'or', 'if', 'then', 'than', 'as', 'at', 'by',
-    'from', 'into', 'about', 'so', 'just', 'also', 'too', 'up', 'out',
-]);
 /**
  * Strips the parts of a prompt that are never a good title: fenced code, URLs, and
- * `@handle`/`#tag` tokens. Each of these is high-entropy and low-meaning in a six-word summary.
+ * `@handle`/`#tag` tokens. Each of these is high-entropy and low-meaning in a short summary.
  * Inline code keeps its label with delimiters removed, so a filename can still name the task.
  */
 function cleanPrompt(prompt) {
@@ -114,7 +83,8 @@ export function stripConversationTitleMarkdown({ text }, _options = {}) {
         .trim();
 }
 /** Keep complete words at the display ceiling. A single oversized token still gets a bounded
- * prefix: pasted blobs must never become megabyte-sized stored/listed titles.
+ * prefix: pasted blobs must never become megabyte-sized stored/listed titles. The old six-word cap
+ * stranded auxiliaries and pronouns mid-clause; the character ceiling leaves short questions whole.
  * @complexity O(n) time/space, bounded by the title ceiling after the initial length check.
  */
 function truncateTitle(title) {
@@ -126,24 +96,11 @@ function truncateTitle(title) {
     const lastSpace = prefix.lastIndexOf(' ');
     return (lastSpace > 0 ? prefix.slice(0, lastSpace) : prefix).trimEnd();
 }
-/** Callers pass only non-empty words (`trimLatinTitle` filters blanks before mapping). */
-function toTitleCase(word) {
-    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-}
-function trimLatinTitle(input, { casing }) {
-    const words = input
-        .replace(LEADING_LATIN_FILLER, '')
-        .replace(/[^\p{L}\p{N}\s-]/gu, ' ')
-        .split(/\s+/)
-        .filter(Boolean)
-        .filter((word) => !LATIN_STOP_WORDS.has(word.toLowerCase()))
-        .slice(0, MAX_LATIN_WORDS);
-    // Applied after the cap, because the cap is what strands these words in the first place.
-    while (words.length > 0 && LATIN_NEVER_TRAILING.has(words[words.length - 1].toLowerCase())) {
-        words.pop();
-    }
-    const title = casing === 'title' ? words.map(toTitleCase).join(' ') : words.join(' ');
-    return title ? title.charAt(0).toUpperCase() + title.slice(1) : title;
+function trimLatinTitle(input) {
+    const words = input.replace(LEADING_LATIN_FILLER, '').match(/[\p{L}\p{N}]+(?:[._-][\p{L}\p{N}]+)*/gu) ?? [];
+    const title = words.join(' ');
+    // Domain and filename tokens retain their original case, even at the start of a sentence.
+    return words[0]?.includes('.') ? title : title.charAt(0).toUpperCase() + title.slice(1);
 }
 function trimCjkTitle(input) {
     let title = input.trim();
@@ -161,7 +118,7 @@ function trimCjkTitle(input) {
  *
  * @complexity O(n) in prompt length; no allocation beyond the intermediate strings.
  */
-export function deriveConversationTitle({ prompt }, { casing = 'title' } = {}) {
+export function deriveConversationTitle({ prompt }, _optional = {}) {
     const cleaned = cleanPrompt(prompt);
     if (!cleaned)
         return '';
@@ -169,12 +126,12 @@ export function deriveConversationTitle({ prompt }, { casing = 'title' } = {}) {
     const firstClause = cleaned.split(/[\n\r。！？!?]/)[0].trim();
     if (!firstClause)
         return '';
-    const title = CJK_PATTERN.test(firstClause) ? trimCjkTitle(firstClause) : trimLatinTitle(firstClause, { casing });
+    const title = CJK_PATTERN.test(firstClause) ? trimCjkTitle(firstClause) : trimLatinTitle(firstClause);
     // Truncated without an ellipsis: this is a working title, not prose, and a `…` would end up stored
     // and shown as if the author wrote it.
     return truncateTitle(title);
 }
-/** Sentence-case only a known heuristic title using the original prompt's proper names/acronyms.
+/** A known heuristic title is already display-ready: derivation keeps the prompt's own wording.
  * Manual names, model-authored names and unloaded transcripts keep their saved wording, with
  * presentation markup removed and the display ceiling applied; no writes.
  * @complexity O(n) time/space in the first prompt's length, using the existing bounded heuristic.
@@ -183,7 +140,7 @@ export function conversationTitleForDisplay({ title, titleSource, firstPrompt },
     if (!title)
         return title;
     if (titleSource === 'generated' && firstPrompt && title === deriveConversationTitle({ prompt: firstPrompt })) {
-        return deriveConversationTitle({ prompt: firstPrompt }, { casing: 'sentence' });
+        return title;
     }
     return truncateTitle(stripConversationTitleMarkdown({ text: title })) || null;
 }

package/dist/core/question-answer.js

@@ -15,11 +15,11 @@ function selectedAnswerText({ result, input }, _options = {}) {
     const question = record(input);
     const labels = [];
     if (typeof result.choice === 'string')
-        labels.push(optionLabel(question.singleSelect, result.choice));
+        labels.push(optionLabel(question.singleSelect ?? question, result.choice));
     if (Array.isArray(result.selections)) {
         for (const selection of result.selections) {
             if (typeof selection === 'string')
-                labels.push(optionLabel(question.multiSelect, selection));
+                labels.push(optionLabel(question.multiSelect ?? question, selection));
         }
     }
     if (labels.length > 0)

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

@@ -53,7 +53,7 @@ export declare function asString({ value }: {
  * `mcp-ui`/`a2ui` cases (each a one-line unwrap, zero branching — see their own comments below) for
  * a cost that actually came from here.
  */
-/** Keep only numeric usage fields; omit absent fields without changing JSON output. */
+/** Keep numeric usage and the model's stop reason; omit absent or malformed fields. */
 export declare function parseUsageEvent({ payload }: {
     payload: RunAgentPayload;
 }, _options?: Record<string, never>): AgentEvent;

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

@@ -25,7 +25,7 @@ export function asString({ value }, _options = {}) {
  * `mcp-ui`/`a2ui` cases (each a one-line unwrap, zero branching — see their own comments below) for
  * a cost that actually came from here.
  */
-/** Keep only numeric usage fields; omit absent fields without changing JSON output. */
+/** Keep numeric usage and the model's stop reason; omit absent or malformed fields. */
 export function parseUsageEvent({ payload }, _options = {}) {
     const usage = (payload.usage ?? {});
     return {
@@ -36,6 +36,7 @@ export function parseUsageEvent({ payload }, _options = {}) {
         ...(typeof payload.cumulativeCostUsd === "number" ? { cumulativeCostUsd: payload.cumulativeCostUsd } : {}),
         ...(typeof payload.costSessionId === "string" ? { costSessionId: payload.costSessionId } : {}),
         ...(typeof payload.durationMs === "number" ? { durationMs: payload.durationMs } : {}),
+        ...(typeof payload.stopReason === "string" ? { stopReason: payload.stopReason } : {}),
     };
 }
 /**

package/dist/core/turn-usage.js

@@ -5,6 +5,18 @@ export const MID_RUN_USER_MESSAGE_EVENT_NAME = 'user_message';
 export function isReplyBoundary({ event }, _optional = {}) {
     return event.kind === 'ext' && event.name === MID_RUN_USER_MESSAGE_EVENT_NAME;
 }
+/** Queued/consumed receipts update one input, so usage must split that reply only once. */
+function newReplyBoundary({ event, seen }, _options = {}) {
+    if (!isReplyBoundary({ event }))
+        return false;
+    const id = event.data;
+    if (typeof id?.id !== 'string')
+        return true;
+    if (seen.has(id.id))
+        return false;
+    seen.add(id.id);
+    return true;
+}
 /** Split one assistant message's events into replies at each mid-run user message. A usage event
  * that lands after a boundary but before the next reply produced anything is the interrupted
  * reply's own result (the daemon notes it can arrive after the interrupt ack), so it stays with
@@ -13,8 +25,9 @@ export function isReplyBoundary({ event }, _optional = {}) {
 export function replySegments({ events }, _optional = {}) {
     const segments = [[]];
     let started = false;
+    const seen = new Set();
     for (const event of events ?? []) {
-        if (isReplyBoundary({ event })) {
+        if (newReplyBoundary({ event, seen })) {
             segments.push([]);
             started = false;
             continue;
@@ -27,7 +40,7 @@ export function replySegments({ events }, _optional = {}) {
 }
 /** Usage, status and raw lines are bookkeeping; anything else means the reply has produced output. */
 function producesReplyOutput({ event }, _optional = {}) {
-    return event.kind !== 'usage' && event.kind !== 'status' && event.kind !== 'raw';
+    return !['usage', 'status', 'raw'].includes(event.kind) && !isReplyBoundary({ event });
 }
 /** Resolve one charge against this agent/session's last snapshot. State is local to an
  * ordered transcript projection; revisiting a session keeps its baseline. A lower snapshot
@@ -61,6 +74,8 @@ export function turnUsage({ events }, { sessions = new Map(), agentId = '' } = {
             continue;
         total ??= { kind: 'usage' };
         addReportedCounts({ total, event });
+        if (event.stopReason !== undefined)
+            total.stopReason = event.stopReason;
         const cost = usageCost({ event, agentId, sessions });
         if (cost !== undefined)
             total.costUsd = (total.costUsd ?? 0) + cost;
@@ -80,6 +95,8 @@ function addUsage({ total, usage }, _optional = {}) {
     if (!usage)
         return total;
     const next = { ...(total ?? { kind: 'usage' }) };
+    if (usage.stopReason !== undefined)
+        next.stopReason = usage.stopReason;
     for (const field of ['inputTokens', 'outputTokens', 'durationMs', 'costUsd']) {
         const value = usage[field];
         if (value !== undefined)