@jini-ai/chat 0.6.17 → 0.6.21

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## 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.
+- The chat model picker names raw catalog ids friendly ("Claude Opus 5.5", context and date suffixes kept), shows "Offline fallback" only once the live model list has actually failed rather than while the host is still probing, and closes on Escape from the menu or its trigger even when an ancestor stops the keydown.
+- A reply's "Done · time" runs from the person's send to the run's end for every CLI; the CLI's own reported duration, which leaves out its start-up wait, is only the fallback.
+- Keep failed tool receipts visible unless a matching canonical call also failed, including buffered CLI receipts.
+- Remove an obsolete hook lint directive for an uninstalled rule.
+- Document the two 0.6.x fetch fallback exceptions, inject fetch in repo hosts, and redact expiry/React callback exception logs.
+
 ## 0.6.17
 
 ### Patch Changes

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/events.d.ts

@@ -56,6 +56,12 @@ export type AgentEvent = {
     id: string;
     name: string;
     input: unknown;
+    bridgeCall?: {
+        name: string;
+        input: unknown;
+        buffered?: boolean;
+    };
+    toolOrigin?: 'bridge';
 } | {
     kind: 'tool_result';
     toolUseId: 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/run-events/entry.js

@@ -5,8 +5,19 @@
  * Authenticated routing, ownership, boot repair and storage transactions remain host responsibilities. */
 import { decodeSseFrames, parseSseRecord } from "@jini-ai/core/primitives";
 import { assistantContentFromEvents } from "../assistant-content.js";
+import { recoverableSurfaceResource } from '../surface-recovery.js';
 import { mergeAdjacentTextEvents } from "../compact-events.js";
 import { dedupeToolUsesById } from "../tool-events.js";
+/** Retain executor-decoded display correlation through both live and saved chat reduction.
+ * Only the delegated bridge marks canonical rows; malformed optional metadata is ignored. O(1). */
+function toolCallCorrelation({ payload }) {
+    const call = payload.bridgeCall;
+    return {
+        ...(payload.toolOrigin === 'bridge' ? { toolOrigin: 'bridge' } : {}),
+        ...(isRecord(call) && typeof call.name === 'string' ? { bridgeCall: { name: call.name, input: call.input,
+                ...(call.buffered === true ? { buffered: true } : {}) } } : {}),
+    };
+}
 function wireString(v) {
     if (typeof v === "string")
         return v;
@@ -84,7 +95,8 @@ export function translateRunAgentPayload({ payload }, _options = {}) {
         case "thinking_delta":
             return { kind: "thinking", text: wireString(payload.delta) };
         case "tool_use":
-            return { kind: "tool_use", id: wireString(payload.id), name: wireString(payload.name), input: payload.input };
+            return { kind: "tool_use", id: wireString(payload.id), name: wireString(payload.name), input: payload.input,
+                ...toolCallCorrelation({ payload }) };
         case "tool_result":
             return toolResultEvent(payload);
         case "usage":
@@ -126,7 +138,8 @@ function translateEnvelopePayload(payload) {
         // worst possible failure for a confirmation dialog. Unwrapping here is what makes the two ends
         // meet. `name` must stay `"mcp-ui"` to match `MCP_UI_EXT_EVENT_NAME`.
         case "mcp-ui":
-            return { kind: "ext", name: "mcp-ui", data: payload.resource };
+            return { kind: "ext", name: "mcp-ui", data: recoverableSurfaceResource({ resource: payload.resource,
+                    exchange: 'surfaceExchange' in payload ? payload.surfaceExchange : undefined }) };
         // A2UI's own agent->renderer envelope (`@jini-ai/core`'s `SurfaceEmission` with
         // `channel: "a2ui"`, injected by `@jini-ai/daemon`'s `delegated-tool-bridge.ts` as
         // `{type: "a2ui", message: <AgentToRendererMessage>}`). Unwrapped to the bare `.message` here,

package/dist/core/surface-recovery.d.ts

@@ -0,0 +1,19 @@
+/** Wire metadata belongs to the channel adapter, never to rendered HTML or model context. */
+export declare const SURFACE_EXCHANGE_META = "jini/surface-exchange";
+export interface SurfaceRecoveryInfo {
+    readonly exchangeId: string;
+    readonly toolId: string;
+    readonly runId: string;
+}
+/** Read only server-issued exchange identity; original tool arguments never cross this boundary.
+ * @complexity O(1). */
+export declare function surfaceRecoveryInfo({ value }: {
+    value: unknown;
+}, _options?: {}): SurfaceRecoveryInfo | undefined;
+/** Preserve the existing bare-resource renderer contract while attaching recovery identity.
+ * @complexity O(1), shallow copies only. Malformed resources remain the renderer's responsibility. */
+export declare function recoverableSurfaceResource({ resource, exchange }: {
+    resource: unknown;
+    exchange: unknown;
+}, _options?: {}): unknown;
+//# sourceMappingURL=surface-recovery.d.ts.map

package/dist/core/surface-recovery.js

@@ -0,0 +1,26 @@
+/** Wire metadata belongs to the channel adapter, never to rendered HTML or model context. */
+export const SURFACE_EXCHANGE_META = 'jini/surface-exchange';
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Read only server-issued exchange identity; original tool arguments never cross this boundary.
+ * @complexity O(1). */
+export function surfaceRecoveryInfo({ value }, _options = {}) {
+    if (!record(value))
+        return undefined;
+    if (typeof value.exchangeId !== 'string' || typeof value.toolId !== 'string' || typeof value.runId !== 'string')
+        return undefined;
+    if (!value.exchangeId || !value.toolId || !value.runId)
+        return undefined;
+    return { exchangeId: value.exchangeId, toolId: value.toolId, runId: value.runId };
+}
+/** Preserve the existing bare-resource renderer contract while attaching recovery identity.
+ * @complexity O(1), shallow copies only. Malformed resources remain the renderer's responsibility. */
+export function recoverableSurfaceResource({ resource, exchange }, _options = {}) {
+    const info = surfaceRecoveryInfo({ value: exchange });
+    if (!info || !record(resource) || !record(resource.resource))
+        return resource;
+    const meta = record(resource.resource._meta) ? resource.resource._meta : {};
+    return { ...resource, resource: { ...resource.resource, _meta: { ...meta, [SURFACE_EXCHANGE_META]: info } } };
+}
+//# sourceMappingURL=surface-recovery.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
@@ -45,9 +48,14 @@ export declare function isDelegatedWrapperToolName({ name }: {
  * Antigravity buffers CLI receipts: its adapter-described wrappers match equal inner inputs
  * anywhere in this assistant turn, in appearance order among equal keys. Pass only one turn's events;
  * no state is retained across calls. Wrapper and bridge rows are each claimed at most once.
+ * Receipt and canonical failure states must match: a success cannot consume a failed row,
+ * and an identical successful or pending call cannot account for a refusal before the bridge,
+ * regardless of buffered receipt ordering.
  * A legacy gateway folds onto the first LATER canonical `tool_use` whose name equals its `input.toolId`.
  * A direct call folds onto the first LATER `X` row with structurally equal JSON input that arrives
- * before the CLI's own result for it. No canonical row is claimed twice, and a folded wrapper's
+ * before the CLI's own result for it; failing that, once that result has arrived, onto the first
+ * unclaimed same-name row between the two, since argument normalization can change the bridge's
+ * input (see {@link findCanonicalRow}). No canonical row is claimed twice, and a folded wrapper's
  * `tool_result` events go with it. A wrapper with no such canonical row (refused before the
  * bridge, e.g. a read-only 403) stays, so its error is not hidden.
  *