@jini-ai/chat 0.6.19 → 0.6.21

package/dist/react/hooks/useConversation.js

@@ -37,6 +37,15 @@ function pendingUserMessage({ content, sendOptions, createMessageId }, options =
             ...(sendOptions.attachments ? { attachments: sendOptions.attachments } : {}),
         } }, options).message;
 }
+/** A checkpoint's run id proves acceptance even if the original start request is still pending.
+ * @returns A copy with pending state cleared only for this run's preceding user row; no I/O.
+ * @complexity O(1) time/space, called in the existing transcript reconciliation pass.
+ */
+function acceptPendingUserMessage({ message, reply, assistantId, runId }, _options = {}) {
+    if (!message.inputPending || reply?.id !== assistantId || runId === null)
+        return message;
+    return { ...message, inputPending: false };
+}
 /** The queued assistant bubble a send opens; the run's events fill it in. */
 function pendingAssistantMessage({ id }, { agentId } = {}) {
     return {
@@ -164,9 +173,11 @@ export function useConversation(options) {
         const assistantId = activeAssistantIdRef.current;
         if (!assistantId)
             return;
-        setMessagesState((prev) => prev.map((m) => {
+        setMessagesState((prev) => prev.map((m, index) => {
             if (m.id !== assistantId)
-                return m;
+                return acceptPendingUserMessage({
+                    message: m, reply: prev[index + 1], assistantId, runId: run.runId,
+                });
             // A plain if/else chain (not a nested ternary) — deliberately, so
             // each of the four mapped statuses is its own independently
             // trackable branch under coverage instrumentation. The fallback

package/dist/server/durable-runs/recover.js

@@ -165,7 +165,7 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
         const events = recoveredRunEvents({ saved: savedWork({ run }) }, { notice: missingResume ? 'silent' : 'visible' });
         if (!await ports.store.advance({ run, nextRunId, now: ports.now(), events }, {}))
             return "superseded";
-        const next = await ports.store.load({ messageId: run.messageId }, {});
+        const next = await ports.store.load({ messageId: run.messageId }, { includeTranscriptEvents: false });
         // Cancel/deletion can win while the old attempt is being fenced. Re-read after CAS and do
         // not launch against a removed binding or a newer generation.
         if (!next || next.runId !== nextRunId)
@@ -234,7 +234,7 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
     }
     /** The saved row after an await, or the outcome that ends this decision. O(1) store reads. */
     async function reload(run) {
-        const current = await ports.store.load({ messageId: run.messageId }, {});
+        const current = await ports.store.load({ messageId: run.messageId }, { includeTranscriptEvents: false });
         if (!current)
             return "gone";
         // A probe only speaks about the generation it inspected. Never apply its dead result to
@@ -264,7 +264,7 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
     }
     return {
         async recover({ messageId, trigger, expectedRunId }, options) {
-            const run = await ports.store.load({ messageId }, {});
+            const run = await ports.store.load({ messageId }, { includeTranscriptEvents: false });
             if (!run)
                 return "gone";
             if (run.message.runStatus !== "queued" && run.message.runStatus !== "running")

package/dist/store/ports.d.ts

@@ -88,8 +88,22 @@ export interface ChatStore {
     delete(required: {
         readonly id: string;
     }, optional?: Record<string, never>): Promise<void>;
-    /** Compatibility read: all messages in stored position order; unauthorized returns []. */
-    messages(required: ChatMessagePageInput, optional?: Record<string, never>): Promise<ChatMessage[]>;
+    /** Compatibility read in stored order; unauthorized returns []. `false` omits event columns;
+     * `user` keeps input receipts/folders without reading prior assistant payloads. */
+    messages(required: ChatMessagePageInput, optional?: {
+        readonly includeEvents?: boolean | "user";
+    }): Promise<ChatMessage[]>;
+    /** Optional indexed compatibility read; unknown and other-owned rows both return null. */
+    message?(required: ChatMessagePageInput & {
+        readonly messageId: string;
+    }, optional?: Record<string, never>): Promise<ChatMessage | null>;
+    /** Cheap owner-scoped history validator; reads metadata, never message/event payloads. */
+    messagesVersion?(required: ChatMessagePageInput, optional?: Record<string, never>): Promise<string | null>;
+    /** JSON response chunks, preserving stored event JSON instead of serializing event object trees.
+     * The optional ordering policy sees message metadata and receipt-derived folders, without events. */
+    messagesJson?(required: ChatMessagePageInput, optional?: {
+        readonly orderMessages?: (messages: ChatMessage[]) => ChatMessage[];
+    }): Promise<AsyncIterable<string>>;
     /** Idempotent update by message ID within its original conversation; unauthorized: null. */
     appendMessage(required: {
         readonly conversationId: string;
@@ -100,7 +114,7 @@ export interface ChatStore {
     readonly search?: ChatSearchCapability;
 }
 /** Eight-method compatibility subset plus optional bounded history; old hosts/fakes still fit. */
-export type ChatHistoryStore = Pick<ChatStore, 'list' | 'get' | 'create' | 'rename' | 'touch' | 'delete' | 'messages' | 'appendMessage' | 'history'>;
+export type ChatHistoryStore = Pick<ChatStore, 'list' | 'get' | 'create' | 'rename' | 'touch' | 'delete' | 'messages' | 'message' | 'messagesJson' | 'messagesVersion' | 'appendMessage' | 'history'>;
 /** Internal persistence projections. Model-facing tools redact and cap these before returning. */
 export interface ChatHistoryReader {
     list(required: Record<string, never>, optional?: {

package/dist/store/runtime/chat-history-store.js

@@ -50,6 +50,12 @@ export function createChatHistoryStore({ kernel: hostKernel, scope, isDaemonRunI
         async messages(required, optional = {}) {
             return repairLegacyTurnOrder({ messages: await store.messages(required, optional), isDaemonRunId }, {});
         },
+        // Raw history must apply the same repair before emitting chunks; ordering never needs events.
+        async messagesJson(required, optional = {}) {
+            return store.messagesJson(required, { ...optional,
+                orderMessages: messages => repairLegacyTurnOrder({ messages, isDaemonRunId }, {}),
+            });
+        },
     };
 }
 function storeFactory(transport) {

package/dist/store/runtime/checkpoint-delta.d.ts

@@ -0,0 +1,35 @@
+import type { AgentEvent } from "../../core/index.js";
+import type { CheckpointState, RunProgress } from "../../core/durable-runs/ledger-contracts.js";
+/** A delta may append events or replace the final coalesced text event. Every earlier event
+ * must match; replay reordering, thinking replacement and tool identity deduplication fall back.
+ * @complexity O(prefix bytes + new suffix bytes) time; O(new suffix bytes) temporary space. */
+export declare function checkpointDelta({ previous, progress }: {
+    previous: CheckpointState;
+    progress: RunProgress;
+}, _options?: {}): {
+    removeCharacters: number;
+    suffix: string;
+    grown: boolean;
+} | undefined;
+/** Same tool identity rule as the full checkpoint's progress check. O(saved + incoming events). */
+export declare function hasNewToolProgress({ saved, incoming }: {
+    saved: readonly AgentEvent[];
+    incoming: readonly AgentEvent[];
+}, _options?: {}): boolean;
+/** Durable tool identity shared by the full merge and delta progress check. */
+export declare function toolKey({ event }: {
+    event: AgentEvent;
+}, _options?: {}): string;
+/** Build a receipt only for an exact incoming projection; callers own its watch lifetime.
+ * SQL supplies content/event lengths; the removed tail counts Unicode code points. Retain only
+ * a bounded suffix for CAS, so a multi-MB tool result never becomes a guard parameter twice.
+ * @complexity O(last event bytes) serialization/counting; O(last event bytes) transient space,
+ * with at most 256 UTF-16 units retained beyond the existing projection references.
+ */
+export declare function checkpointState({ progress, length, contentLength, version }: {
+    progress: RunProgress;
+    length: number;
+    contentLength: number;
+    version: string;
+}, _options?: {}): CheckpointState;
+//# sourceMappingURL=checkpoint-delta.d.ts.map

package/dist/store/runtime/checkpoint-delta.js

@@ -0,0 +1,75 @@
+import { dedupeToolUsesById } from "../../core/tool-events.js";
+/** Compare unchanged prefix values; compacting text creates fresh objects, while large tool
+ * payloads normally retain their reference. Never parse the saved SQL column here. */
+function sameEvent(left, right) {
+    return left === right || JSON.stringify(left) === JSON.stringify(right);
+}
+/** A delta may append events or replace the final coalesced text event. Every earlier event
+ * must match; replay reordering, thinking replacement and tool identity deduplication fall back.
+ * @complexity O(prefix bytes + new suffix bytes) time; O(new suffix bytes) temporary space. */
+export function checkpointDelta({ previous, progress }, _options = {}) {
+    if (progress.content.length < previous.content.length)
+        return undefined;
+    const incoming = progress.events;
+    const saved = previous.events;
+    if (incoming.length < saved.length)
+        return undefined;
+    if (dedupeToolUsesById({ events: incoming }).length !== incoming.length)
+        return undefined;
+    const prefix = saved.slice(0, -1);
+    if (!prefix.every((event, index) => sameEvent(event, incoming[index])))
+        return undefined;
+    const last = saved.at(-1);
+    const next = incoming[saved.length - 1];
+    const replacing = last !== undefined && !sameEvent(last, next);
+    if (replacing && !extendsText({ last, next }))
+        return undefined;
+    return { ...deltaSuffix({ previous, incoming, replacing }),
+        grown: progress.content.length > previous.content.length || hasNewToolProgress({ saved, incoming }) };
+}
+/** SQL counts characters in the removed tail, so non-BMP text never uses JS UTF-16 offsets. */
+function deltaSuffix({ previous, incoming, replacing }, _options = {}) {
+    const from = previous.events.length - (replacing ? 1 : 0);
+    const suffixEvents = incoming.slice(from);
+    const separator = !replacing && from > 0 && suffixEvents.length > 0 ? ',' : '';
+    return { removeCharacters: replacing ? previous.tailLength : 1,
+        suffix: separator + JSON.stringify(suffixEvents).slice(1) };
+}
+/** Extending text must retain every other field (including any future event metadata). */
+function extendsText({ last, next }, _options = {}) {
+    if (last.kind !== 'text' || next?.kind !== 'text')
+        return false;
+    return next.text.startsWith(last.text) && sameEvent({ ...last, text: next.text }, next);
+}
+/** Same tool identity rule as the full checkpoint's progress check. O(saved + incoming events). */
+export function hasNewToolProgress({ saved, incoming }, _options = {}) {
+    const keys = new Set(saved.map(event => toolKey({ event })));
+    return incoming.some(event => { const key = toolKey({ event }); return key !== '' && !keys.has(key); });
+}
+/** Durable tool identity shared by the full merge and delta progress check. */
+export function toolKey({ event }, _options = {}) {
+    if (event.kind === 'tool_use')
+        return 'use:' + event.id;
+    if (event.kind === 'tool_result')
+        return 'result:' + event.toolUseId;
+    return '';
+}
+/** Build a receipt only for an exact incoming projection; callers own its watch lifetime.
+ * SQL supplies content/event lengths; the removed tail counts Unicode code points. Retain only
+ * a bounded suffix for CAS, so a multi-MB tool result never becomes a guard parameter twice.
+ * @complexity O(last event bytes) serialization/counting; O(last event bytes) transient space,
+ * with at most 256 UTF-16 units retained beyond the existing projection references.
+ */
+export function checkpointState({ progress, length, contentLength, version }, _options = {}) {
+    const last = progress.events.at(-1);
+    const fullTail = last === undefined ? '[]' : JSON.stringify(last) + ']';
+    // Count SQL characters without allocating an array of code points for a multi-MB tool result.
+    let tailLength = 0;
+    for (const _character of fullTail)
+        tailLength++;
+    let tail = fullTail.slice(-256);
+    if (/^[\uDC00-\uDFFF]/u.test(tail))
+        tail = tail.slice(1);
+    return { content: progress.content, events: progress.events, version, length, contentLength, tailLength, tail };
+}
+//# sourceMappingURL=checkpoint-delta.js.map

package/dist/store/runtime/durable-run-store.js

@@ -1,3 +1,4 @@
+import { sqliteReadVersion } from '../sql/read-version.js';
 import { acceptedInputEvent, acceptedInputUserEvent } from "../../core/accepted-input.js";
 import { redactUserMessage } from "../../core/user-text-redaction.js";
 import { recoveredRunEvents } from "../../core/index.js";
@@ -8,7 +9,8 @@ import { RECOVERY_WINDOW_MS } from "../../core/durable-runs/policies.js";
 import { createChatHistoryStore } from "./chat-history-store.js";
 import { runLockKey } from "../../core/durable-runs/run-lock.js";
 import { runContentFromEvents } from "../../core/run-events/entry.js";
-import { toMessage } from "../sql/store.js";
+import { appendedEventsJson } from "./events-json.js";
+import { toMessage, validatedEventsJson } from "../sql/store.js";
 export const RUN_SLOT_BUSY = "Another answer in this chat is still running. This turn is queued in your browser.";
 export class RunSlotBusyError extends Error {
     constructor() { super(RUN_SLOT_BUSY); }
@@ -150,15 +152,6 @@ function continuationEvents({ current, incoming }, _optional = {}) {
     }
     return runContentFromEvents({ events: incoming }).length >= current.message.content.length ? incoming : saved;
 }
-/** `events_json` with one more event, built in SQL: no dialect parses or re-serializes the saved
- * array in JS. Writers store `JSON.stringify` output (no whitespace), so a non-empty array is
- * `[...]` and gains `,event`; `[]`, NULL and anything not array-shaped (a truncated legacy value,
- * which the old JS read also treated as no events) become `[event]`. Plain `substr`/`length`/`||`
- * run unchanged on SQLite and PostgreSQL. */
-function appendedEventsJson({ event }, _optional = {}) {
-    const item = sql `cast(${JSON.stringify(event)} as text)`;
-    return sql `case when events_json like '[_%]' then substr(events_json, 1, length(events_json) - 1) || ',' || ${item} || ']' else '[' || ${item} || ']' end`;
-}
 function sameOwner({ run, required }, _optional = {}) {
     return run.principalId === required.principalId && run.conversationId === required.conversationId;
 }
@@ -176,10 +169,28 @@ export function createDurableRunStore({ kernel: hostKernel, isDaemonRunId }, _op
             .select(eventsColumn.as("events_json"))
             .where(match.column, "=", match.value).where("role", "=", "assistant").executeTakeFirst());
     }
-    /** Every message of the run's conversation; only `load` and legacy rows without attempt metadata pay this. */
-    async function conversationTranscript({ row }, _options = {}) {
+    /** Conversation projection: callers can omit assistant event payloads; legacy heads need only content. */
+    async function conversationTranscript({ row }, { includeEvents = true } = {}) {
         const history = createChatHistoryStore({ kernel, isDaemonRunId, scope: { scopeId: row.scope_id, ownerKind: row.owner_kind, ownerId: row.owner_id } }, {});
-        return history.messages({ conversationId: row.conversation_id });
+        return history.messages({ conversationId: row.conversation_id }, { includeEvents });
+    }
+    /** Legacy accepted requests and recovery reconstruction consume prior text only. */
+    async function readTranscript({ row, metadata }, options = {}) {
+        if (!options.transcript && metadata)
+            return [];
+        const includeEvents = transcriptEventProjection(options);
+        return conversationTranscript({ row }, { includeEvents });
+    }
+    /** Accepted user receipts split queued inputs and hold folder references. Keep that small
+     * public metadata even when recovery omits prior assistant event payloads. */
+    function transcriptEventProjection(options) {
+        if (options.includeTranscriptEvents === false && options.transcript)
+            return 'user';
+        return options.includeTranscriptEvents ?? options.transcript === true;
+    }
+    function currentMessage({ row, transcript }, options = {}) {
+        return options.transcript && options.includeTranscriptEvents !== false
+            ? transcript.find(item => item.id === row.id) : toMessage(row);
     }
     /** One run's head, plus its transcript when that was read (`[]` otherwise). */
     async function readRun({ match }, options = {}) {
@@ -189,11 +200,12 @@ export function createDurableRunStore({ kernel: hostKernel, isDaemonRunId }, _op
         const messageId = row.id;
         const metadata = await kernel.run((db) => db.selectFrom("assistant_run_attempts").selectAll().where("message_id", "=", messageId).executeTakeFirst());
         // A legacy row's accepted request is derived from its transcript, so only it reads one here.
-        const transcript = options.transcript || !metadata ? await conversationTranscript({ row }) : [];
-        const message = options.transcript ? transcript.find((item) => item.id === messageId) : toMessage(row);
+        const transcript = await readTranscript({ row, metadata }, options);
+        const message = currentMessage({ row, transcript }, options);
         if (!message)
             return null; // Deletion may have cascaded between the two reads.
-        return { head: runHead({ row, runId: row.run_id, metadata, message, transcript }, { isDaemonRunId }), transcript };
+        return { head: runHead({ row, runId: row.run_id, metadata, message, transcript }, { isDaemonRunId }),
+            transcript: transcript.map(item => item.id === messageId ? message : item) };
     }
     /** Locked read of one message; `transcript` decides whether it is a whole run or only its head. */
     async function lockedRead({ messageId, conversationId }, options = {}) {
@@ -204,15 +216,70 @@ export function createDurableRunStore({ kernel: hostKernel, isDaemonRunId }, _op
             return readRun({ match: { column: "ai_chat_messages.id", value: messageId } }, options);
         });
     }
-    async function load({ messageId }, _options = {}) {
+    async function load({ messageId }, { includeTranscriptEvents = true } = {}) {
         const binding = await kernel.run((db) => db.selectFrom("ai_chat_messages").select("conversation_id")
             .where("id", "=", messageId).executeTakeFirst());
         if (!binding)
             return null;
-        // The message comes from the transcript, so its row's events are not selected twice.
-        const read = await lockedRead({ messageId, conversationId: binding.conversation_id }, { transcript: true });
+        // Full reads take the message from the transcript. Lean reads select its own events once,
+        // omitting prior assistant payloads while retaining accepted user receipts.
+        const read = await lockedRead({ messageId, conversationId: binding.conversation_id }, { transcript: true, includeTranscriptEvents, events: !includeTranscriptEvents });
         return read && { ...read.head, transcript: read.transcript };
     }
+    /** Single-message read; message identity survives continuation while run_id changes.
+     * Legacy request reconstruction needs only transcript content, never its old event columns. */
+    async function head({ messageId }, { events = true } = {}) {
+        const binding = await kernel.run((db) => db.selectFrom("ai_chat_messages").select("conversation_id")
+            .where("id", "=", messageId).executeTakeFirst());
+        if (!binding)
+            return null;
+        return (await lockedRead({ messageId, conversationId: binding.conversation_id }, { events }))?.head ?? null;
+    }
+    /** Read only one owned projection, without a run lock or accepted-request reconstruction.
+     * Native database versions follow checkpoint growth, replacements, attempts and settlement. SQL omits
+     * content/events on a hit; only changed rows cross into JS as raw JSON, never parsed events.
+     * @complexity One indexed row read; O(1) unchanged payload and JS space; changed payload is O(current message bytes).
+     */
+    async function poll({ messageId, principalId, workspaceId }, { cursor } = {}) {
+        // SQLite has no per-row version: combine this connection's writes with the external-commit
+        // generation. Unrelated writes may invalidate the cursor, but equal-length rewrites cannot
+        // hide. PostgreSQL supplies the row's own MVCC version. Neither reads the event column.
+        const version = kernel.dialect === 'sqlite'
+            ? sqliteReadVersion({ kernel })
+            : sql `cast(ai_chat_messages.xmin as text)`;
+        const changed = sql `${version} <> ${cursor ?? ''}`;
+        // Run writers persist compact JSON arrays on both engines. SQLite also tolerates malformed
+        // legacy rows through its native validator; PG14 has no safe try-cast (do not parse in JS).
+        const valid = kernel.dialect === 'sqlite' ? sql `json_valid(events_json)` : sql `1`;
+        const row = await kernel.run(db => db.selectFrom('ai_chat_messages')
+            .innerJoin('ai_chats', 'ai_chats.id', 'ai_chat_messages.conversation_id')
+            .select(['ai_chat_messages.id', 'conversation_id', 'role'])
+            .select([
+            sql `case when ${changed} then run_id else null end`.as('run_id'),
+            sql `case when ${changed} then run_status else null end`.as('run_status'),
+            sql `case when ${changed} then agent_id else null end`.as('agent_id'),
+            sql `case when ${changed} then agent_name else null end`.as('agent_name'),
+            sql `case when ${changed} then attachments_json else null end`.as('attachments_json'),
+            sql `case when ${changed} then ai_chat_messages.created_at else 0 end`.as('created_at'),
+            sql `case when ${changed} then started_at else null end`.as('started_at'),
+            sql `case when ${changed} then ended_at else null end`.as('ended_at')
+        ])
+            .select([version.as('cursor'),
+            sql `case when ${changed} then content else '' end`.as('content'),
+            sql `case when ${changed} then events_json else null end`.as('events_json'),
+            sql `case when ${changed} then ${valid} else null end`.as('events_json_valid')])
+            .where('ai_chat_messages.id', '=', messageId).where('role', '=', 'assistant')
+            .where('owner_kind', '=', 'user').where('owner_id', '=', principalId).where('scope_id', '=', workspaceId)
+            .executeTakeFirst());
+        if (!row)
+            return null;
+        if (row.cursor === cursor)
+            return { cursor: row.cursor };
+        const metadata = JSON.stringify(toMessage({ ...row, events_json: null }));
+        const events = validatedEventsJson({ row });
+        const messageJson = events === undefined ? metadata : metadata.slice(0, -1) + ',"events":' + events + '}';
+        return { cursor: row.cursor, conversationId: row.conversation_id, messageJson };
+    }
     /** Unlocked probe: the message and conversation an attempt id currently names. */
     async function probeRun({ runId }, _options = {}) {
         return kernel.run((db) => db.selectFrom("ai_chat_messages").select(["id", "conversation_id"])
@@ -267,7 +334,7 @@ export function createDurableRunStore({ kernel: hostKernel, isDaemonRunId }, _op
             const history = await lockOwnedConversation({ required });
             if (!history)
                 return null;
-            const existing = await load({ messageId: required.messageId }, {});
+            const existing = await load({ messageId: required.messageId }, { includeTranscriptEvents: false });
             if (existing)
                 return sameOwner({ run: existing, required }) ? existing : null;
             await assertSlotFree({ conversationId: required.conversationId });
@@ -282,7 +349,7 @@ export function createDurableRunStore({ kernel: hostKernel, isDaemonRunId }, _op
                 recovery_elapsed_ms: 0, attempt_started_at: required.now,
                 session_id: null, session_confirmed: 0, child_pid: null, child_started_at: null, attempt_base_json: "[]",
             }).execute());
-            return load({ messageId: required.messageId }, {});
+            return load({ messageId: required.messageId }, { includeTranscriptEvents: false });
         });
     }
     async function writeAttemptMetadata({ values, updates }) {
@@ -340,18 +407,18 @@ export function createDurableRunStore({ kernel: hostKernel, isDaemonRunId }, _op
             const history = await lockOwnedConversation({ required });
             if (!history)
                 return null;
-            const existing = await load({ messageId: required.messageId }, {});
+            const existing = await load({ messageId: required.messageId }, { includeTranscriptEvents: false });
             if (existing) {
                 if (!sameOwner({ run: existing, required }))
                     return null;
                 await cancel({ runId: existing.runId, reason: "user-stop" }, {});
-                return load({ messageId: existing.messageId }, {});
+                return load({ messageId: existing.messageId }, { includeTranscriptEvents: false });
             }
             // Stop may beat acceptance or its response. A terminal tombstone for the same logical
             // identity makes any later duplicate acceptance a no-op, without reserving the chat slot.
             await history.appendMessage({ conversationId: required.conversationId, message: { id: required.messageId, role: "assistant", content: "",
                     events: [{ kind: "status", label: "Stopped." }], runId: required.runId, runStatus: "canceled", createdAt: required.now, endedAt: required.now } });
-            return load({ messageId: required.messageId }, {});
+            return load({ messageId: required.messageId }, { includeTranscriptEvents: false });
         });
     }
     async function saveAgentSession({ run, sessionId }) {
@@ -430,6 +497,6 @@ export function createDurableRunStore({ kernel: hostKernel, isDaemonRunId }, _op
             await writeAttemptMetadata({ values: { ...row, recovery_deadline: deadline, recovery_elapsed_ms: elapsed }, updates: { recovery_deadline: deadline, recovery_elapsed_ms: elapsed } });
         });
     }
-    return { load, find, accept, advance, cancel, cancelPending, captureSession, clearSession, guardTool, completeTool, recoveryClock };
+    return { load, head, poll, find, accept, advance, cancel, cancelPending, captureSession, clearSession, guardTool, completeTool, recoveryClock };
 }
 //# sourceMappingURL=durable-run-store.js.map

package/dist/store/runtime/events-json.d.ts

@@ -0,0 +1,17 @@
+import type { AgentEvent } from "../../core/index.js";
+/** Replace a compact array's suffix without transferring the stored prefix to JS.
+ * SQL length/substr count characters on SQLite and PostgreSQL, including non-BMP text.
+ * @complexity One SQL string splice; only the new suffix crosses the kernel boundary. */
+export declare function spliceEventsJson({ removeCharacters, suffix }: {
+    removeCharacters: number;
+    suffix: string;
+}, _options?: {}): import("kysely").RawBuilder<string>;
+/** `events_json` with one more event, built in SQL: no dialect parses or re-serializes the saved
+ * array in JS. Writers store `JSON.stringify` output (no whitespace), so a non-empty array is
+ * `[...]` and gains `,event`; `[]`, NULL and anything not array-shaped (a truncated legacy value,
+ * which the old JS read also treated as no events) become `[event]`. Plain `substr`/`length`/`||`
+ * run unchanged on SQLite and PostgreSQL. */
+export declare function appendedEventsJson({ event }: {
+    event: AgentEvent;
+}, _optional?: {}): import("kysely").RawBuilder<string>;
+//# sourceMappingURL=events-json.d.ts.map

package/dist/store/runtime/events-json.js

@@ -0,0 +1,19 @@
+import { sql } from "kysely";
+/** Replace a compact array's suffix without transferring the stored prefix to JS.
+ * SQL length/substr count characters on SQLite and PostgreSQL, including non-BMP text.
+ * @complexity One SQL string splice; only the new suffix crosses the kernel boundary. */
+export function spliceEventsJson({ removeCharacters, suffix }, _options = {}) {
+    return sql `substr(events_json, 1, length(events_json) - ${removeCharacters}) || cast(${suffix} as text)`;
+}
+/** `events_json` with one more event, built in SQL: no dialect parses or re-serializes the saved
+ * array in JS. Writers store `JSON.stringify` output (no whitespace), so a non-empty array is
+ * `[...]` and gains `,event`; `[]`, NULL and anything not array-shaped (a truncated legacy value,
+ * which the old JS read also treated as no events) become `[event]`. Plain `substr`/`length`/`||`
+ * run unchanged on SQLite and PostgreSQL. */
+export function appendedEventsJson({ event }, _optional = {}) {
+    const item = JSON.stringify(event);
+    const suffix = spliceEventsJson({ removeCharacters: 1, suffix: ',' + item + ']' });
+    const empty = '[' + item + ']';
+    return sql `case when events_json like '[_%]' then ${suffix} else cast(${empty} as text) end`;
+}
+//# sourceMappingURL=events-json.js.map

package/dist/store/runtime/run-guarded-chat-store.js

@@ -1,5 +1,11 @@
 /** Bind the server-owned run write fence to an already owner-scoped transcript. */
 export function createRunGuardedChatStore({ store, ledger, isDaemonRunId }, _optional = {}) {
+    async function savedMessage({ conversationId, messageId }, _optional = {}) {
+        if (store.message)
+            return store.message({ conversationId, messageId }, {});
+        // Compatibility for hosts/fakes without the indexed read capability.
+        return (await store.messages({ conversationId })).find(message => message.id === messageId) ?? null;
+    }
     return {
         ...store,
         /*
@@ -24,7 +30,7 @@ export function createRunGuardedChatStore({ store, ledger, isDaemonRunId }, _opt
                     // attempt id or a transport-only failure; returning the stored row fences both without
                     // matching presentation text. BYOK/AG-UI remain request-bound.
                     if (isDaemonRunId({ runId })) {
-                        const saved = (await store.messages({ conversationId })).find((m) => m.id === message.id);
+                        const saved = await savedMessage({ conversationId, messageId: message.id });
                         if (saved)
                             return saved;
                         if (message.runStatus !== "queued" && message.runStatus !== "running")
@@ -34,8 +40,7 @@ export function createRunGuardedChatStore({ store, ledger, isDaemonRunId }, _opt
                 } }, {});
             if (outcome.written)
                 return outcome.value;
-            const saved = await store.messages({ conversationId });
-            return saved.find((m) => m.id === message.id) ?? null;
+            return savedMessage({ conversationId, messageId: message.id });
         },
     };
 }

package/dist/store/runtime/run-ledger.d.ts

@@ -6,8 +6,8 @@ export { runLockKey } from "../../core/durable-runs/run-lock.js";
 /**
  * @param store the chat kernel, or the open `chat.db` handle `createChatStoreFactory` also wraps.
  * @param now Injectable epoch-millisecond clock for progress stamps and the default cancel time.
- * @complexity each method is one or two indexed statements, except `reconcileInterrupted`, which
- *   is O(stuck rows).
+ * @complexity indexed guards; checkpoints cost O(delta bytes) plus a SQLite scalar receipt read,
+ *   or O(saved + incoming bytes) on fallback. Reconcile costs O(stuck rows + their event bytes).
  */
 export declare function createChatRunLedger<DB extends ChatDatabase>({ kernel: hostKernel, isDaemonRunId }: {
     kernel: ChatKernel<DB>;