@jini-ai/chat 0.6.15 → 0.6.17

package/dist/react/hooks/composer-draft-cache.js

@@ -59,6 +59,8 @@ export const COMPOSER_DRAFT_STORAGE_PREFIX = 'jini.chat.composer-draft.v1.';
  * so a corrupt or unwritable attachment entry can never cost the operator their words, and vice
  * versa. See {@link readCachedAttachments} for what these references are and are not.
  */
+const COMPOSER_FOLDERS_STORAGE_PREFIX = 'jini.chat.composer-folders.v1.';
+const folderDrafts = new Map();
 export const COMPOSER_ATTACHMENTS_STORAGE_PREFIX = 'jini.chat.composer-attachments.v1.';
 const drafts = new Map();
 const stagedAttachments = new Map();
@@ -465,11 +467,33 @@ export function writeCachedAttachments({ conversationId, attachments }) {
  */
 export function __resetComposerDraftCacheForTests(options) {
     drafts.clear();
+    folderDrafts.clear();
     stagedAttachments.clear();
     stagedBatchIds.clear();
     if (options?.keepStorage === true)
         return;
+    pruneStored(COMPOSER_FOLDERS_STORAGE_PREFIX, 0);
     pruneStored(COMPOSER_DRAFT_STORAGE_PREFIX, 0);
     pruneStored(COMPOSER_ATTACHMENTS_STORAGE_PREFIX, 0);
 }
+/** Folder drafts share the bounded cache owner, but never upload liveness or TTL checks. */
+export function readCachedFolders({ conversationId }, _options = {}) {
+    if (!conversationId)
+        return [];
+    const cached = folderDrafts.get(conversationId);
+    if (cached)
+        return [...cached];
+    const stored = readStoredEnvelope(COMPOSER_FOLDERS_STORAGE_PREFIX, { conversationId, decode: parsed => {
+            const value = parsed;
+            return value?.v === 1 && Array.isArray(value.folders) && value.folders.every(path => typeof path === 'string') ? value.folders : null;
+        } });
+    return stored ?? [];
+}
+/** Persist exact strings independently of text and attachment validation. */
+export function writeCachedFolders({ conversationId, folders }, _options = {}) {
+    if (!conversationId)
+        return;
+    setBounded(folderDrafts, { key: conversationId, value: [...folders] });
+    writeStoredEnvelope(COMPOSER_FOLDERS_STORAGE_PREFIX, { conversationId, envelope: folders.length ? { v: 1, t: Date.now(), folders } : null });
+}
 //# sourceMappingURL=composer-draft-cache.js.map

package/dist/react/hooks/useComposer.d.ts

@@ -72,6 +72,13 @@ export interface UseComposerResult {
     /** Optional for compatibility with host-created composer controllers. */
     history?: ComposerHistoryController;
     setDraft: (next: string) => void;
+    folders?: string[];
+    addFolders: (input: {
+        folders: readonly string[];
+    }, options?: {}) => void;
+    removeFolder: (input: {
+        path: string;
+    }, options?: {}) => void;
     attachments: ChatAttachment[];
     /** Uploads via `project.uploadFiles` (when supplied) and stages the results; no-ops (with a rejected promise) when no upload port is wired. */
     addAttachments: (files: File[]) => Promise<void>;

package/dist/react/hooks/useComposer.js

@@ -29,7 +29,7 @@
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useComposerHistory } from './useComposerHistory.hooks.js';
-import { readCachedAttachments, readCachedDraft, rememberCachedDraft, writeCachedAttachments, writeCachedDraft, } from './composer-draft-cache.js';
+import { readCachedFolders, writeCachedFolders, readCachedAttachments, readCachedDraft, rememberCachedDraft, writeCachedAttachments, writeCachedDraft, } from './composer-draft-cache.js';
 import { cacheAttachmentPreviewSource } from './attachment-preview-cache.js';
 /**
  * The real window/document pair, or `null` when this runtime has no `window` — a non-DOM React
@@ -104,6 +104,23 @@ function useDeferredDraftWrite(pageLifecycle) {
 export function useComposer(options = {}) {
     const { project, composerSlots, persistence, conversationId, validateAttachments } = options;
     const [draft, setDraftState] = useState(() => options.initialDraft ?? persistence?.read() ?? readCachedDraft({ conversationId: conversationId }) ?? '');
+    const [folders, setFolders] = useState(() => readCachedFolders({ conversationId }));
+    // Persist inside the state transition with its conversation key: switching cannot write an old
+    // render's folders over the newly selected conversation, and a pick survives immediate unmount.
+    const addFolders = useCallback(({ folders: picked }, _options = {}) => {
+        setFolders(previous => {
+            const next = [...new Set([...previous, ...picked])];
+            writeCachedFolders({ conversationId, folders: next });
+            return next;
+        });
+    }, [conversationId]);
+    const removeFolder = useCallback(({ path }, _options = {}) => {
+        setFolders(previous => {
+            const next = previous.filter(folder => folder !== path);
+            writeCachedFolders({ conversationId, folders: next });
+            return next;
+        });
+    }, [conversationId]);
     const [attachments, setAttachments] = useState([]);
     const [agent, setAgent] = useState(options.initialAgent);
     const [mention, setMention] = useState(EMPTY_MENTION);
@@ -164,8 +181,13 @@ export function useComposer(options = {}) {
         // reason — nothing was switched away from.
         if (previousConversationId == null && conversationId != null && restored === null && draftRef.current.trim() !== '') {
             writeCachedDraft({ conversationId: conversationId, draft: draftRef.current });
+            writeCachedFolders({ conversationId, folders });
             return;
         }
+        if (previousConversationId == null && conversationId != null)
+            writeCachedFolders({ conversationId, folders });
+        else
+            setFolders(readCachedFolders({ conversationId }));
         setDraftState(restored ?? '');
         setAttachments([]);
         setMention(EMPTY_MENTION);
@@ -284,14 +306,19 @@ export function useComposer(options = {}) {
     }, [draft, setDraft]);
     const reset = useCallback(() => {
         setDraft('');
+        setFolders([]);
+        writeCachedFolders({ conversationId, folders: [] });
         clearAttachments();
         closeMention();
-    }, [clearAttachments, closeMention, setDraft]);
-    const canSubmit = draft.trim().length > 0 || attachments.length > 0;
+    }, [clearAttachments, closeMention, setDraft, conversationId]);
+    const canSubmit = draft.trim().length > 0 || attachments.length > 0 || folders.length > 0;
     return useMemo(() => ({
         draft,
         history,
         setDraft,
+        folders,
+        addFolders,
+        removeFolder,
         attachments,
         addAttachments,
         addAttachment,
@@ -306,6 +333,6 @@ export function useComposer(options = {}) {
         canSubmit,
         reset,
         flushDraft: deferredWrite.flush,
-    }), [draft, history, setDraft, attachments, addAttachments, addAttachment, removeAttachment, clearAttachments, agent, mention, openMention, closeMention, selectMention, canSubmit, reset, deferredWrite.flush]);
+    }), [draft, history, setDraft, folders, addFolders, removeFolder, attachments, addAttachments, addAttachment, removeAttachment, clearAttachments, agent, mention, openMention, closeMention, selectMention, canSubmit, reset, deferredWrite.flush]);
 }
 //# sourceMappingURL=useComposer.js.map

package/dist/react/hooks/useConversation.d.ts

@@ -27,6 +27,8 @@ export interface SendMessageOptions {
     }) => void;
     /** Non-secret signal from a composer that already sanitized the content before this boundary. */
     secretRedaction?: ChatMessage['secretRedaction'];
+    /** Picked directory paths, kept byte-exact and separate from upload references. */
+    folders?: string[];
     attachments?: ChatAttachment[];
     context?: RunContext;
     agentId?: string;

package/dist/react/hooks/useConversation.js

@@ -32,6 +32,7 @@ function pendingUserMessage({ content, sendOptions, createMessageId }, options =
             content,
             createdAt: Date.now(),
             ...(sendOptions.secretRedaction ? { secretRedaction: sendOptions.secretRedaction } : {}),
+            ...(sendOptions.folders ? { folders: sendOptions.folders } : {}),
             ...(sendOptions.attachments ? { attachments: sendOptions.attachments } : {}),
         } }, options).message;
 }
