@jini-ai/chat 0.6.19 → 0.6.22

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.6.22
+
+- The full CLI access notice shows once per conversation, also after replay or remount.
+- A validated extension renderer can declare that it shows a failed turn's explanation (`terminalNotice`); the generic notice stays when the renderer is absent or refuses the payload.
+
+## 0.6.21
+
+- Per-chat memory churn stopped: run checkpoints are size-scaled (`checkpointIntervalMs({ bytes })`: 1 s, 3 s from 1 MB, 10 s from 5 MB) and written as guarded SQL deltas (append or text-tail splice under a length+tail receipt), falling back to a full checkpoint on mismatch. A completed checkpoint is never retried unchanged.
+- Leaner reads: message-scoped run heads, lean transcripts for acceptance and recovery, a conditional history read keyed on the connection-wide version, and `hasActiveRuns()` as a single-row probe.
+- Mid-run sends are deduplicated by accepted-input id (two sends with equal text are both kept); Cmd/Ctrl+Enter sends instead of cancelling; "Sending…" clears once the send is accepted; the queued label uses the status pill.
+
 ## 0.6.19
 
 - A direct MCP call (`mcp__<server>__X`, any CLI) shows as one row even when the MCP server normalized its arguments before the bridge saw them: once the CLI's own result has arrived, the call pairs by name with the bridge's `X` row between the two. Equal-input pairing still runs first across the turn; refusals and open calls never pair by name.

package/dist/core/accepted-input.d.ts

