@adecore/agents 0.21.0 → 0.21.1

package/dist/chat/ui-queries.js

@@ -1,18 +1,40 @@
 import { randomUUID } from 'node:crypto';
-import { copyUiValue, UiBudget } from '@adecore/intelligent-ui';
+import { copyUiValue, UI_HOST_LIMITS, UiBudget, uiMayReferenceHost } from '@adecore/intelligent-ui';
 import { UiLinkResolutionSchema, uiLinkTargets } from '@adecore/intelligent-ui/links';
 import { uiQueryArguments, uiQueryFallback } from '@adecore/intelligent-ui/query';
 import { ChatError } from './errors.js';
+/*
+ * A failure a client can say in its own words: `reason` is a code that stays the same across versions,
+ * the message is the fallback for a client that does not know the code.
+ */
+class UiQueryError extends ChatError {
+    reason;
+    constructor(code, reason, message) {
+        super(code, message);
+        this.reason = reason;
+    }
+}
+/*
+ * What a host's `authorize`, `read` or `link` throws to say why with a code: `code` reaches the reading's
+ * `code` and should stay the same across versions, `reason` is the plain sentence a client shows without it.
+ */
+export class ChatUiRefusal extends UiQueryError {
+    constructor(code, reason) {
+        super('refused-query', code, reason);
+    }
+}
 const MAX_QUERY_BYTES = 64 * 1024;
 const MAX_SNAPSHOT_BYTES = 128 * 1024;
-const MAX_QUERIES = 8;
-const REFRESH_MS = 10_000;
 const READ_TIMEOUT_MS = 8_000;