@@ -213,6 +214,7 @@ export function useConversation(options) {
             history,
             ...(resolvedAgentId !== undefined ? { agentId: resolvedAgentId } : {}),
             conversationId,
+            ...(sendOptions.folders !== undefined ? { folders: sendOptions.folders } : {}),
             ...(sendOptions.attachments !== undefined ? { attachments: sendOptions.attachments } : {}),
             ...(sendOptions.context !== undefined ? { context: sendOptions.context } : {}),
         });
@@ -222,7 +224,7 @@ export function useConversation(options) {
             setSendRefused(true);
             return;
         }
-        const inputs = sendOptions.acceptedInputs ?? [{ id: userMessage.id, text: userMessage.content }];
+        const inputs = sendOptions.acceptedInputs ?? [{ id: userMessage.id, text: userMessage.content, ...(userMessage.folders ? { folders: userMessage.folders } : {}) }];
         setMessagesState(prev => prev.map(message => message.id === userMessage.id ? { ...message, inputPending: false } : message));
         sendOptions.onAccepted?.({ inputs });
     }, [agentId, conversationId, createMessageId, run, options.redactUserText, options.onSecretRedacted]);
@@ -254,6 +256,7 @@ export function useConversation(options) {
             history,
             ...(resolvedAgentId !== undefined ? { agentId: resolvedAgentId } : {}),
             conversationId,
+            ...(priorUser.folders !== undefined ? { folders: priorUser.folders } : {}),
             ...(priorUser.attachments !== undefined ? { attachments: priorUser.attachments } : {}),
         });
     }, [agentId, conversationId, run, options.redactUserText, options.onSecretRedacted]);