@@ -18,7 +18,11 @@ export interface AcceptedChatInput {
 }
 /** Display queue constituents using their accepted identities; storage and delivery retain one turn.
  * MOVE: Receipts travel in events_json, so separate bubbles survive a history reload without another store.
- * @complexity O(m + e + i) time/space for m messages, e receipt events and i accepted queue inputs.
+ * The earlier in-run receipt owns the bubble when an unconsumed fallback also became a user row.
+ * @param messages The already loaded transcript; never fetched or mutated here.
+ * @returns Display rows with queued fallback copies removed by accepted id and aliases, never text.
+ * @complexity O(m + e + i + a) time/space for messages, receipt events, inputs and aliases; no I/O.
+ * @example projectAcceptedInputMessages({ messages });
  */
 export declare function projectAcceptedInputMessages({ messages }: {
     messages: readonly ChatMessage[];
@@ -69,7 +73,11 @@ export declare function acceptedInputUserEvent({ input, inputs, toolUseId, after
 export declare function projectAcceptedInputEvents({ events }: {
     events: readonly AgentEvent[];
 }, options?: AcceptedInputProjectionOptions): AgentEvent[];
-/** The sole transcript-to-recall projection. A merged queued turn retains its original inputs. */
+/** The sole transcript-to-recall projection. A merged queued turn retains its original inputs.
+ * @returns Accepted inputs once by id/alias, in send order; pending input is excluded.
+ * @complexity O(m + e + i + a) time/space for messages, events, inputs and aliases; no I/O.
+ * @example acceptedInputsFromMessages({ messages });
+ */
 export declare function acceptedInputsFromMessages({ messages }: {
     messages: readonly ChatMessage[];
 }, _options?: {}): AcceptedChatInput[];

package/dist/core/accepted-input.js

@@ -3,28 +3,65 @@ import { questionAnswerFromResult, questionAnswerLabel } from './question-answer
 import { MID_RUN_USER_MESSAGE_EVENT_NAME } from './turn-usage.js';
 /** Display queue constituents using their accepted identities; storage and delivery retain one turn.
  * MOVE: Receipts travel in events_json, so separate bubbles survive a history reload without another store.
- * @complexity O(m + e + i) time/space for m messages, e receipt events and i accepted queue inputs.
+ * The earlier in-run receipt owns the bubble when an unconsumed fallback also became a user row.
+ * @param messages The already loaded transcript; never fetched or mutated here.
+ * @returns Display rows with queued fallback copies removed by accepted id and aliases, never text.
+ * @complexity O(m + e + i + a) time/space for messages, receipt events, inputs and aliases; no I/O.
+ * @example projectAcceptedInputMessages({ messages });
  */
 export function projectAcceptedInputMessages({ messages }, _options = {}) {
+    const seen = new Set();
     return messages.flatMap(message => {
-        if (message.role !== 'user')
-            return [message];
-        const inputs = (message.events ?? []).flatMap(event => {
-            const input = acceptedInputEvent({ event });
-            return input ? [input.data] : [];
-        });
-        if (inputs.length === 0)
+        if (message.role !== 'user') {
+            for (const input of inputsFromMessage({ message }))
+                claimAcceptedInput({ input, seen });
             return [message];
-        const turn = { ...message };
-        delete turn.attachments;
-        delete turn.folders;
-        delete turn.secretRedaction;
+        }
+        return expandUserInputMessage({ message, seen });
+    });
+}
+/** Keep the original row fields and per-input files when splitting a batched fallback.
+ * @complexity O(e + i) time/space for the row's events and accepted inputs; no effects.
+ */
+function expandUserInputMessage({ message, seen }, _options = {}) {
+    const inputs = inputsFromMessage({ message: { ...message, inputPending: false } });
+    // Ordinary user rows have no receipt metadata to split.
+    if (!(message.events ?? []).some(event => acceptedInputEvent({ event }))) {
+        return claimAcceptedInput({ input: inputs[0], seen }) ? [message] : [];
+    }
+    return inputs.flatMap((input, index) => {
+        if (!claimAcceptedInput({ input, seen }))
+            return [];
         // MOVE: Older receipts have no per-input files; retain those legacy files on the final bubble.
-        return inputs.map((input, index) => ({ ...turn, id: input.id, content: input.text,
-            folders: input.folders ?? (index === inputs.length - 1 ? message.folders ?? [] : []),
-            attachments: input.attachments ?? (index === inputs.length - 1 ? message.attachments ?? [] : []), ...(input.secretRedaction ? { secretRedaction: input.secretRedaction } : {}) }));
+        const legacyFiles = index === inputs.length - 1 ? message : {};
+        return [userInputRow({ message, input, legacyFiles })];
     });
 }
+/** Expand one accepted input without copying another input's files or redaction metadata.
+ * @returns A display-only row; stored messages and their receipt events remain unchanged.
+ * @complexity O(1) time/space, retaining attachment and folder arrays by reference.
+ */
+function userInputRow({ message, input, legacyFiles }, _options = {}) {
+    const turn = { ...message };
+    delete turn.attachments;
+    delete turn.folders;
+    delete turn.secretRedaction;
+    return { ...turn, id: input.id, content: input.text,
+        folders: input.folders ?? legacyFiles.folders ?? [],
+        attachments: input.attachments ?? legacyFiles.attachments ?? [],
+        ...(input.secretRedaction ? { secretRedaction: input.secretRedaction } : {}) };
+}
+/** Claim the stable identity and all aliases even on a duplicate, so later aliases stay deduplicated.
+ * @returns Whether this is the first occurrence; mutates only the projection's local identity set.
+ * @complexity O(a) time/space for one input's aliases.
+ */
+function claimAcceptedInput({ input, seen }, _options = {}) {
+    const ids = [input.id, ...(input.aliases ?? [])];
+    const duplicate = ids.some(id => seen.has(id));
+    for (const id of ids)
+        seen.add(id);
+    return !duplicate;
+}
 /** Reads the existing event-backed user bubble without depending on a host renderer. */
 export function acceptedInputEvent({ event }, _options = {}) {
     if (event.kind !== 'ext' || event.name !== MID_RUN_USER_MESSAGE_EVENT_NAME)
@@ -237,26 +274,43 @@ function projectEvents({ events }, options) {
     }
     return projected;
 }
-/** The sole transcript-to-recall projection. A merged queued turn retains its original inputs. */
+/** The sole transcript-to-recall projection. A merged queued turn retains its original inputs.
+ * @returns Accepted inputs once by id/alias, in send order; pending input is excluded.
+ * @complexity O(m + e + i + a) time/space for messages, events, inputs and aliases; no I/O.
+ * @example acceptedInputsFromMessages({ messages });
+ */
 export function acceptedInputsFromMessages({ messages }, _options = {}) {
-    return messages.flatMap(message => {
-        if (message.role === 'user') {
-            if (message.inputPending)
-                return [];
-            // Queue constituents travel in events_json, already preserved by the existing chat store.
-            const receipts = (message.events ?? []).flatMap(event => {
-                const input = acceptedInputEvent({ event });
-                return input ? [input.data] : [];
-            });
-            return receipts.length > 0 ? receipts : [{ id: message.id, text: message.content, ...(message.folders ? { folders: message.folders } : {}) }];
-        }
-        return projectAcceptedInputEvents({ events: message.events ?? [] }).flatMap(event => {
-            const input = acceptedInputEvent({ event });
-            if (!input)
-                return [];
-            return input.data.inputs?.map((receipt, index) => index === 0 ? { ...receipt, aliases: input.data.aliases ?? [] } : receipt) ?? [input.data];
-        });
+    const seen = new Set();
+    return messages.flatMap(message => inputsFromMessage({ message }))
+        .filter(input => claimAcceptedInput({ input, seen }));
+}
+/** Read one message's accepted identities, retaining queue constituents and wire aliases.
+ * @complexity O(e + i) time/space for the message's events and expanded inputs; no effects.
+ */
+function inputsFromMessage({ message }, _options = {}) {
+    if (message.inputPending)
+        return [];
+    // Queue constituents travel in events_json, already preserved by the existing chat store.
+    const receipts = projectAcceptedInputEvents({ events: message.events ?? [] }).flatMap(event => {
+        const input = acceptedInputEvent({ event });
+        if (!input)
+            return [];
+        return receiptInputs({ receipt: input });
     });
+    if (message.role !== 'user' || receipts.length > 0)
+        return receipts;
+    return [{ id: message.id, text: message.content, ...(message.folders ? { folders: message.folders } : {}) }];
+}
+/** Expand a batched receipt while retaining the first input's local and transport aliases.
+ * @returns The accepted constituents, or the single receipt; does not mutate either.
+ * @complexity O(i + a) time/space for constituents and first-input aliases.
+ */
+function receiptInputs({ receipt }, _options = {}) {
+    if (!receipt.data.inputs)
+        return [receipt.data];
+    return receipt.data.inputs.map((input, index) => index === 0 ? {
+        ...input, aliases: [...(input.aliases ?? []), ...(receipt.data.aliases ?? [])],
+    } : input);
 }
 /** Preserve folder metadata through existing event JSON storage; no attachment lifecycle or schema.
  * Existing per-input receipts already own queued variants and must retain their identities.

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

@@ -87,12 +87,14 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
         stopTimer?.();
         stopTimer = undefined;
         const recover = recoveryPending;
+        let retryRecovery = recover;
         // Consume only when a read starts: faults during its await latch one follow-up recovery.
         recoveryPending = false;
         try {
             const message = await ports.read({ runId, ...(messageId ? { messageId } : {}) }, { recover });
             if (stopped || !message)
                 return;
+            retryRecovery = false;
             if (message === "gone") {
                 stop();
                 handlers.onDone([]);
@@ -101,6 +103,10 @@ export function followDurableRun({ runId: initialRunId, handlers, signal, bindin
             applySavedMessage(message);
         }
         finally {
+            // Recovery must return a body before conditional polls resume: a failed recovery followed
+            // by unchanged (304) polls would otherwise leave a quiet run's dropped stream closed.
+            if (retryRecovery)
+                recoveryPending = true;
             reading = false;
             if (!stopped) {
                 // Always schedule: an error arriving during read must not create a tight recovery loop.

package/dist/core/assistant-client/entry.d.ts

@@ -4,7 +4,7 @@ export type { AssistantTransportPorts, AssistantTransportOptions, AssistantTrans
 export type { AgUiClient, AgUiClientPorts, AgUiRunClient, AgUiEventContext } from "./ag-ui-transport.js";
 export { followDurableRun } from "./durable-run-subscription.js";
 export type { DurableRunBinding, DurableSubscriptionPorts } from "./durable-run-subscription.js";
-export { activeRunStub, messageWriteKey, persistableMessages } from "./messages.js";
+export { activeRunStub, messageWriteKey, persistableMessages, createConditionalHistoryRead } from "./messages.js";
 export type { AssistantConversation } from "./messages.js";
 export { createChatAttachmentValidator } from "./attachment-liveness.js";
 export type { ChatAttachmentValidatorInput, ChatAttachmentValidatorOptions } from "./attachment-liveness.js";

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

@@ -1,7 +1,7 @@
 /** Daemon/BYOK/AG-UI chat client lifecycles. Host routes, identity and authenticated I/O are ports. */
 export { createAssistantTransportClient } from "./transport.js";
 export { followDurableRun } from "./durable-run-subscription.js";
-export { activeRunStub, messageWriteKey, persistableMessages } from "./messages.js";
+export { activeRunStub, messageWriteKey, persistableMessages, createConditionalHistoryRead } from "./messages.js";
 export { createChatAttachmentValidator } from "./attachment-liveness.js";
 export { createA2uiActionPoster } from "./a2ui-action-poster.js";
 //# sourceMappingURL=entry.js.map

package/dist/core/assistant-client/messages.d.ts

@@ -70,4 +70,25 @@ export declare function messageWriteKey({ message }: {
 export declare function activeRunStub({ messages }: {
     messages: ChatMessage[];
 }, _options?: Record<string, never>): ChatMessage | null;
+/** Retain only the last history response by reference, while reauthorizing every refresh at the
+ * server. An unchanged reply reuses it without reading/parsing the whole conversation again.
+ * @param required.read Host HTTP adapter; version is opaque and scoped to one conversation.
+ * @returns An async history reader. Port failures clear its snapshot and propagate.
+ * @throws If an adapter returns unchanged without an earlier snapshot (a port contract violation).
+ * @complexity O(1) local work; one retained snapshot reference, with no message/event copies.
+ * @example const load = createConditionalHistoryRead({ read }); await load({ conversationId });
+ */
+export declare function createConditionalHistoryRead({ read }: {
+    read: (required: {
+        conversationId: string;
+    }, optional: {
+        version?: string | undefined;
+    }) => Promise<{
+        messages?: ChatMessage[];
+        version?: string | undefined;
+        unchanged?: boolean;
+    }>;
+}, _options?: {}): ({ conversationId }: {
+    conversationId: string;
+}, _optional?: {}) => Promise<ChatMessage[]>;
 //# sourceMappingURL=messages.d.ts.map

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

@@ -65,4 +65,35 @@ export function activeRunStub({ messages }, _options = {}) {
         return null;
     return isTerminalRunStatus({ status: last.runStatus }) ? null : last;
 }
+/** Retain only the last history response by reference, while reauthorizing every refresh at the
+ * server. An unchanged reply reuses it without reading/parsing the whole conversation again.
+ * @param required.read Host HTTP adapter; version is opaque and scoped to one conversation.
+ * @returns An async history reader. Port failures clear its snapshot and propagate.
+ * @throws If an adapter returns unchanged without an earlier snapshot (a port contract violation).
+ * @complexity O(1) local work; one retained snapshot reference, with no message/event copies.
+ * @example const load = createConditionalHistoryRead({ read }); await load({ conversationId });
+ */
+export function createConditionalHistoryRead({ read }, _options = {}) {
+    let saved;
+    return async ({ conversationId }, _optional = {}) => {
+        const previous = saved?.conversationId === conversationId ? saved : undefined;
+        try {
+            const result = await read({ conversationId }, { version: previous?.version });
+            if (result.unchanged) {
+                if (!previous)
+                    throw new Error('Unchanged history requires an earlier snapshot');
+                return previous.messages;
+            }
+            // Same coercion/reason as a conversation list: initialMessages must never be undefined.
+            // A successful transport guarantees JSON syntax, not the response object's field shape.
+            const messages = Array.isArray(result.messages) ? result.messages : [];
+            saved = { conversationId, messages, version: result.version };
+            return messages;
+        }
+        catch (error) {
+            saved = undefined;
+            throw error;
+        }
+    };
+}
 //# sourceMappingURL=messages.js.map

package/dist/core/checkpoint-interval.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Select the checkpoint delay for an approximate saved-projection size.
+ * @param required.bytes Approximate payload size in bytes; thresholds use decimal MB.
+ * @returns 1 s below 1 MB, 3 s from 1 MB, and 10 s from 5 MB. Pure; no side effects.
+ * @complexity O(1) time and space.
+ */
+export declare function checkpointIntervalMs({ bytes }: {
+    bytes: number;
+}, _options?: {}): number;
+/** Count durable progress without materializing the saved projection. Thinking and extension
+ * receipts must survive a crash even before the next answer/tool. Status chatter and duplicate
+ * tool echoes must not trigger another multi-MB compaction.
+ * @param required.events Current renderable projection; never mutated.
+ * @returns Text/thinking characters, extension count and unique tool identities.
+ * @complexity O(events) time and O(unique tool identities) space.
+ * @example checkpointProgress({ events: [{ kind: 'thinking', text: 'Working' }] });
+ */
+export declare function checkpointProgress({ events }: {
+    events: readonly import('./events.js').AgentEvent[];
+}, _options?: {}): {
+    textCharacters: number;
+    extensionEvents: number;
+    tools: Set<string>;
+};
+//# sourceMappingURL=checkpoint-interval.d.ts.map

package/dist/core/checkpoint-interval.js

@@ -0,0 +1,38 @@
+/**
+ * Select the checkpoint delay for an approximate saved-projection size.
+ * @param required.bytes Approximate payload size in bytes; thresholds use decimal MB.
+ * @returns 1 s below 1 MB, 3 s from 1 MB, and 10 s from 5 MB. Pure; no side effects.
+ * @complexity O(1) time and space.
+ */
+export function checkpointIntervalMs({ bytes }, _options = {}) {
+    if (bytes >= 5_000_000)
+        return 10_000;
+    if (bytes >= 1_000_000)
+        return 3_000;
+    return 1_000;
+}
+/** Count durable progress without materializing the saved projection. Thinking and extension
+ * receipts must survive a crash even before the next answer/tool. Status chatter and duplicate
+ * tool echoes must not trigger another multi-MB compaction.
+ * @param required.events Current renderable projection; never mutated.
+ * @returns Text/thinking characters, extension count and unique tool identities.
+ * @complexity O(events) time and O(unique tool identities) space.
+ * @example checkpointProgress({ events: [{ kind: 'thinking', text: 'Working' }] });
+ */
+export function checkpointProgress({ events }, _options = {}) {
+    let textCharacters = 0;
+    let extensionEvents = 0;
+    const tools = new Set();
+    for (const event of events) {
+        if (event.kind === 'text' || event.kind === 'thinking')
+            textCharacters += event.text.length;
+        if (event.kind === 'ext')
+            extensionEvents++;
+        if (event.kind === 'tool_use')
+            tools.add(`tool_use:${event.id}`);
+        if (event.kind === 'tool_result')
+            tools.add(`tool_result:${event.toolUseId}`);
+    }
+    return { textCharacters, extensionEvents, tools };
+}
+//# sourceMappingURL=checkpoint-interval.js.map

package/dist/core/durable-runs/ledger-contracts.d.ts

@@ -20,8 +20,34 @@ export interface ChatRunRecoveryOptions {
      * Called outside storage transactions so a daemon request cannot hold the database lock. */
     readonly recover?: (input: InterruptedChatTurn) => Promise<boolean>;
 }
+/** Watch-owned receipt for the last exact incoming projection. SQL lengths count characters,
+ * not UTF-16 code units. A saved-only tool barrier invalidates this receipt. */
+export interface CheckpointState {
+    /** Native row/connection version guards equal-length changes outside the bounded suffix. */
+    readonly version: string;
+    readonly length: number;
+    /** SQL character count, avoiding a second full content parameter in CAS. */
+    readonly contentLength: number;
+    /** SQL characters in the complete last serialized event plus closing array bracket. */
+    readonly tailLength: number;
+    readonly content: string;
+    readonly events: readonly import("../events.js").AgentEvent[];
+    /** At most 256 UTF-16 units of the saved suffix; never the whole last tool result. */
+    readonly tail: string;
+}
+export interface CheckpointOptions {
+    readonly expected?: number | undefined;
+    readonly previous?: CheckpointState | undefined;
+    /** Undefined means the authoritative merge retained saved-only events: use the full path next. */
+    readonly onPersisted?: (state: CheckpointState | undefined) => void;
+}
 export interface ChatRunLedger {
     readonly durable?: DurableRunStore;
+    /** Read-only existence probe across all owners. Only queued/running assistant rows block idle
+     * shutdown; no transcript payloads, recovery or writes. Rejects on storage failure (host stays busy).
+     * @example if (await ledger.hasActiveRuns({}, {})) return;
+     */
+    hasActiveRuns(required?: {}, optional?: {}): Promise<boolean>;
     /**
      * Runs `write` only while `run`'s row holds no terminal status (an unknown row, another run id, or
      * a row still `queued`/`running` all count as unsettled), with no settle able to land in between.
@@ -43,7 +69,7 @@ export interface ChatRunLedger {
      * A no-op once the row is terminal or belongs to another run. Resolves `true` when it wrote, or
      * when the row already held exactly this checkpoint (accepted without rewriting the row).
      */
-    checkpoint(progress: RunProgress, optional?: {}): Promise<boolean>;
+    checkpoint(progress: RunProgress, optional?: CheckpointOptions): Promise<boolean>;
     /** Serving-only discovery of unfinished rows. The injected recovery coordinator owns adopted
      * runs; rows it cannot adopt are canceled, preserving saved work. Returns handled rows.
      * Export apps must not invoke discovery while a serving daemon is still alive. */

package/dist/core/durable-runs/ports.d.ts

@@ -27,10 +27,34 @@ export interface DurableRun extends RunRef {
 /** A run without its conversation transcript: what a fence, lock or tool guard reads. `message`
  * still carries the run's own saved events; only `load`/`accept`/`cancelPending` read every message. */
 export type DurableRunHead = Omit<DurableRun, "transcript">;
+/** Raw current-message projection. An absent messageJson means the cursor is unchanged. */
+export interface DurableRunPoll {
+    readonly cursor: string;
+    readonly conversationId?: string;
+    readonly messageJson?: string;
+}
 export interface DurableRunStore {
+    /** Owner-scoped, unlocked poll. No transcript read or event parse; unchanged omits payloads. */
+    poll?(required: {
+        messageId: string;
+        principalId: string;
+        workspaceId: string;
+    }, optional: {
+        cursor?: string;
+    }): Promise<DurableRunPoll | null>;
+    /** `includeTranscriptEvents:false` omits prior assistant payloads, keeping current-run events
+     * and user receipts that preserve queued inputs and folder references. Defaults to a full read. */
     load(required: {
         messageId: string;
-    }, optional: {}): Promise<DurableRun | null>;
+    }, optional: {
+        includeTranscriptEvents?: boolean;
+    }): Promise<DurableRun | null>;
+    /** Follow the current attempt by message id without loading its conversation. */
+    head?(required: {
+        messageId: string;
+    }, optional: {
+        events?: boolean;
+    }): Promise<DurableRunHead | null>;
     /** Reads only this run's message and attempt rows; `load` when the transcript is needed. */
     find(required: {
         runId: string;

package/dist/core/index.d.ts

@@ -39,4 +39,5 @@ export { turnUsage, conversationUsage, replySegments, isReplyBoundary, MID_RUN_U
 export { formatUsageCost } from './usage-format.js';
 export * from './accepted-input.js';
 export * from './question-answer.js';
+export { checkpointIntervalMs, checkpointProgress } from './checkpoint-interval.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -38,4 +38,5 @@ export { turnUsage, conversationUsage, replySegments, isReplyBoundary, MID_RUN_U
 export { formatUsageCost } from './usage-format.js';
 export * from './accepted-input.js';
 export * from './question-answer.js';
+export { checkpointIntervalMs, checkpointProgress } from './checkpoint-interval.js';
 //# sourceMappingURL=index.js.map

package/dist/core/tool-events.d.ts

@@ -14,9 +14,12 @@ import type { AgentEvent } from './events.js';
  *   `k` is the number of distinct `tool_use` ids seen — one linear pass with
  *   a `Set` membership check.
  */
-export declare function dedupeToolUsesById({ events }: {
+export declare function dedupeToolUsesById(required: {
     events: AgentEvent[] | undefined;
-}): AgentEvent[];
+}, optional?: {}): AgentEvent[];
+export declare function dedupeToolUsesById(required: {
+    events: readonly AgentEvent[] | undefined;
+}, optional?: {}): readonly AgentEvent[];
 /**
  * Whether `name` is a delegated-tool transport wrapper — `execute_delegated_tool` or
  * `execute_readonly_delegated_tool`, bare or as an MCP client names it (`mcp__<server>__…`). Its real

package/dist/core/tool-events.js

@@ -1,21 +1,6 @@
 import { canonicalJson } from '@jini-ai/core/records';
 import { toolPresentation } from './tool-presentation.js';
-/**
- * Drop repeated `tool_use` events that share an `id`. A retried/duplicated
- * stream can replay the same tool-call id (e.g. reconnect-and-replay landing
- * an event twice); rendering it twice would show a phantom second call.
- * Non-`tool_use` events (and the first occurrence of each id) pass through
- * unchanged and in original order.
- *
- * @param events - The event list to dedupe, or `undefined` for an empty conversation turn.
- * @returns A new array with later duplicate `tool_use` events removed, or the
- *   original array reference when nothing needed to change (cheap no-op for
- *   the common case).
- * @complexity O(n) time / O(k) extra space, where `n` is `events.length` and
- *   `k` is the number of distinct `tool_use` ids seen — one linear pass with
- *   a `Set` membership check.
- */
-export function dedupeToolUsesById({ events }) {
+export function dedupeToolUsesById({ events }, _optional) {
     if (!events || events.length === 0)
         return [];
     const seen = new Set();

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

@@ -30,9 +30,9 @@ export interface ComposerProps {
     /** Cancels the in-flight run. Required when `running` is true; ignored otherwise. */
     onCancel?: () => void;
     /**
-     * Cmd/Ctrl+Enter: end the run in flight and send this draft next. Optional — without it the
-     * modifier falls through to the ordinary Enter path, so a host that has not opted in keeps
-     * exactly its previous behavior.
+     * Cmd/Ctrl+Enter: optional host send shortcut. ChatPane shares the ordinary mid-run delivery
+     * path so sending keeps the current run going. Without this callback the modifier falls
+     * through to ordinary Enter, so a host that has not opted in keeps its previous behavior.
      */
     onInterrupt?: () => void;
     /**

package/dist/react/components/Composer.js

@@ -273,9 +273,9 @@ export function Composer({ composer, onSend, disabled = false, sendDisabled = fa
     function submitFromEnter(event) {
         if (disabled || !composer.canSubmit)
             return;
-        // Cmd/Ctrl+Enter ends the current run and sends this next; plain Enter queues behind it.
-        // `sendDisabled` is deliberately NOT consulted on the interrupt path — while a run streams it
-        // is set precisely BECAUSE of that run, which is the one case this modifier exists to act on.
+        // Cmd/Ctrl+Enter uses the host shortcut; ChatPane routes it through the ordinary send guards.
+        // `sendDisabled` is deliberately NOT consulted here: hosts can offer a shortcut while a run
+        // itself blocks ordinary sends. ChatPane queues or delivers live without cancelling the run.
         if ((event.metaKey || event.ctrlKey) && onInterrupt) {
             onInterrupt();
             return;

package/dist/react/components/MessageList.js

@@ -20,9 +20,9 @@ import { MessageRow } from './MessageRow.js';
 import { SentAttachmentButton } from './SentAttachment.js';
 import { AttachmentPreviewModal } from './AttachmentPreviewModal.js';
 import { useAttachmentGallery } from './AttachmentGallery.hooks.js';
-function renderMessageRow({ message, isLast, isStreaming, usageSummary, sending }, { activeQuestionFormMessageId, questionFormSubmittedAnswersByMessageId, onQuestionFormSubmit, ...rowProps } = {}) {
+function renderMessageRow({ message, isLast, isStreaming, usageSummary, sending, showAccessNotice }, { activeQuestionFormMessageId, questionFormSubmittedAnswersByMessageId, onQuestionFormSubmit, ...rowProps } = {}) {
     const runStreaming = isLast && isStreaming && !isTerminalRunStatus({ status: message.runStatus });
-    return (_jsx(MessageRow, { message: message, ...rowProps, ...(usageSummary === undefined ? {} : { usageSummary }), runStreaming: runStreaming, runSending: sending, runSucceeded: message.runStatus === 'succeeded', questionFormInteractive: message.id === activeQuestionFormMessageId, ...(questionFormSubmittedAnswersByMessageId?.[message.id] !== undefined ? { questionFormSubmittedAnswers: questionFormSubmittedAnswersByMessageId[message.id] } : {}), ...(onQuestionFormSubmit !== undefined ? { onQuestionFormSubmit: (text, answers) => onQuestionFormSubmit(message.id, text, answers) } : {}) }, message.id));
+    return (_jsx(MessageRow, { message: message, ...rowProps, showAccessNotice: showAccessNotice, ...(usageSummary === undefined ? {} : { usageSummary }), runStreaming: runStreaming, runSending: sending, runSucceeded: message.runStatus === 'succeeded', questionFormInteractive: message.id === activeQuestionFormMessageId, ...(questionFormSubmittedAnswersByMessageId?.[message.id] !== undefined ? { questionFormSubmittedAnswers: questionFormSubmittedAnswersByMessageId[message.id] } : {}), ...(onQuestionFormSubmit !== undefined ? { onQuestionFormSubmit: (text, answers) => onQuestionFormSubmit(message.id, text, answers) } : {}) }, message.id));
 }
 /**
  * Memoized: the pane re-renders on every composer keystroke, and re-rendering a long transcript
@@ -33,12 +33,17 @@ function renderMessageRow({ message, isLast, isStreaming, usageSummary, sending
 export const MessageList = memo(function MessageList({ messages: sourceMessages, isStreaming = false, scrollIntent = false, onScrolled, pendingPrompt, pendingPrompts, ...rowProps }) {
     const messages = useMemo(() => projectAcceptedInputMessages({ messages: sourceMessages }), [sourceMessages]);
     const usageByMessage = useConversationUsage({ messages });
+    // Derive from the conversation's saved events, so replay/remount does not repeat the notice.
+    const accessNoticeId = useMemo(() => messages.find(message => message.role === 'assistant'
+        && message.events?.some(event => event.kind === 'status' && event.label === 'full_cli_access' && event.detail))?.id, [messages]);
     const { containerRef, onScroll, awayFromLatest, jumpToLatest } = useMessageListAutoScroll({ messages, scrollIntent }, onScrolled !== undefined ? { onScrolled } : {});
     return (_jsxs("div", { className: "jini-message-list", ref: containerRef, onScroll: onScroll, "data-agent-element": "chat-transcript", "data-agent-role": "list", "data-agent-label": "The conversation transcript, oldest message first", children: [messages.map((message, index) => renderMessageRow({
                 message,
+                showAccessNotice: message.id === accessNoticeId,
                 isLast: message.id === messages[messages.length - 1]?.id,
                 // A reply's start is accepted together with its user turn (`inputPending` clears then).
-                sending: messages[index - 1]?.inputPending === true,
+                // A run id also proves acceptance after reload, when a legacy pending flag can survive.
+                sending: message.runId === undefined && messages[index - 1]?.inputPending === true,
                 isStreaming,
                 usageSummary: usageByMessage.get(message.id),
             }, rowProps)), (pendingPrompts ?? (pendingPrompt ? [pendingPrompt] : [])).map((prompt, index) => (_jsx(QueuedMessage, { prompt: prompt, renderAttachment: rowProps.renderAttachment }, prompt.id ?? index))), awayFromLatest && _jsx(JumpToLatest, { onJump: jumpToLatest })] }));

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

@@ -54,6 +54,8 @@ import type { ChatAttachment, ChatMessage } from '../../core/index.js';
 import { type ToolCallDisplay } from '../tool-call-display.js';
 export interface MessageRowProps {
     message: ChatMessage;
+    /** Conversation hosts show the first access status only; standalone rows retain it by default. */
+    showAccessNotice?: boolean;
     /** Per-turn charge and prefix total derived from the complete conversation's persisted events. */
     usageSummary?: ChatUsageSummary;
     /** Append the chat's running total as of each reply ("· total $3.95") to its Done line. On by default

package/dist/react/components/MessageRow.js

@@ -147,7 +147,7 @@ function RunAccessNotice({ events }) {
     const notice = events?.find(event => event.kind === 'status' && event.label === 'full_cli_access');
     if (notice?.kind !== 'status' || !notice.detail)
         return null;
-    return _jsx("div", { className: "jini-chat-pane__notice", role: "note", children: t(notice.detail) });
+    return _jsx("div", { className: "jini-chat-pane__notice", role: "status", children: t(notice.detail) });
 }
 function ThinkingBlock({ text }) {
     const t = useT();
@@ -187,13 +187,16 @@ function UserMessageRow({ message, renderAttachment }) {
     const gallery = useAttachmentGallery({ attachments: message.attachments ?? NO_ATTACHMENTS });
     return (_jsxs("div", { className: "jini-message jini-message-user", "data-message-id": message.id, "data-agent-element": `chat-message-${message.id}`, "data-agent-role": "region", "data-agent-label": "A message from the user", children: [(message.attachments?.length || message.folders?.length) ? (_jsxs("div", { className: "jini-message-attachments", children: [_jsx(FolderChips, { folders: message.folders }), (message.attachments ?? []).map((a) => (_jsx(SentAttachmentButton, { attachment: a, onOpen: gallery.open, renderAttachment: renderAttachment }, a.path)))] })) : null, _jsx("div", { className: "jini-message-content", children: message.content }), _jsx("div", { className: "jini-message-actions jini-message-actions--user", children: _jsx(CopyMessageButton, { text: message.content, label: t('Copy message') }) }), gallery.opened ? (_jsx(AttachmentPreviewModal, { attachment: gallery.opened, onClose: gallery.close, navigation: gallery.navigation })) : null] }));
 }
-function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageLine, toolCallDisplay, showThinking, runStreaming, runSending, sendingLabel, runSucceeded, questionFormInteractive, questionFormSubmittedAnswers, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, }) {
+function AssistantMessageRow({ showAccessNotice = true, message, usageSummary, showUsageTotal, showUsageLine, toolCallDisplay, showThinking, runStreaming, runSending, sendingLabel, runSucceeded, questionFormInteractive, questionFormSubmittedAnswers, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, }) {
     const registry = useExtEventRendererRegistry();
     const messageUsage = useMessageUsage({ message, ...(usageSummary === undefined ? {} : { summary: usageSummary }) });
     const timeline = useToolTimeline({ events: message.events }, { runStreaming, runSucceeded });
     const extGroups = useExtEventGroups({ events: message.events }, { slotOf: (name, data) => registry.slot({ name, data }) });
     const answeredCards = useAnsweredCards({ slotOf: registry.slot, events: message.events ?? [], groups: extGroups, runStreaming, runStatus: message.runStatus });
-    const terminalNotice = terminalMessageNotice({ message }, {});
+    // A validated extension may already show the explanation. Keep the generic fallback when its
+    // renderer is absent or refuses the payload, so malformed history never hides a failed turn.
+    const extensionExplainsFailure = !runStreaming && !runSucceeded && extGroups.some(group => registry.hasTerminalNotice(group));
+    const terminalNotice = extensionExplainsFailure ? null : terminalMessageNotice({ message }, {});
     const visibleContent = stripArtifact({ content: message.content });
     const displayBlocks = messageBlocks({ message, rows: timeline.rows, registry }, { toolCallDisplay, includeThinking: showThinking });
     // Artifact stripping trims/replaces text, invalidating the event offsets for rendering. Keep the
@@ -286,11 +289,11 @@ function AssistantMessageRow({ message, usageSummary, showUsageTotal, showUsageL
     // in their original receipt order, outside the assistant's actions and usage footer.
     // Keep the same child-array nesting as the interleaved path so React preserves the footer.
     if (blocks === null)
-        return _jsxs(_Fragment, { children: [_jsx(RunAccessNotice, { events: message.events }), [renderAssistantSection({ section: null, key: message.id, footer: true })], extGroups.filter(group => group.name === MID_RUN_USER_MESSAGE_EXT_EVENT_NAME).map(renderExtGroup)] });
+        return _jsxs(_Fragment, { children: [showAccessNotice && _jsx(RunAccessNotice, { events: message.events }), [renderAssistantSection({ section: null, key: message.id, footer: true })], extGroups.filter(group => group.name === MID_RUN_USER_MESSAGE_EXT_EVENT_NAME).map(renderExtGroup)] });
     // A reply boundary without reported usage renders nothing; it must not create an empty row's gap.
     const visibleBlocks = blocks.filter(block => block.kind !== 'reply-end' || (showUsageLine && usage.replies[block.index] !== undefined));
     const { sections, footerIndex } = transcriptSections({ blocks: visibleBlocks, runInProgress });
-    return _jsxs(_Fragment, { children: [_jsx(RunAccessNotice, { events: message.events }), sections.map((section, index) => isUserSection({ section })
+    return _jsxs(_Fragment, { children: [showAccessNotice && _jsx(RunAccessNotice, { events: message.events }), sections.map((section, index) => isUserSection({ section })
                 ? _jsx(React.Fragment, { children: section.map(renderBlock) }, section[0].key)
                 : renderAssistantSection({ section, key: section[0]?.key ?? message.id, footer: index === footerIndex }))] });
 }