+// A changed input reads at once, but a query never reads more often than this across its inputs.
+const INPUT_READ_MS = 250;
 export class ChatUiQueries {
     schemas;
     captures = new Map();
     freezing = new Set();
     cache = new Map();
+    // The read id of the newest reading per cache key, which a remount or a second client is answered with.
+    latest = new Map();
     reading = new Map();
     attempts = new Map();
     active = new Map();
@@ -23,14 +45,16 @@ export class ChatUiQueries {
         this.schemas = Object.fromEntries(Object.entries(host.sources).map(([name, source]) => [name, source.args]));
     }
     observe(session, item, final) {
-        if (!item.text.includes('@Query') && !/<(?:File|Diff|Commit|Node)\b/.test(item.text) && !item.ui?.some((block) => Object.keys(block.queries).length)) {
+        const key = `${session.id}:${item.id}`;
+        // Once a capture started, every delta of a streaming reply would scan its whole text again for nothing.
+        const captured = this.captures.has(key) || item.uiQueries?.authorChatId === session.id;
+        if (!captured && !uiMayReferenceHost(item.text) && !item.ui?.some((block) => Object.keys(block.queries).length)) {
             return;
         }
         const capture = this.access(session, item);
         if (!final || !item.ui?.length) {
             return;
         }
-        const key = `${session.id}:${item.id}`;
         if (this.freezing.has(key)) {
             return;
         }
@@ -47,7 +71,7 @@ export class ChatUiQueries {
                 }
                 const readings = Object.create(null);
                 const values = Object.create(null);
-                for (const name of Object.keys(block.queries).slice(0, MAX_QUERIES)) {
+                for (const name of Object.keys(block.queries).slice(0, UI_HOST_LIMITS.queries)) {
                     const reading = await this.query(session, {
                         chatId: session.id,
                         itemId: item.id,
@@ -64,12 +88,12 @@ export class ChatUiQueries {
                 if (this.host.link) {
                     const targets = uiLinkTargets(block, {}, values);
                     const access = await this.access(session, current);
-                    for (const [id, target] of Object.entries(targets).slice(0, 64)) {
+                    for (const [id, target] of Object.entries(targets).slice(0, UI_HOST_LIMITS.links)) {
                         try {
-                            links[id] = this.linkReading(await this.host.link(session.info, access.access, target));
+                            links[id] = this.linkReading(await this.host.link(session.info, access, target));
                         }
                         catch (error) {
-                            links[id] = { state: 'plain', reason: this.reason(error) };
+                            links[id] = { state: 'plain', ...this.failure(error) };
                         }
                     }
                 }
@@ -94,9 +118,9 @@ export class ChatUiQueries {
                 if (Buffer.byteLength(JSON.stringify(blocks)) > MAX_SNAPSHOT_BYTES) {
                     frozen.readings = Object.fromEntries(Object.keys(readings).map((name) => [
                         name,
-                        { state: 'failed', readAt: Date.now(), reason: 'The frozen query values are too large.' }
+                        { state: 'failed', readAt: Date.now(), code: 'snapshot-too-large', reason: 'The frozen query values are too large.' }
                     ]));
-                    frozen.links = Object.fromEntries(Object.keys(links).map((id) => [id, { state: 'plain', reason: 'This link must be checked again.' }]));
+                    frozen.links = Object.fromEntries(Object.keys(links).map((id) => [id, { state: 'plain', code: 'link-unchecked', reason: 'This link must be checked again.' }]));
                     frozen.fallback = `${block.fallback.slice(0, 2048)}\nSources: ${names}\nThe frozen query values are too large.`;
                 }
                 if (Buffer.byteLength(JSON.stringify(blocks)) > MAX_SNAPSHOT_BYTES) {
@@ -108,6 +132,7 @@ export class ChatUiQueries {
             .catch(() => { })
             .finally(() => this.freezing.delete(key));
     }
+    /* The writer's access for a reply, captured once; null where it was denied or is unavailable. */
     access(session, item) {
         const key = `${session.id}:${item.id}`;
         const existing = this.captures.get(key);
@@ -115,10 +140,11 @@ export class ChatUiQueries {
             return existing;
         }
         if (item.uiQueries?.authorChatId === session.id) {
-            return Promise.resolve(item.uiQueries);
+            return Promise.resolve(session.uiAccess(item.id) ?? null);
         }
         // A pending capture is persisted as denied, so a restart cannot widen the writer's rights.
-        session.updateUiQueries(item.id, { authorChatId: session.id, access: null, blocks: {} });
+        session.setUiAccess(item.id, null);
+        session.updateUiQueries(item.id, { authorChatId: session.id, blocks: {} });
         const captured = this.host
             .capture(session.info)
             .then((access) => {
@@ -126,11 +152,10 @@ export class ChatUiQueries {
             if (Buffer.byteLength(JSON.stringify(captured)) > 32 * 1024) {
                 throw new Error('The UI access snapshot is too large.');
             }
-            const state = { authorChatId: session.id, access: captured, blocks: {} };
-            session.updateUiQueries(item.id, state);
-            return state;
+            session.setUiAccess(item.id, captured);
+            return captured;
         })
-            .catch(() => ({ authorChatId: session.id, access: null, blocks: {} }))
+            .catch(() => null)
             .finally(() => this.captures.delete(key));
         this.captures.set(key, captured);
         return captured;
@@ -139,18 +164,18 @@ export class ChatUiQueries {
         const item = session.thread.get(payload.itemId);
         const block = item?.kind === 'assistant' && !item.streaming && !item.parentToolUseId ? item.ui?.find((entry) => entry.id === payload.blockId) : undefined;
         if (item?.kind !== 'assistant' || !block?.complete || block.revision !== payload.revision) {
-            throw new ChatError('stale-ui-block', 'This completed UI block is no longer available.');
+            throw new UiQueryError('stale-ui-block', 'block-stale', 'This completed UI block is no longer available.');
         }
         return { item, block };
     }
     stored(session, payload) {
         const { item, block } = this.storedBlock(session, payload);
-        if (!Object.hasOwn(block.queries, payload.query) || Object.keys(block.queries).length > MAX_QUERIES) {
-            throw new ChatError('refused-query', 'This block does not declare an allowed query.');
+        if (!Object.hasOwn(block.queries, payload.query) || Object.keys(block.queries).length > UI_HOST_LIMITS.queries) {
+            throw new UiQueryError('refused-query', 'query-undeclared', 'This block does not declare an allowed query.');
         }
         const name = block.queries[payload.query].source;
         if (!Object.hasOwn(this.host.sources, name)) {
-            throw new ChatError('refused-query', 'This query source is not registered.');
+            throw new UiQueryError('refused-query', 'source-unregistered', 'This query source is not registered.');
         }
         return { item, block, source: this.host.sources[name] };
     }
@@ -164,19 +189,18 @@ export class ChatUiQueries {
             ({ source, block, item } = this.stored(session, payload));
             args = uiQueryArguments(block, payload.query, payload.values);
             args = source.args.parse(args);
-            const access = await this.access(session, item);
-            if (access.access === null) {
-                throw new ChatError('refused-query', 'The writer’s original access is unavailable.');
+            authorAccess = await this.access(session, item);
+            if (authorAccess === null) {
+                throw new UiQueryError('refused-query', 'access-unavailable', 'The writer’s original access is unavailable.');
             }
-            authorAccess = access.access;
             await source.authorize(session.info, authorAccess, args);
         }
         catch (error) {
-            return { state: 'refused', readAt: Date.now(), reason: this.reason(error) };
+            return { state: 'refused', readAt: Date.now(), ...this.failure(error) };
         }
         const key = JSON.stringify([session.id, item.id, block.id, block.revision, payload.query, args]);
-        const cached = [...this.cache.values()].find((entry) => entry.key === key);
-        if (cached && Date.now() - cached.reading.readAt < REFRESH_MS) {
+        const cached = this.cache.get(this.latest.get(key) ?? '');
+        if (cached && Date.now() - cached.reading.readAt < UI_HOST_LIMITS.refreshMilliseconds) {
             return cached.reading;
         }
         const pending = this.reading.get(key);
@@ -184,14 +208,17 @@ export class ChatUiQueries {
             return pending;
         }
         const identity = JSON.stringify([session.id, item.id, block.id, block.revision, payload.query]);
-        if (Date.now() - (this.attempts.get(identity) ?? 0) < REFRESH_MS) {
-            return { state: 'failed', readAt: Date.now(), reason: 'This query may refresh once every ten seconds.' };
+        const now = Date.now();
+        if (now - (this.attempts.get(key) ?? -Infinity) < UI_HOST_LIMITS.refreshMilliseconds ||
+            now - (this.attempts.get(identity) ?? -Infinity) < INPUT_READ_MS) {
+            return { state: 'failed', readAt: now, code: 'refresh-limit', reason: 'This query may refresh once every ten seconds.' };
         }
         if ((this.active.get(session.id) ?? 0) >= 2 || this.totalActive >= 16) {
-            return { state: 'failed', readAt: Date.now(), reason: 'Too many UI queries are being read.' };
+            return { state: 'failed', readAt: now, code: 'busy', reason: 'Too many UI queries are being read.' };
         }
-        this.attempts.set(identity, Date.now());
-        while (this.attempts.size > 128) {
+        this.attempts.set(key, now);
+        this.attempts.set(identity, now);
+        while (this.attempts.size > 256) {
             this.attempts.delete(this.attempts.keys().next().value);
         }
         this.active.set(session.id, (this.active.get(session.id) ?? 0) + 1);
@@ -202,21 +229,24 @@ export class ChatUiQueries {
         timeout.unref?.();
         const read = Promise.race([
             work,
-            new Promise((_, reject) => controller.signal.addEventListener('abort', () => reject(new Error('The UI query timed out.')), { once: true }))
+            new Promise((_, reject) => controller.signal.addEventListener('abort', () => reject(new UiQueryError('refused-query', 'timed-out', 'The UI query timed out.')), {
+                once: true
+            }))
         ])
             .then((result) => {
             const value = copyUiValue(source.result.parse(result), new UiBudget());
             if (Buffer.byteLength(JSON.stringify(value)) > MAX_QUERY_BYTES) {
-                throw new Error('The UI query result is too large.');
+                throw new UiQueryError('refused-query', 'result-too-large', 'The UI query result is too large.');
             }
             const reading = { state: 'fresh', value, readId: randomUUID(), readAt: Date.now() };
             this.cache.set(reading.readId, { key, chatId: session.id, reading });
+            this.latest.set(key, reading.readId);
             while (this.cache.size > 128) {
-                this.cache.delete(this.cache.keys().next().value);
+                this.evict(this.cache.keys().next().value);
             }
             return reading;
         })
-            .catch((error) => ({ state: 'failed', readAt: Date.now(), reason: this.reason(error) }))
+            .catch((error) => ({ state: 'failed', readAt: Date.now(), ...this.failure(error) }))
             .finally(() => {
             clearTimeout(timeout);
             this.reading.delete(key);
@@ -237,31 +267,40 @@ export class ChatUiQueries {
         this.reading.set(key, read);
         return read;
     }
+    /* The issued value of every query the block declares, each checked against the read id the person saw. */
     async choiceValues(session, payload) {
         const item = session.thread.get(payload.itemId);
         const block = item?.kind === 'assistant' ? item.ui?.find((entry) => entry.id === payload.blockId) : undefined;
         if (!block || item?.kind !== 'assistant' || ('choiceId' in payload && item.uiAnswers?.[block.id]?.revision === payload.revision)) {
             return {};
         }
+        const names = Object.keys(block.queries);
         const values = Object.create(null);
-        for (const name of Object.keys(payload.reads ?? {})) {
-            const identity = { ...payload, query: name };
-            const { source } = this.stored(session, identity);
+        if (names.length === 0) {
+            return values;
+        }
+        const access = await this.access(session, item);
+        if (access === null) {
+            throw new UiQueryError('refused-query', 'access-unavailable', 'The writer’s original access is unavailable.');
+        }
+        for (const name of names) {
+            const { source } = this.stored(session, { ...payload, query: name });
             const args = source.args.parse(uiQueryArguments(block, name, payload.values));
-            const access = await this.access(session, item);
-            await source.authorize(session.info, access.access, args);
+            await source.authorize(session.info, access, args);
+            const readId = payload.reads !== undefined && Object.hasOwn(payload.reads, name) ? payload.reads[name] : undefined;
             const key = JSON.stringify([session.id, item.id, block.id, block.revision, name, args]);
-            const readId = payload.reads[name];
-            const cached = this.cache.get(readId);
+            const cached = readId === undefined ? undefined : this.cache.get(readId);
             const frozen = item.uiQueries?.blocks[block.id];
             const snapshot = frozen?.revision === block.revision ? frozen?.readings[name] : undefined;
-            const reading = cached?.key === key
-                ? cached.reading
-                : snapshot?.readId === readId && JSON.stringify(args) === JSON.stringify(source.args.parse(uiQueryArguments(block, name)))
-                    ? snapshot
-                    : undefined;
+            const reading = readId === undefined
+                ? undefined
+                : cached?.key === key
+                    ? cached.reading
+                    : snapshot?.readId === readId && JSON.stringify(args) === JSON.stringify(source.args.parse(uiQueryArguments(block, name)))
+                        ? snapshot
+                        : undefined;
             if (!reading || reading.state !== 'fresh') {
-                throw new ChatError('stale-ui-query', 'Refresh this query before sending its choice.');
+                throw new UiQueryError('stale-ui-query', 'stale-read', 'Refresh this query before sending its choice.');
             }
             values[name] = reading.value;
         }
@@ -270,34 +309,41 @@ export class ChatUiQueries {
     async link(session, payload) {
         try {
             if (!this.host.link) {
-                throw new ChatError('refused-query', 'This host does not provide UI links.');
+                throw new UiQueryError('refused-query', 'links-unsupported', 'This host does not provide UI links.');
             }
             const { item, block } = this.storedBlock(session, payload);
             if (!item.uiQueries) {
-                throw new ChatError('refused-query', 'The writer’s original access is unavailable.');
+                throw new UiQueryError('refused-query', 'access-unavailable', 'The writer’s original access is unavailable.');
             }
             const access = await this.access(session, item);
-            if (access.access === null) {
-                throw new ChatError('refused-query', 'The writer’s original access is unavailable.');
+            if (access === null) {
+                throw new UiQueryError('refused-query', 'access-unavailable', 'The writer’s original access is unavailable.');
             }
             const queries = await this.choiceValues(session, payload);
             const target = uiLinkTargets(block, payload.values, queries)[payload.nodeId];
             if (!target) {
-                throw new ChatError('refused-query', 'This visible node is not a supported link.');
+                throw new UiQueryError('refused-query', 'link-unsupported', 'This visible node is not a supported link.');
             }
-            return this.linkReading(await this.host.link(session.info, access.access, target));
+            return this.linkReading(await this.host.link(session.info, access, target));
         }
         catch (error) {
-            return { state: 'plain', reason: this.reason(error) };
+            return { state: 'plain', ...this.failure(error) };
         }
     }
     forget(chatId) {
         for (const [id, cached] of this.cache) {
             if (cached.chatId === chatId) {
-                this.cache.delete(id);
+                this.evict(id);
             }
         }
     }
+    evict(readId) {
+        const cached = this.cache.get(readId);
+        this.cache.delete(readId);
+        if (cached && this.latest.get(cached.key) === readId) {
+            this.latest.delete(cached.key);
+        }
+    }
     linkReading(value) {
         const reading = UiLinkResolutionSchema.parse(copyUiValue(value, new UiBudget()));
         if (reading.state === 'chip' && !reading.target) {
@@ -305,7 +351,8 @@ export class ChatUiQueries {
         }
         return reading;
     }
-    reason(error) {
-        return (error instanceof Error ? error.message : 'This query could not be read.').slice(0, 240);
+    failure(error) {
+        const reason = (error instanceof Error ? error.message : 'This query could not be read.').slice(0, 240);
+        return error instanceof UiQueryError ? { reason, code: error.reason } : { reason };
     }
 }

package/dist/host/handlers.js

@@ -32,7 +32,7 @@ export function chatHandlers(chats, providers) {
             return {};
         },
         'chat.send': (payload) => chats.send(payload.chatId, payload.text, { delivery: payload.delivery, mentions: payload.mentions, skills: payload.skills, chats: payload.chats }, payload.attachments),
-        'chat.uiChoice': (payload) => chats.choose(payload),
+        'chat.uiChoice': (payload, clientId) => chats.choose(payload, clientId),
         'ui.link': (payload, clientId) => chats.linkUi(payload, clientId),
         'ui.query': (payload, clientId) => chats.queryUi(payload, clientId),
         'chat.unqueue': (payload) => ({ message: chats.unqueue(payload.chatId, payload.messageId) }),

package/dist/tasks/task-coordinator.js

@@ -1,12 +1,16 @@
 import { abortedByMachine, clipText } from '@adecore/agent-contracts';
 import { BACKGROUND_COMMAND_LIMIT_MS, commandLabel, isBackgroundWork, runningInBackground, runsInBackground } from '../chat/background-work.js';
+import { readableAssistantText } from '../chat/readable-text.js';
 import { errorText } from '../error-text.js';
 // A child's answer is its last word of the turn; the thinking and the tools before it are not the result.
 function answerOf(items, turnId) {
     for (let i = items.length - 1; i >= 0; i--) {
         const item = items[i];
-        if (item.kind === 'assistant' && item.turnId === turnId && !item.parentToolUseId && item.text.trim() !== '') {
-            return item.text.trim();
+        if (item.kind === 'assistant' && item.turnId === turnId && !item.parentToolUseId) {
+            const text = readableAssistantText(item).trim();
+            if (text !== '') {
+                return text;
+            }
         }
     }
     return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.21.0",
+  "version": "0.21.1",
   "description": "Node-compatible agent chat hosts, providers, accounts, usage and durable task coordination.",
   "type": "module",
   "exports": {
@@ -20,8 +20,8 @@
     "test": "bun --conditions=source test"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.21.0",
-    "@adecore/intelligent-ui": "0.21.0",
+    "@adecore/agent-contracts": "0.21.1",
+    "@adecore/intelligent-ui": "0.21.1",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/chat-core.ts

@@ -57,6 +57,7 @@ import type { CodexProcessSpec } from './codex-thread.ts';
 import type { CodexClientInfo } from './codex-transport.ts';
 import { ComposerPreferences } from './composer-preferences.ts';
 import { DeltaCoalescer } from './delta-coalescer.ts';
+import { readableAssistantText } from './readable-text.ts';
 import { ChatError } from './errors.ts';
 import { commandLabel, isBackgroundWork, runsInBackground, type BackgroundWork } from './background-work.ts';
 import { SubagentReader, type SubagentReaderOptions } from './subagent-reader.ts';
@@ -84,7 +85,8 @@ function isBookmarkable(item: ChatItem): item is BookmarkableItem {
 /* The start of a message on one line; a message of only attachments is its file names. */
 function excerptOf(item: BookmarkableItem): string {
     const files = item.kind === 'user' ? (item.attachments ?? []).map((attachment) => attachment.name).join(', ') : '';
-    return (item.text.trim() === '' ? files : item.text).replace(/\s+/g, ' ').trim();
+    const text = item.kind === 'assistant' ? readableAssistantText(item) : item.text;
+    return (text.trim() === '' ? files : text).replace(/\s+/g, ' ').trim();
 }
 
 // One process worked on the turn and one more may take it up after a restart; a loop of resumes could redo a command forever.
@@ -102,6 +104,8 @@ const DEFAULT_RESUME_WORDS: ResumeWords = {
 
 export interface ChatCoreOptions {
     intelligentUi?: ChatUiHost;
+    // The info string that marks a UI fence in a reply, for a host that keeps a name of its own.
+    uiFenceLanguage?: string;
     providers: ProviderRegistry;
     // Where the threads are kept; without it a chat lives as long as the process.
     store?: ChatStore;
@@ -175,6 +179,7 @@ export class ChatCore {
     readonly claudeProjectsDir: string;
     readonly composerPreferences = new ComposerPreferences();
     private readonly uiQueries: ChatUiQueries | null;
+    private readonly uiFenceLanguage: string | undefined;
     private readonly checkpoints: TurnCheckpoints | null;
     private readonly instructions: string | null;
     private readonly skillIndex: SkillIndex;
@@ -188,7 +193,7 @@ export class ChatCore {
     // How big each record was the last time it went to disk, and the writes waiting for a big one.
     private readonly sizes = new Map<string, number>();
     private readonly waiting = new Map<string, ReturnType<typeof setTimeout>>();
-    // What the last record held that no event carries (preambles, the host's extras), as its JSON.
+    // What the last record held that no event carries (preambles, the host's extras, captured UI access), as its JSON.
     private readonly unlogged = new Map<string, string>();
     // The write in flight per chat, so the next one queues behind it instead of racing it.
     private readonly writes = new Map<string, Promise<void>>();
@@ -202,6 +207,7 @@ export class ChatCore {
 
     constructor(options: ChatCoreOptions) {
         this.uiQueries = options.intelligentUi ? new ChatUiQueries(options.intelligentUi) : null;
+        this.uiFenceLanguage = options.uiFenceLanguage;
         this.providers = options.providers;
         this.store = options.store ?? null;
         this.bookmarks = options.bookmarks ?? null;
@@ -398,9 +404,11 @@ export class ChatCore {
         const references = this.referencesFor(payload.chatId);
         const session = new ChatSession({
             info,
+            ...(this.uiFenceLanguage ? { uiFenceLanguage: this.uiFenceLanguage } : {}),
             ...(this.uiQueries ? { ui: { schemas: this.uiQueries.schemas, observe: (item, final) => this.uiQueries!.observe(session, item, final) } } : {}),
             items: stored?.items ?? [],
             preambles: stored?.preambles ?? [],
+            uiAccess: stored?.uiAccess ?? {},
             provider,
             command: this.commands[kind] ?? provider.command,
             ...(this.spawn ? { spawn: this.spawn } : {}),
@@ -735,7 +743,10 @@ export class ChatCore {
         return this.uiQueries.query(this.require(payload.chatId), payload);
     }
 
-    async choose(payload: ChatUiChoicePayload): Promise<{ queued: boolean; turnId: string }> {
+    async choose(payload: ChatUiChoicePayload, clientId: string): Promise<{ queued: boolean; turnId: string }> {
+        if (!this.attached.get(payload.chatId)?.has(clientId)) {
+            throw new ChatError('refused-query', 'Attach to the chat before answering its UI.');
+        }
         const session = this.require(payload.chatId);
         const queries = await this.uiQueries?.choiceValues(session, payload);
         const result = session.choose(payload, queries);
@@ -1022,7 +1033,15 @@ export class ChatCore {
             const log = this.logs.get(chatId);
             // Not folded here: an older write still in flight may land after this one, and the log is what covers for it.
             try {
-                this.store.writeSync(chatId, info, items, { seq: log?.seq ?? 0, resetSeq: log?.resetSeq ?? 0 }, session.preambles, this.recordExtras(chatId));
+                this.store.writeSync(
+                    chatId,
+                    info,
+                    items,
+                    { seq: log?.seq ?? 0, resetSeq: log?.resetSeq ?? 0 },
+                    session.preambles,
+                    this.recordExtras(chatId),
+                    session.uiAccessRecord
+                );
             } catch (e) {
                 console.error(`Chat record for ${chatId} failed:`, errorText(e));
             }
@@ -1181,7 +1200,8 @@ export class ChatCore {
             // A delta held back is already in the thread, so it gets its seq before the snapshot says where it ends.
             this.coalescers.get(chatId)?.flush();
             const extras = this.recordExtras(chatId);
-            const unlogged = JSON.stringify([session.preambles, extras]);
+            const uiAccess = session.uiAccessRecord;
+            const unlogged = JSON.stringify([session.preambles, extras, uiAccess]);
             const folds = fold || log.size > COMPACT_ABOVE_BYTES || !log.onDisk;
             // The log already holds every change to the thread, so the whole record is rewritten only to fold
             // the log, on a chat's first write, or for what no event carries.
@@ -1190,7 +1210,7 @@ export class ChatCore {
             }
             const { info, items } = session.thread.snapshot();
             const at = { seq: log.seq, resetSeq: log.resetSeq };
-            this.sizes.set(chatId, await this.store.write(chatId, info, items, at, session.preambles, extras));
+            this.sizes.set(chatId, await this.store.write(chatId, info, items, at, session.preambles, extras, uiAccess));
             this.unlogged.set(chatId, unlogged);
             // A chat killed while the write was out has no log left to fold.
             if (this.logs.get(chatId) === log && folds) {