package/dist/react/hooks/useUserTextGuard.d.ts

@@ -7,5 +7,6 @@ export declare function useUserTextGuard(options: UserTextRedactionOptions, _opt
     }, _options?: {}) => import("../index.js").UserTextRedaction;
     redactText: (text: string) => string;
     notifyRedaction: (signal: SecretRedactionSignal) => void;
+    clearNotice: () => void;
 };
 //# sourceMappingURL=useUserTextGuard.d.ts.map

package/dist/react/hooks/useUserTextGuard.js

@@ -14,6 +14,8 @@ export function useUserTextGuard(options, _optional = {}) {
         return result;
     }, [options.redactUserText, notifyRedaction]);
     const redactText = useCallback((text) => redact({ text }, {}).text, [redact]);
-    return { secretRedacted, redact, redactText, notifyRedaction };
+    /** The notice is about one message: the pane clears it when the person sends the next one (a key in that one sets it again) or dismisses it. */
+    const clearNotice = useCallback(() => setSecretRedacted(false), []);
+    return { secretRedacted, redact, redactText, notifyRedaction, clearNotice };
 }
 //# sourceMappingURL=useUserTextGuard.js.map

package/dist/react/styles/reference.css

@@ -328,3 +328,9 @@
  * deleted silently) so a future reader who remembers seeing "queued" in this file finds the pointer
  * instead of concluding the removal was accidental.
  */
+
+.jini-composer-attachments, .jini-folder-chips__list { display: flex; flex-wrap: wrap; }
+.jini-folder-chips, .jini-folder-chips__name { min-width: 0; max-width: 100%; overflow-wrap: anywhere; }
+.jini-folder-chips__toggle, .jini-folder-chips__item { display: flex; align-items: center; }
+.jini-folder-chips__list { list-style: none; }
+.jini-folder-chips svg, .jini-folder-chips button { flex-shrink: 0; }

package/dist/react/tool-call-display.d.ts

