@jini-ai/chat 0.6.19 → 0.6.21

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

@@ -1,4 +1,8 @@
 import { dedupeToolUsesById } from "../../core/tool-events.js";
+import { sql } from "kysely";
+import { sqliteReadVersion } from "../sql/read-version.js";
+import { spliceEventsJson } from "./events-json.js";
+import { checkpointDelta, checkpointState, hasNewToolProgress, toolKey } from "./checkpoint-delta.js";
 import { chatKernelTables } from "../sql/boundary.js";
 import { createDurableRunStore } from "./durable-run-store.js";
 /**
@@ -48,18 +52,6 @@ function readEvents(eventsJson) {
     }
     return Array.isArray(events) ? events : [];
 }
-/** Tool identity shared by progress detection and checkpoint merging; "" for non-tool events. */
-function toolKey(event) {
-    if (event.kind === "tool_use")
-        return `use:${event.id}`;
-    if (event.kind === "tool_result")
-        return `result:${event.toolUseId}`;
-    return "";
-}
-function hasNewToolProgress(current, next) {
-    const saved = new Set(current.map(toolKey));
-    return next.some((event) => { const id = toolKey(event); return id !== "" && !saved.has(id); });
-}
 /** Retain a longer checkpoint's text and merge non-text replay events under the shared ID rule.
  * @complexity O(b + n) time and space for b serialized bytes across n events. */
 function retainSavedEvents(saved, incoming) {
@@ -72,9 +64,11 @@ function retainSavedEvents(saved, incoming) {
  *
  * The saved `events_json` is parsed ONCE and reused by both the merge and the progress check:
  * a long turn's column is many MB, and a host checkpoints every second (memory cause 3).
- * Appending only new events instead of rewriting the column is NOT equivalent: storage coalesces
- * text deltas (the last text event grows in place) and the merge puts saved-only tool barriers
- * after the replay's events, so an existing element or the tail changes on most checkpoints.
+ * Blindly appending only new events is NOT equivalent: storage coalesces text deltas (the last
+ * text event grows in place) and the merge puts saved-only tool barriers after replay events.
+ * The watch-owned delta may replace that text tail only after an exact incoming write; saved-only
+ * barriers disable it. Native versions, SQL lengths and bounded suffix CAS detect concurrent
+ * appends and equal-length replacements; any miss uses this authoritative merge, never a ledger cache or freshness stamp.
  * @complexity O(b + n) time and space for b serialized bytes across n events; one parse, one stringify.
  */
 function planCheckpoint({ current, progress }, _optional = {}) {
@@ -86,27 +80,30 @@ function planCheckpoint({ current, progress }, _optional = {}) {
     const runStatus = current.run_status === "queued" ? "running" : current.run_status;
     return {
         eventsJson,
+        exact: events.length === progress.events.length && events.every((event, index) => event === progress.events[index]),
         runStatus,
-        grown: progress.content.length > current.content.length || hasNewToolProgress(saved, events),
+        grown: progress.content.length > current.content.length || hasNewToolProgress({ saved, incoming: events }),
         unchanged: runStatus === current.run_status && progress.content === current.content && eventsJson === current.events_json,
     };
 }
 /** Preserve tool barriers absent from a replay, with one persisted use per tool ID.
  * @complexity O(n) time and space in the combined saved and incoming event count. */
 function keepToolCheckpoints(saved, incoming) {
-    const seen = new Set(incoming.map(toolKey));
+    const seen = new Set(incoming.map(event => toolKey({ event })));
     // Deduplicate after merging: a legacy checkpoint or replay can repeat an ID with different
     // serialized input. The shared ID rule owns identity; JSON equality does not.
-    return dedupeToolUsesById({ events: [...incoming, ...saved.filter((event) => { const id = toolKey(event); return id !== "" && !seen.has(id); })] });
+    return dedupeToolUsesById({ events: [...incoming, ...saved.filter((event) => { const id = toolKey({ event }); return id !== "" && !seen.has(id); })] });
 }
 /**
  * @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 function createChatRunLedger({ kernel: hostKernel, isDaemonRunId }, { now = () => Date.now() } = {}) {
     const kernel = chatKernelTables({ kernel: hostKernel }, {});
+    const version = kernel.dialect === 'sqlite' ? sqliteReadVersion({ kernel }) : sql `cast(ai_chat_messages.xmin as text)`;
+    const returnedVersion = kernel.dialect === 'sqlite' ? sql `null` : version;
     async function isSettled(run) {
         const row = await kernel.run((db) => db
             .selectFrom("ai_chat_messages")
@@ -117,8 +114,99 @@ export function createChatRunLedger({ kernel: hostKernel, isDaemonRunId }, { now
             .executeTakeFirst());
         return isTerminal(row?.run_status);
     }
+    /** Progress earns a fresh recovery budget. Replayed prefixes/dividers cannot keep a failing
+     * attempt alive forever. Kept separate so full and delta writes use exactly the same reset. */
+    async function recordProgress({ progress }, _options = {}) {
+        await kernel.run((db) => db.updateTable("assistant_run_attempts")
+            .set({ recovery_count: 0, recovery_deadline: null, recovery_elapsed_ms: 0, last_progress_at: now() })
+            .where("message_id", "=", progress.messageId).execute());
+    }
+    /** One guarded delta UPDATE, no saved-column read or parse. A miss is deliberately indistinguishable
+     * from an ineligible delta: both must consult the authoritative checkpoint path under this lock. */
+    async function writeDelta({ progress, optional }, _options = {}) {
+        const { previous, expected } = optional;
+        if (!previous || expected !== previous.length)
+            return false;
+        const delta = checkpointDelta({ previous, progress });
+        if (!delta)
+            return false;
+        const result = await kernel.run((db) => db.updateTable("ai_chat_messages")
+            .set({ content: progress.content, events_json: spliceEventsJson(delta),
+            run_status: sql `case when run_status = 'queued' then 'running' else run_status end` })
+            .where(activeRunPredicate({ run: progress }))
+            .where(sql `${version} = ${previous.version}`)
+            .where(sql `length(events_json) = ${expected}`)
+            // BYOK/AG-UI browser upserts can replace a queued/running projection at the same length.
+            // Durable tool appends grow the length; recovery replacements also change run_id.
+            .where(sql `substr(events_json, length(events_json) - length(cast(${previous.tail} as text)) + 1) = ${previous.tail}`)
+            .where(sql `length(content) = ${previous.contentLength}`)
+            .returning([sql `length(events_json)`.as("length"), sql `length(content)`.as("contentLength"), returnedVersion.as("version")])
+            .executeTakeFirst());
+        if (!result)
+            return false;
+        if (delta.grown)
+            await recordProgress({ progress });
+        await notifyPersisted({ progress, optional, length: Number(result.length), contentLength: Number(result.contentLength), nativeVersion: result.version, exact: true });
+        return true;
+    }
+    /** A saved-only barrier invalidates the receipt. SQLite samples its connection/external-commit
+     * generation after ALL writes, while still under the transaction lock. Never capture a later
+     * writer's version beside this projection. PG returns the updated row's own MVCC version.
+     * @complexity O(1) scalar SQLite read per requested receipt; no payload query or PG extra read.
+     */
+    async function notifyPersisted({ progress, optional, length, contentLength, nativeVersion, exact }, _options = {}) {
+        if (!optional.onPersisted)
+            return;
+        if (!exact) {
+            optional.onPersisted(undefined);
+            return;
+        }
+        const receiptVersion = kernel.dialect === 'sqlite'
+            ? (await kernel.query(sql `select ${version} as version`))[0].version : nativeVersion;
+        optional.onPersisted(checkpointState({ progress, length, contentLength, version: receiptVersion }));
+    }
+    /** Full merge fallback, including identical-checkpoint write elision. One parse/stringify only. */
+    async function writeFullCheckpoint({ progress, optional }, _options = {}) {
+        const current = await kernel.run((db) => db.selectFrom("ai_chat_messages")
+            .select(["content", "events_json", "run_status", sql `length(events_json)`.as("length"), sql `length(content)`.as("contentLength"), returnedVersion.as("version")])
+            .where(activeRunPredicate({ run: progress })).executeTakeFirst());
+        if (!current || progress.content.length < current.content.length)
+            return false;
+        const plan = planCheckpoint({ current, progress });
+        // Identical content/events are not progress; accepting without rewriting leaves both the
+        // multi-MB column and recovery budget exactly as the guarded UPDATE would have.
+        // Under this lock the row was just matched by the update's own predicate, so the update
+        // would match (true); returning true without writing preserves that contract.
+        if (plan.unchanged) {
+            await notifyPersisted({ progress, optional, length: Number(current.length), contentLength: Number(current.contentLength), nativeVersion: current.version, exact: plan.exact });
+            return true;
+        }
+        const result = await kernel.run((db) => db.updateTable("ai_chat_messages")
+            .set({ content: progress.content, events_json: plan.eventsJson, run_status: plan.runStatus })
+            .where(activeRunPredicate({ run: progress }))
+            .returning([sql `length(events_json)`.as("length"), sql `length(content)`.as("contentLength"), returnedVersion.as("version")]).executeTakeFirst());
+        if (!result)
+            return false;
+        if (plan.grown)
+            await recordProgress({ progress });
+        await notifyPersisted({ progress, optional, length: Number(result.length), contentLength: Number(result.contentLength), nativeVersion: result.version, exact: plan.exact });
+        return true;
+    }
     return {
         durable: createDurableRunStore({ kernel, isDaemonRunId }, {}),
+        /** One bounded existence read, across owners and engines. Stale active rows conservatively
+         * keep the host awake; recovery belongs to the serving boot, never an idle probe.
+         * @complexity O(log n) covering-index lookup for n messages; O(1) returned space, no payload reads.
+         */
+        async hasActiveRuns(_required = {}, _optional = {}) {
+            const row = await kernel.run(db => db.selectFrom("ai_chat_messages").select("id")
+                .where("role", "=", "assistant")
+                // Keep the fixed literal predicate identical to the partial index. Parameterized IN
+                // cannot establish SQLite's partial-index implication at plan time.
+                .where(sql `run_status in ('queued', 'running')`)
+                .limit(1).executeTakeFirst());
+            return row !== undefined;
+        },
         unlessSettled({ run, write }, _optional = {}) {
             return kernel.transaction(async () => {
                 await kernel.lockKey(runLockKey(run));
@@ -161,34 +249,21 @@ export function createChatRunLedger({ kernel: hostKernel, isDaemonRunId }, { now
                 return true;
             });
         },
-        async checkpoint(progress, _optional = {}) {
-            return kernel.transaction(async () => {
+        async checkpoint(progress, optional = {}) {
+            let persisted = false;
+            let receipt;
+            // Publish the watch receipt only after COMMIT. A rollback must not advance its CAS base.
+            const transactionOptions = optional.onPersisted
+                ? { ...optional, onPersisted: (value) => { persisted = true; receipt = value; } } : optional;
+            const written = await kernel.transaction(async () => {
                 await kernel.lockKey(runLockKey(progress));
-                const current = await kernel.run((db) => db.selectFrom("ai_chat_messages").select(["content", "events_json", "run_status"])
-                    .where(activeRunPredicate({ run: progress })).executeTakeFirst());
-                if (!current || progress.content.length < current.content.length)
-                    return false;
-                const { eventsJson, runStatus, grown, unchanged } = planCheckpoint({ current, progress });
-                // An identical checkpoint would rewrite the same multi-MB column for nothing. Under this lock
-                // the row was just matched by the update's own predicate, so the update would match (true),
-                // and identical content and events are never progress (`grown` is false), so skipping it
-                // leaves the row and the recovery budget exactly as the write would have.
-                if (unchanged)
+                if (await writeDelta({ progress, optional: transactionOptions }))
                     return true;
-                const result = await kernel.run((db) => db
-                    .updateTable("ai_chat_messages")
-                    .set({ content: progress.content, events_json: eventsJson, run_status: runStatus })
-                    .where(activeRunPredicate({ run: progress }))
-                    .executeTakeFirst());
-                if (Number(result.numUpdatedRows) > 0 && grown) {
-                    // Progress earns a fresh recovery budget. Replayed prefixes and the coordinator's
-                    // divider are not progress and cannot keep a repeatedly failing attempt alive forever.
-                    await kernel.run((db) => db.updateTable("assistant_run_attempts")
-                        .set({ recovery_count: 0, recovery_deadline: null, recovery_elapsed_ms: 0, last_progress_at: now() })
-                        .where("message_id", "=", progress.messageId).execute());
-                }
-                return Number(result.numUpdatedRows) > 0;
+                return writeFullCheckpoint({ progress, optional: transactionOptions });
             });
+            if (persisted)
+                optional.onPersisted?.(receipt);
+            return written;
         },
         async reconcileInterrupted(required = {}, optional = {}) {
             const stuck = await kernel.run((db) => db

package/dist/store/sql/read-version.d.ts

@@ -0,0 +1,15 @@
+import { type RawBuilder } from 'kysely';
+/** SQLite invalidation without scanning message rows. Both same-connection writes and external
+ * commits invalidate; the kernel epoch prevents counters reused after reopen from hiding changes.
+ * @param required.kernel The existing borrowed connection identity; never opens or changes it.
+ * @param optional.mintEpoch Injectable epoch source, called once per live kernel.
+ * @returns A SQL scalar with bounded output, without event/content reads or writes.
+ * @complexity O(1) time and weak identity space per kernel.
+ * @example sqliteReadVersion({ kernel });
+ */
+export declare function sqliteReadVersion({ kernel }: {
+    kernel: object;
+}, { mintEpoch }?: {
+    mintEpoch?: () => string;
+}): RawBuilder<string>;
+//# sourceMappingURL=read-version.d.ts.map

package/dist/store/sql/read-version.js

@@ -0,0 +1,21 @@
+import { sql } from 'kysely';
+// Weak identity metadata only, never row data. Closing/replacing a kernel releases its epoch with GC.
+const epochs = new WeakMap();
+/** SQLite invalidation without scanning message rows. Both same-connection writes and external
+ * commits invalidate; the kernel epoch prevents counters reused after reopen from hiding changes.
+ * @param required.kernel The existing borrowed connection identity; never opens or changes it.
+ * @param optional.mintEpoch Injectable epoch source, called once per live kernel.
+ * @returns A SQL scalar with bounded output, without event/content reads or writes.
+ * @complexity O(1) time and weak identity space per kernel.
+ * @example sqliteReadVersion({ kernel });
+ */
+export function sqliteReadVersion({ kernel }, { mintEpoch = () => globalThis.crypto.randomUUID() } = {}) {
+    let epoch = epochs.get(kernel);
+    if (epoch === undefined) {
+        epoch = mintEpoch();
+        epochs.set(kernel, epoch);
+    }
+    // Connection-wide counters invalidate every row on any chat.db write; concurrent chats can erase the cache savings.
+    return sql `${epoch} || ':' || cast(total_changes() as text) || ':' || cast((select data_version from pragma_data_version) as text)`;
+}
+//# sourceMappingURL=read-version.js.map

package/dist/store/sql/store.d.ts

@@ -20,6 +20,15 @@ interface MessageRow {
 }
 /** Project only existing ai_* fields: resumable and lastRunEventId belong to run state. */
 export declare function toMessage(row: MessageRow): ChatMessage;
+type RawMessageRow = MessageRow & {
+    events_json_valid: number | null;
+};
+/** Keep malformed-column tolerance without reserializing event trees. SQLite validates in SQL;
+ * PostgreSQL 14 lacks a safe built-in JSON try-cast, so validate and discard one row's parsed value.
+ * @complexity O(row JSON size) time; PG14 temporarily allocates one event tree, SQLite none. */
+export declare function validatedEventsJson({ row }: {
+    row: Pick<RawMessageRow, "events_json" | "events_json_valid">;
+}, _optional?: {}): string | undefined;
 /**
  * Returns a {@link ChatHistoryStore} that can only ever see `scope`'s own conversations.
  *

package/dist/store/sql/store.js

@@ -1,3 +1,4 @@
+import { sqliteReadVersion } from './read-version.js';
 import { withFolderReceipt, foldersFromReceipts } from '../../core/accepted-input.js';
 const MESSAGE_POSITION = 'm.position';
 const CONVERSATION_UPDATED_AT = 'c.updated_at';
@@ -92,6 +93,61 @@ function jsonFields(row) {
         ...(attachments === undefined ? {} : { attachments }),
     };
 }
+/** Project metadata without retaining assistant event trees. User folder receipts still hydrate
+ * through the existing mapper; unusual assistant receipts with folders need the same projection. */
+function rawMessageMetadata({ row }, _optional = {}) {
+    const hasFolderReceipt = row.events_json?.includes(`"name":"${MID_RUN_USER_MESSAGE_EVENT_NAME}"`) && row.events_json.includes('"folders"');
+    const needsReceipts = row.role === 'user' || hasFolderReceipt;
+    const message = toMessage({ ...row, events_json: needsReceipts ? row.events_json : null });
+    delete message.events;
+    return message;
+}
+/** Keep malformed-column tolerance without reserializing event trees. SQLite validates in SQL;
+ * PostgreSQL 14 lacks a safe built-in JSON try-cast, so validate and discard one row's parsed value.
+ * @complexity O(row JSON size) time; PG14 temporarily allocates one event tree, SQLite none. */
+export function validatedEventsJson({ row }, _optional = {}) {
+    if (!row.events_json)
+        return undefined;
+    if (row.events_json_valid !== null)
+        return Number(row.events_json_valid) === 1 ? row.events_json : undefined;
+    try {
+        JSON.parse(row.events_json);
+        return row.events_json;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Emit metadata and opaque event JSON separately, so neither an aggregate response string nor
+ * all parsed assistant events coexist. The borrowed query still holds O(total stored JSON) strings.
+ * @complexity O(total JSON bytes) time/retained raw strings; PG validation peaks at one event tree. */
+async function* messageJsonChunks({ rows }, { orderMessages = messages => messages } = {}) {
+    const byId = new Map(rows.map(row => [row.id, row]));
+    const messages = orderMessages(rows.map(row => rawMessageMetadata({ row })));
+    yield '{"messages":[';
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index];
+        const eventsJson = validatedEventsJson({ row: byId.get(message.id) });
+        if (index > 0)
+            yield ',';
+        const metadataJson = JSON.stringify(message);
+        if (eventsJson === undefined) {
+            yield metadataJson;
+            continue;
+        }
+        yield metadataJson.slice(0, -1) + ',"events":';
+        yield eventsJson;
+        yield '}';
+    }
+    yield ']}';
+}
+/** Receipt-bearing user rows retain their public metadata while large assistant histories stay
+ * outside recovery/acceptance projections. Both dialects evaluate the same CASE expression. */
+function messageEventsColumn({ includeEvents }, _options = {}) {
+    if (includeEvents === 'user')
+        return sql `case when m.role = 'user' then m.events_json else null end`;
+    return includeEvents ? sql `m.events_json` : sql `null`;
+}
 /** Empty run columns are omitted. */
 function runFields(row) {
     return {
@@ -164,7 +220,7 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
         return row ? toConversation(row) : null;
     }
     /** One scoped projection for all message reads, including the row returned by an upsert. */
-    function ownedMessages(db, conversationId) {
+    function ownedMessages(db, conversationId, { includeEvents = true } = {}) {
         return db
             .selectFrom("ai_chat_messages as m")
             .innerJoin("ai_chats as c", "c.id", "m.conversation_id")
@@ -174,7 +230,6 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
             "m.content",
             "m.agent_id",
             "m.agent_name",
-            "m.events_json",
             "m.attachments_json",
             "m.run_id",
             "m.run_status",
@@ -182,14 +237,15 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
             "m.started_at",
             "m.ended_at",
         ])
+            .select(messageEventsColumn({ includeEvents }).as('events_json'))
             .where("m.conversation_id", "=", conversationId)
             .where("c.scope_id", "=", scopeId)
             .where("c.owner_kind", "=", ownerKind)
             .where("c.owner_id", "=", ownerId);
     }
     /** Read owned messages in persisted position order; foreign IDs produce no rows. */
-    async function messages({ conversationId }, _optional = {}) {
-        const rows = await run(db => ownedMessages(db, conversationId).orderBy(MESSAGE_POSITION).execute());
+    async function messages({ conversationId }, { includeEvents = true } = {}) {
+        const rows = await run(db => ownedMessages(db, conversationId, { includeEvents }).orderBy(MESSAGE_POSITION).execute());
         return rows.map(toMessage);
     }
     /** Writes and projects one message inside the borrowed transaction; null for absent/foreign IDs. */
@@ -369,6 +425,32 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
                 .execute());
         },
         messages,
+        /** One indexed, owner-scoped row; browser save fences do not need the conversation's history. */
+        async message({ conversationId, messageId }, _optional = {}) {
+            const row = await run(db => ownedMessages(db, conversationId).where('m.id', '=', messageId).executeTakeFirst());
+            return row ? toMessage(row) : null;
+        },
+        /** SQLite's connection/external-commit counters avoid reading message rows at all. PG uses
+         * MVCC versions from only this conversation's indexed metadata, never large event columns.
+         * @complexity O(1) SQLite; O(n) PG message metadata for n messages; O(1) returned bytes.
+         */
+        async messagesVersion({ conversationId }, _optional = {}) {
+            const row = await run(db => db.selectFrom('ai_chats as c').select(eb => {
+                const version = kernel.dialect === 'sqlite' ? sqliteReadVersion({ kernel })
+                    : sql `md5(coalesce(${eb.selectFrom('ai_chat_messages as m')
+                        .select(sql `string_agg(m.id || ':' || cast(m.xmin as text), ',' order by m.position)`.as('versions'))
+                        .whereRef('m.conversation_id', '=', 'c.id')}, ''))`;
+                return version.as('version');
+            })
+                .where('c.id', '=', conversationId).where('c.scope_id', '=', scopeId)
+                .where('c.owner_kind', '=', ownerKind).where('c.owner_id', '=', ownerId).executeTakeFirst());
+            return row?.version ?? null;
+        },
+        async messagesJson({ conversationId }, optional = {}) {
+            const valid = kernel.dialect === 'sqlite' ? sql `json_valid(m.events_json)` : sql `null`;
+            const rows = await run(db => ownedMessages(db, conversationId).select(valid.as('events_json_valid')).orderBy(MESSAGE_POSITION).execute());
+            return messageJsonChunks({ rows }, optional);
+        },
         async appendMessage({ conversationId, message }, _optional = {}) {
             const prepared = redactUserMessage({ message }, { ...(redactionOptions.redactUserText ? { redactUserText: redactionOptions.redactUserText } : {}) });
             const saved = await writeMessage(conversationId, prepared.message);
@@ -429,6 +511,9 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
         touch: (required, optional = {}) => atStoreBoundary({ operation: () => store.touch(required, optional) }),
         delete: (required, optional = {}) => atStoreBoundary({ operation: () => store.delete(required, optional) }),
         messages: (required, optional = {}) => atStoreBoundary({ operation: () => store.messages(required, optional) }),
+        message: (required, optional = {}) => atStoreBoundary({ operation: () => store.message(required, optional) }),
+        messagesVersion: (required, optional = {}) => atStoreBoundary({ operation: () => store.messagesVersion(required, optional) }),
+        messagesJson: (required, optional = {}) => atStoreBoundary({ operation: () => store.messagesJson(required, optional) }),
         appendMessage: (required, optional = {}) => atStoreBoundary({ operation: () => store.appendMessage(required, optional) }),
         pageConversations: (required, optional = {}) => atStoreBoundary({ operation: () => store.pageConversations(required, optional) }),
         pageMessages: (required, optional = {}) => atStoreBoundary({ operation: () => store.pageMessages(required, optional) }),

package/dist/store/sqlite/schema.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module store/sqlite/schema
  *
- * Canonical unchanged DDL for ai_chats and ai_chat_messages. Hosts own their database,
+ * Canonical DDL for ai_chats and ai_chat_messages. Hosts own their database,
  * migration ledger and connection configuration. A host with migrations retains its frozen
  * migration statements; a fresh fixture or host without a migrator may call the explicit helper.
  * Store construction never invokes it, chooses a file, or sets connection-wide pragmas.
@@ -30,7 +30,7 @@ import type { SqliteClient } from '@jini-ai/db/sqlite';
  *   `expires_at IS NOT NULL`, so authenticated history is out of its reach by construction, not
  *   by a predicate that could drift.
  */
-export declare const CHAT_HISTORY_DDL = "\nCREATE TABLE IF NOT EXISTS ai_chats (\n  id            TEXT PRIMARY KEY,\n  scope_id      TEXT NOT NULL,\n  owner_kind    TEXT NOT NULL CHECK (owner_kind IN ('user','guest')),\n  owner_id      TEXT NOT NULL,\n  title         TEXT,\n  title_source  TEXT NOT NULL DEFAULT 'fallback'\n                CHECK (title_source IN ('fallback','generated','manual')),\n  created_at    INTEGER NOT NULL,\n  updated_at    INTEGER NOT NULL,\n  expires_at    INTEGER\n);\n\nCREATE INDEX IF NOT EXISTS idx_ai_chats_owner\n  ON ai_chats(scope_id, owner_kind, owner_id, updated_at DESC);\n\nCREATE INDEX IF NOT EXISTS idx_ai_chats_expiry\n  ON ai_chats(expires_at) WHERE expires_at IS NOT NULL;\n\nCREATE TABLE IF NOT EXISTS ai_chat_messages (\n  id              TEXT PRIMARY KEY,\n  conversation_id TEXT NOT NULL REFERENCES ai_chats(id) ON DELETE CASCADE,\n  role            TEXT NOT NULL CHECK (role IN ('user','assistant')),\n  content         TEXT NOT NULL,\n  agent_id        TEXT,\n  agent_name      TEXT,\n  events_json     TEXT,\n  attachments_json TEXT,\n  run_id          TEXT,\n  run_status      TEXT,\n  position        INTEGER NOT NULL,\n  created_at      INTEGER NOT NULL,\n  started_at      INTEGER,\n  ended_at        INTEGER,\n  UNIQUE (conversation_id, position)\n);\n\nCREATE INDEX IF NOT EXISTS idx_ai_chat_messages_order\n  ON ai_chat_messages(conversation_id, position);\n";
+export declare const CHAT_HISTORY_DDL = "\nCREATE TABLE IF NOT EXISTS ai_chats (\n  id            TEXT PRIMARY KEY,\n  scope_id      TEXT NOT NULL,\n  owner_kind    TEXT NOT NULL CHECK (owner_kind IN ('user','guest')),\n  owner_id      TEXT NOT NULL,\n  title         TEXT,\n  title_source  TEXT NOT NULL DEFAULT 'fallback'\n                CHECK (title_source IN ('fallback','generated','manual')),\n  created_at    INTEGER NOT NULL,\n  updated_at    INTEGER NOT NULL,\n  expires_at    INTEGER\n);\n\nCREATE INDEX IF NOT EXISTS idx_ai_chats_owner\n  ON ai_chats(scope_id, owner_kind, owner_id, updated_at DESC);\n\nCREATE INDEX IF NOT EXISTS idx_ai_chats_expiry\n  ON ai_chats(expires_at) WHERE expires_at IS NOT NULL;\n\nCREATE TABLE IF NOT EXISTS ai_chat_messages (\n  id              TEXT PRIMARY KEY,\n  conversation_id TEXT NOT NULL REFERENCES ai_chats(id) ON DELETE CASCADE,\n  role            TEXT NOT NULL CHECK (role IN ('user','assistant')),\n  content         TEXT NOT NULL,\n  agent_id        TEXT,\n  agent_name      TEXT,\n  events_json     TEXT,\n  attachments_json TEXT,\n  run_id          TEXT,\n  run_status      TEXT,\n  position        INTEGER NOT NULL,\n  created_at      INTEGER NOT NULL,\n  started_at      INTEGER,\n  ended_at        INTEGER,\n  UNIQUE (conversation_id, position)\n);\n\nCREATE INDEX IF NOT EXISTS idx_ai_chat_messages_order\n  ON ai_chat_messages(conversation_id, position);\n\n-- Idle probes read only this covering index, never the overflowing event rows.\nCREATE INDEX IF NOT EXISTS idx_ai_chat_messages_active\n  ON ai_chat_messages(role, run_status, id) WHERE run_status IN ('queued', 'running');\n";
 /**
  * Creates the chat-history tables in the given database if they are absent.
  *

package/dist/store/sqlite/schema.js

@@ -61,6 +61,10 @@ CREATE TABLE IF NOT EXISTS ai_chat_messages (
 
 CREATE INDEX IF NOT EXISTS idx_ai_chat_messages_order
   ON ai_chat_messages(conversation_id, position);
+
+-- Idle probes read only this covering index, never the overflowing event rows.
+CREATE INDEX IF NOT EXISTS idx_ai_chat_messages_active
+  ON ai_chat_messages(role, run_status, id) WHERE run_status IN ('queued', 'running');
 `;
 /**
  * Creates the chat-history tables in the given database if they are absent.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/chat",
-  "version": "0.6.19",
+  "version": "0.6.21",
   "description": "Jini's chat/artifact frontend, consolidated into one package with two subpaths: framework-free chat vocabulary and pure parsers in `/core`, headless hooks + presentational components + slots in `/react`. Import only the layer you need.",
   "license": "Apache-2.0",
   "repository": {
@@ -214,10 +214,10 @@
   },
   "dependencies": {
     "kysely": "^0.29.6",
-    "@jini-ai/core": "^0.6.19",
-    "@jini-ai/db": "^0.6.19",
+    "@jini-ai/core": "^0.6.21",
+    "@jini-ai/diagnostics": "^0.6.19",
     "@jini-ai/agentic": "^0.6.19",
-    "@jini-ai/diagnostics": "^0.6.19"
+    "@jini-ai/db": "^0.6.19"
   },
   "peerDependencies": {
     "react": "^18.3.0 || ^19.0.0",
@@ -261,13 +261,13 @@
     "pg": "8.23.0",
     "@ag-ui/core": "0.0.58",
     "fast-check": "4.3.0",
-    "@jini-ai/db": "0.6.19",
     "@jini-ai/agentic": "^0.6.19",
+    "@jini-ai/core": "^0.6.21",
     "@jini-ai/agent-runtime": "0.6.19",
-    "@jini-ai/protocol": "^0.6.19",
     "@jini-ai/diagnostics": "^0.6.19",
-    "@jini-ai/ui": "^0.6.19",
-    "@jini-ai/core": "^0.6.19"
+    "@jini-ai/db": "0.6.19",
+    "@jini-ai/protocol": "^0.6.19",
+    "@jini-ai/ui": "^0.6.19"
   },
   "typesVersions": {
     "*": {