@@ -32,6 +32,17 @@ export interface ToolDisplayRow {
 export declare function isFailedToolRow({ row }: {
     row: Pick<ToolDisplayRow, 'status'>;
 }): boolean;
+/**
+ * Ids of failed rows that a LATER successful call of the same tool and target retried (owner, 2026-10-31: a
+ * red "HTTP 400 … page was NOT written" row and "· 2 failed" stayed on screen after the immediate
+ * retry wrote the page). Those rows render as a neutral "Retried" and are not counted as failed;
+ * a failure nothing later succeeded at stays red. Inputs without target coordinates match by
+ * tool alone; a targetless success cannot clear a failure naming a target. Pass one turn's rows.
+ * @complexity O(n + target bytes) time and space.
+ */
+export declare function retriedToolRowIds({ rows }: {
+    rows: readonly ToolDisplayRow[];
+}, _options?: {}): ReadonlySet<string>;
 /**
  * Applies a display mode to an interleaved message.
  *

package/dist/react/tool-call-display.js

@@ -1,4 +1,4 @@
-import { humanizeToolName } from '../core/index.js';
+import { humanizeToolName, isDelegatedWrapperToolName } from '../core/index.js';
 /**
  * Whether a row failed: the tool returned an error, or the run
  * ended without the tool ever answering (`deriveToolStatus` maps both to `'error'`).
@@ -7,6 +7,62 @@ import { humanizeToolName } from '../core/index.js';
 export function isFailedToolRow({ row }) {
     return row.status === 'error';
 }
+/** The tool a row called: a delegated wrapper's `input.toolId`, else its own name (wrappers share one name). */
+function toolIdentity(row) {
+    if (!isDelegatedWrapperToolName({ name: row.name }))
+        return row.name;
+    const input = row.use?.input;
+    const toolId = typeof input === 'object' && input !== null ? input.toolId : undefined;
+    return typeof toolId === 'string' && toolId ? toolId : row.name;
+}
+/** Prefer a stable id over editable slugs/paths; normalize input aliases within each kind.
+ * @complexity O(target bytes), fixed field count; pure, absent coordinates return undefined.
+ */
+function targetCoordinate({ input }, _options = {}) {
+    const kinds = [
+        ['id', ['postId', 'post_id', 'pageId', 'page_id', 'entryId', 'entry_id', 'id']],
+        ['slug', ['slug']],
+        ['path', ['path', 'filePath', 'file_path']],
+    ];
+    for (const [kind, fields] of kinds) {
+        const field = fields.find(key => typeof input[key] === 'number' || (typeof input[key] === 'string' && input[key] !== ''));
+        if (field !== undefined)
+            return [kind, input[field]];
+    }
+    return undefined;
+}
+/** Target coordinates only: corrected content must not prevent a retry from matching.
+ * Wrapper inputs belong to the delegated tool, whose identity toolIdentity already resolves.
+ * @complexity O(target bytes); the coordinate list is fixed. Pure, with no input mutation.
+ */
+function retryIdentity({ row }, _options = {}) {
+    const input = row.use?.input;
+    const record = typeof input === 'object' && input !== null ? input : {};
+    const target = isDelegatedWrapperToolName({ name: row.name }) ? record.input : record;
+    const coordinates = typeof target === 'object' && target !== null ? target : {};
+    return JSON.stringify([toolIdentity(row), targetCoordinate({ input: coordinates })]);
+}
+/**
+ * Ids of failed rows that a LATER successful call of the same tool and target retried (owner, 2026-10-31: a
+ * red "HTTP 400 … page was NOT written" row and "· 2 failed" stayed on screen after the immediate
+ * retry wrote the page). Those rows render as a neutral "Retried" and are not counted as failed;
+ * a failure nothing later succeeded at stays red. Inputs without target coordinates match by
+ * tool alone; a targetless success cannot clear a failure naming a target. Pass one turn's rows.
+ * @complexity O(n + target bytes) time and space.
+ */
+export function retriedToolRowIds({ rows }, _options = {}) {
+    const succeededLater = new Set();
+    const retried = new Set();
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+        const row = rows[i];
+        const tool = retryIdentity({ row });
+        if (row.status === 'complete')
+            succeededLater.add(tool);
+        else if (isFailedToolRow({ row }) && succeededLater.has(tool))
+            retried.add(row.id);
+    }
+    return retried;
+}
 /** Running = no result yet while the run streams (`'executing'`), or not started (`'inProgress'`). */
 function isRunningToolRow(row) {
     return row.status === 'executing' || row.status === 'inProgress';
@@ -109,7 +165,8 @@ export function summarizeToolGroup({ rows }) {
         if (isRunningToolRow(row))
             return { kind: 'running', name: humanizeToolName({ name: row.name }, { input: row.use?.input }) };
     }
-    return { kind: 'done', count: rows.length, failed: rows.filter((row) => isFailedToolRow({ row })).length };
+    const retried = retriedToolRowIds({ rows });
+    return { kind: 'done', count: rows.length, failed: rows.filter((row) => isFailedToolRow({ row }) && !retried.has(row.id)).length };
 }
 /**
  * The collapsed line's text. Each phrase is its own translation key (the English string is the key,

package/dist/store/legacy/sqlite/messages.d.ts

@@ -25,6 +25,12 @@ export declare function listMessages({ db, conversationId }: {
     db: SqliteDb;
     conversationId: string;
 }): {
+    sessionMode: ChatSessionMode | undefined;
+    runContext: any;
+    createdAt: any;
+    startedAt: any;
+    endedAt: any;
+    folders?: string[];
     id: any;
     role: any;
     content: any;
@@ -35,11 +41,6 @@ export declare function listMessages({ db, conversationId }: {
     lastRunEventId: any;
     events: any;
     attachments: any;
-    sessionMode: ChatSessionMode | undefined;
-    runContext: any;
-    createdAt: any;
-    startedAt: any;
-    endedAt: any;
 }[];
 /**
  * Thrown by `upsertMessage` when the caller presents a message `id` together with a
@@ -150,6 +151,12 @@ export declare function deleteMessage({ db, id }: {
 }): void;
 /** @internal Converts a raw SQLite row to a plain object with JSON columns parsed and null coerced to undefined. */
 declare function normalizeMessage(row: DbRow): {
+    sessionMode: ChatSessionMode | undefined;
+    runContext: any;
+    createdAt: any;
+    startedAt: any;
+    endedAt: any;
+    folders?: string[];
     id: any;
     role: any;
     content: any;
@@ -160,11 +167,6 @@ declare function normalizeMessage(row: DbRow): {
     lastRunEventId: any;
     events: any;
     attachments: any;
-    sessionMode: ChatSessionMode | undefined;
-    runContext: any;
-    createdAt: any;
-    startedAt: any;
-    endedAt: any;
 };
 export {};
 //# sourceMappingURL=messages.d.ts.map

package/dist/store/legacy/sqlite/messages.js

@@ -1,3 +1,4 @@
+import { withFolderReceipt, foldersFromReceipts } from "../../../core/accepted-input.js";
 import { redactUserText } from '../../../core/user-text-redaction.js';
 import { parseJsonOrUndef } from '@jini-ai/db/core';
 /** @internal Column alias list used by both `listMessages` and `upsertMessage`'s re-fetch. */
@@ -117,7 +118,7 @@ function messageFieldValues(m) {
         m.role,
         m.content,
         ...[m.agentId, m.agentName, m.runId, m.runStatus, m.lastRunEventId].map(orNull),
-        jsonOrNull(m.events),
+        jsonOrNull(withFolderReceipt({ message: m }).events),
         jsonOrNull(m.attachments),
         normalizeMessageSessionMode(m.sessionMode) ?? null,
         jsonOrNull(m.runContext),
@@ -273,6 +274,7 @@ export function deleteMessage({ db, id }) {
 }
 /** @internal Converts a raw SQLite row to a plain object with JSON columns parsed and null coerced to undefined. */
 function normalizeMessage(row) {
+    const folders = foldersFromReceipts({ events: parseJsonOrUndef(row.eventsJson) });
     return {
         id: row.id,
         role: row.role,
@@ -284,6 +286,7 @@ function normalizeMessage(row) {
         lastRunEventId: row.lastRunEventId ?? undefined,
         events: parseJsonOrUndef(row.eventsJson),
         attachments: parseJsonOrUndef(row.attachmentsJson),
+        ...(folders.length ? { folders } : {}),
         sessionMode: normalizeMessageSessionMode(row.sessionMode),
         runContext: parseJsonOrUndef(row.runContextJson),
         createdAt: row.createdAt ?? undefined,

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

@@ -1,3 +1,5 @@
+import { acceptedInputEvent, acceptedInputUserEvent } from "../../core/accepted-input.js";
+import { redactUserMessage } from "../../core/user-text-redaction.js";
 import { recoveredRunEvents } from "../../core/index.js";
 import { chatKernelTables } from "../sql/boundary.js";
 import { sql } from "kysely";
@@ -18,6 +20,10 @@ function isAcceptedUserShape({ message }, _optional = {}) {
         return false;
     return message.createdAt === undefined || Number.isFinite(message.createdAt);
 }
+/** Directory existence is host policy; the neutral store validates only its message contract. */
+function validAcceptedFolders({ folders }, _options = {}) {
+    return Array.isArray(folders) && folders.length <= 10 && folders.every(path => typeof path === 'string' && path.length > 0);
+}
 function areAcceptedAttachments({ attachments }, _optional = {}) {
     return Array.isArray(attachments) && attachments.every((attachment) => {
         if (!attachment || typeof attachment.path !== "string" || typeof attachment.name !== "string")
@@ -25,6 +31,31 @@ function areAcceptedAttachments({ attachments }, _optional = {}) {
         return attachment.kind === "file" || attachment.kind === "image";
     });
 }
+/** Both top-level and queued user inputs obey the same reference contract. */
+function validateAcceptedMetadata({ message }, _options = {}) {
+    if (message.folders !== undefined && !validAcceptedFolders({ folders: message.folders }))
+        throw new Error("Invalid accepted user folders");
+    if (message.attachments !== undefined && !areAcceptedAttachments({ attachments: message.attachments }, {}))
+        throw new Error("Invalid accepted user attachments");
+}
+/** Preserve only accepted user receipts; a browser cannot supply assistant lifecycle events.
+ * Receipt text uses the same guard as ordinary user text; folder data remains byte-exact.
+ */
+function acceptedReceiptFields({ message }, _options = {}) {
+    if (!Array.isArray(message.events))
+        return {};
+    const events = message.events.flatMap(event => {
+        if (!event || typeof event !== 'object')
+            return [];
+        const input = acceptedInputEvent({ event })?.data;
+        if (!input)
+            return [];
+        validateAcceptedMetadata({ message: input });
+        const safe = redactUserMessage({ message: { role: 'user', content: input.text } }).message;
+        return [acceptedInputUserEvent({ input: { ...input, text: safe.content } }, { receipt: 'accepted' })];
+    });
+    return events.length ? { events } : {};
+}
 function acceptedUserMessage({ request, now }, _optional = {}) {
     const context = JSON.parse(request.contextRef);
     // Older clients supplied only a prompt; never invent a user identity from that transcript.
@@ -33,11 +64,12 @@ function acceptedUserMessage({ request, now }, _optional = {}) {
         return null;
     if (!isAcceptedUserShape({ message }, {}))
         throw new Error("Invalid accepted user message");
-    if (message.attachments !== undefined && !areAcceptedAttachments({ attachments: message.attachments }, {}))
-        throw new Error("Invalid accepted user attachments");
-    // User input cannot claim an assistant run's status/events. Keep the same identity and payload
+    validateAcceptedMetadata({ message });
+    // User input cannot claim assistant lifecycle events. Keep the same identity and payload
     // as its browser PUT, including the original clock and attachment order.
     return { id: message.id, role: "user", content: message.content, createdAt: message.createdAt ?? now,
+        ...acceptedReceiptFields({ message }),
+        ...(message.folders ? { folders: message.folders } : {}),
         ...(message.attachments ? { attachments: message.attachments } : {}) };
 }
 function recoveryFields({ row, metadata }, _optional = {}) {

package/dist/store/sql/store.js

@@ -1,3 +1,4 @@
+import { withFolderReceipt, foldersFromReceipts } from '../../core/accepted-input.js';
 const MESSAGE_POSITION = 'm.position';
 const CONVERSATION_UPDATED_AT = 'c.updated_at';
 /** One SQL query body upstreamed from the existing host adapter; no resource/schema ownership. */
@@ -84,8 +85,10 @@ function agentFields(row) {
 function jsonFields(row) {
     const events = parseJsonColumn(row.events_json);
     const attachments = parseJsonColumn(row.attachments_json);
+    const folders = foldersFromReceipts({ events });
     return {
         ...(events === undefined ? {} : { events }),
+        ...(folders.length ? { folders } : {}),
         ...(attachments === undefined ? {} : { attachments }),
     };
 }
@@ -190,7 +193,8 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
         return rows.map(toMessage);
     }
     /** Writes and projects one message inside the borrowed transaction; null for absent/foreign IDs. */
-    function writeMessage(conversationId, m) {
+    function writeMessage(conversationId, message) {
+        const m = withFolderReceipt({ message });
         return kernel.transaction(async () => {
             await kernel.lockKey(conversationLockKey(conversationId));
             const owned = await run((db) => db