@adecore/agents 0.21.0 → 0.21.2

package/dist/async.js

@@ -1,8 +1,6 @@
-/* The two waits the host does: a pause it can be woken from, and a deadline on somebody else's promise. */
 /*
- * Resolves after `ms`, or at once when the signal is raised. An abort ends the wait rather than
- * failing it: every caller here is a loop that checks the signal itself on the next turn, and a
- * rejection would only be caught and thrown away.
+ * Resolves after `ms`, or at once when the signal is raised. An abort resolves instead of rejecting:
+ * every caller is a loop that checks the signal itself on its next turn.
  */
 export function wait(ms, signal) {
     return new Promise((resolve) => {
@@ -13,10 +11,7 @@ export function wait(ms, signal) {
         }, { once: true });
     });
 }
-/*
- * The promise, or `message` when it takes longer than `ms`. The timer is cleared either way, so a
- * call that answers at once does not hold the process for the rest of its deadline.
- */
+/* The timer is cleared either way, so a call that answers at once does not hold the process until its deadline. */
 export function withTimeout(promise, ms, message) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => reject(new Error(message)), ms);

package/dist/chat/chat-core.d.ts

@@ -1,5 +1,4 @@
 import { type AgentKind, type ChatAttachment, type ChatAttachResult, type ChatAttachmentUpload, type ChatBookmark, type ChatCheckpointDiff, type ChatConfigurePayload, type ChatCreatePayload, type ChatEvent, type ChatHistoryResult, type ChatInfo, type ChatItem, type ChatQueuedMessage, type ChatUiChoicePayload, type ChatUiQueryPayload, type ChatUiLinkPayload, type ChatSkill, type ChatSubagentPayload, type ChatSubagentResult, type ChatTurnItem, type ChatVisual, type ModelSelection, type RuntimeMode } from '@adecore/agent-contracts';
-import { type ChatUiHost } from './ui-queries.ts';
 import { ClientSinks } from '../client-sinks.ts';
 import type { AgentEvent, AgentSink } from '../events.ts';
 import type { OutboxOutcome } from '../outbox/outbox-worker.ts';
@@ -8,6 +7,7 @@ import type { ProviderRegistry } from '../providers/registry.ts';
 import { SkillIndex } from '../skills.ts';
 import type { LimitsUpdate } from '../usage/limits/normalize.ts';
 import type { AttachmentStore } from './attachment-store.ts';
+import { type BackgroundWork } from './background-work.ts';
 import type { BookmarkStore } from './bookmark-store.ts';
 import type { SpawnChatProcess } from './chat-process.ts';
 import { ChatSession, type ChatReferences, type ChatSendExtras, type PromptNotes, type ResumeWords, type TurnCheckpoints } from './chat-session.ts';
@@ -17,8 +17,8 @@ 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 { type BackgroundWork } from './background-work.ts';
 import { SubagentReader, type SubagentReaderOptions } from './subagent-reader.ts';
+import { type ChatUiHost } from './ui-queries.ts';
 import type { VisualInput, VisualStore } from './visual-store.ts';
 export interface InterruptedRun {
     chatId: string;
@@ -27,6 +27,7 @@ export interface InterruptedRun {
 }
 export interface ChatCoreOptions {
     intelligentUi?: ChatUiHost;
+    uiFenceLanguage?: string;
     providers: ProviderRegistry;
     store?: ChatStore;
     checkpoints?: TurnCheckpoints;
@@ -190,6 +191,7 @@ export declare class ChatCore {
     readonly claudeProjectsDir: string;
     readonly composerPreferences: ComposerPreferences;
     private readonly uiQueries;
+    private readonly uiFenceLanguage;
     private readonly checkpoints;
     private readonly instructions;
     private readonly skillIndex;
@@ -290,6 +292,7 @@ export declare class ChatCore {
         conflicted?: boolean | undefined;
         relativePath?: string | undefined;
         label?: string | undefined;
+        code?: string | undefined;
         reason?: string | undefined;
     }>;
     queryUi(payload: ChatUiQueryPayload, clientId: string): Promise<{
@@ -297,9 +300,10 @@ export declare class ChatCore {
         value?: unknown;
         readId?: string | undefined;
         readAt: number;
+        code?: string | undefined;
         reason?: string | undefined;
     }>;
-    choose(payload: ChatUiChoicePayload): Promise<{
+    choose(payload: ChatUiChoicePayload, clientId: string): Promise<{
         queued: boolean;
         turnId: string;
     }>;

package/dist/chat/chat-core.js

@@ -1,31 +1,33 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { ChatAttachmentUploadsSchema, generatedImageAttachment } from '@adecore/agent-contracts';
-import { ChatUiQueries } from './ui-queries.js';
 import { ClientSinks } from '../client-sinks.js';
 import { errorText } from '../error-text.js';
 import { AccountError, definedEnv, isDefaultAccountOf, launchEnv, storedAccount } from '../providers/accounts/launch.js';
 import { SkillIndex } from '../skills.js';
 import { usageRoots } from '../usage/roots.js';
+import { commandLabel, isBackgroundWork, runsInBackground } from './background-work.js';
 import { ChatLog, COMPACT_ABOVE_BYTES } from './chat-log.js';
 import { ChatSession } from './chat-session.js';
 import { ComposerPreferences } from './composer-preferences.js';
 import { DeltaCoalescer } from './delta-coalescer.js';
 import { ChatError } from './errors.js';
-import { commandLabel, isBackgroundWork, runsInBackground } from './background-work.js';
+import { readableAssistantText } from './readable-text.js';
 import { SubagentReader } from './subagent-reader.js';
-/* A message a person or the agent wrote in the chat's own thread; a subagent's words belong to its row. */
+import { ChatUiQueries } from './ui-queries.js';
 function withoutHidden(info) {
     const { hidden: _hidden, ...rest } = info;
     return rest;
 }
+/* A message a person or the agent wrote in the chat's own thread; a subagent's words belong to its row. */
 function isBookmarkable(item) {
     return item.kind === 'user' || (item.kind === 'assistant' && (item.parentToolUseId ?? null) === null);
 }
 /* The start of a message on one line; a message of only attachments is its file names. */
 function excerptOf(item) {
     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.
 const MAX_ATTEMPTS = 2;
@@ -61,6 +63,7 @@ export class ChatCore {
     claudeProjectsDir;
     composerPreferences = new ComposerPreferences();
     uiQueries;
+    uiFenceLanguage;
     checkpoints;
     instructions;
     skillIndex;
@@ -74,7 +77,7 @@ export class ChatCore {
     // How big each record was the last time it went to disk, and the writes waiting for a big one.
     sizes = new Map();
     waiting = new Map();
-    // 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.
     unlogged = new Map();
     // The write in flight per chat, so the next one queues behind it instead of racing it.
     writes = new Map();
@@ -87,6 +90,7 @@ export class ChatCore {
     limitResume;
     constructor(options) {
         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;
@@ -272,9 +276,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 } : {}),
@@ -573,7 +579,10 @@ export class ChatCore {
         }
         return this.uiQueries.query(this.require(payload.chatId), payload);
     }
-    async choose(payload) {
+    async choose(payload, clientId) {
+        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);
@@ -837,7 +846,7 @@ 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));
@@ -970,7 +979,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.
@@ -979,7 +989,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) {

package/dist/chat/chat-log.js

@@ -31,8 +31,8 @@ export function parseLog(raw) {
     return lines;
 }
 /*
- * Number and synchronously append each broadcast event so disk, memory and snapshot boundaries keep
- * one order. Recent lines stay in memory for immediate `since` attachment.
+ * Numbers every broadcast event and appends it synchronously, so disk, memory and snapshot boundaries
+ * keep one order. Recent lines stay in memory to answer an attach with `since` at once.
  */
 export class ChatLog {
     path;

package/dist/chat/chat-session.d.ts

@@ -32,6 +32,7 @@ export interface ChatSessionOptions {
     clock?: OutboxClock;
     items?: ChatItem[];
     preambles?: string[];
+    uiAccess?: Readonly<Record<string, unknown>>;
     provider: ChatProvider;
     command: string[];
     env(account: string | undefined): Record<string, string>;
@@ -43,6 +44,7 @@ export interface ChatSessionOptions {
     promptNotes?: PromptNotes;
     references?: ChatReferences;
     checkpoints?: TurnCheckpoints;
+    uiFenceLanguage?: string;
     ui?: {
         schemas: UiCompileOptions['querySchemas'];
         observe(item: ChatAssistantItem, final: boolean): void;
@@ -105,6 +107,11 @@ export declare class ChatSession {
     private readonly steering;
     private readonly uiStreams;
     private readonly uiCompiled;
+    private readonly capturedUiAccess;
+    private readonly uiScanned;
+    private readonly uiReferencing;
+    private readonly uiAttachments;
+    private readonly uiFenceLanguage;
     constructor(options: ChatSessionOptions);
     get uiPreviews(): ChatEvent[];
     previewItems(items: ChatItem[]): ChatItem[];
@@ -124,6 +131,9 @@ export declare class ChatSession {
         queued: boolean;
         turnId: string;
     };
+    uiAccess(itemId: string): unknown;
+    setUiAccess(itemId: string, access: unknown): void;
+    get uiAccessRecord(): Record<string, unknown>;
     updateUiQueries(itemId: string, uiQueries: ChatUiQueryState): void;
     choose(payload: ChatUiChoicePayload, queries?: Readonly<Record<string, unknown>>): {
         queued: boolean;
@@ -226,7 +236,10 @@ export declare class ChatSession {
     private settleFromTranscripts;
     private settleRows;
     private emit;
+    private unscannedUiText;
+    private forgetUiScan;
     private latestUiAttachment;
+    private findUiAttachment;
     private clearUi;
     private delegatingChange;
 }

package/dist/chat/chat-session.js

@@ -1,16 +1,19 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { GeneratedImageInputSchema, notResumedNote } from '@adecore/agent-contracts';
-import { resolveUiChoice, UiFailure } from '@adecore/intelligent-ui';
+import { resolveUiChoice, UI_FENCE_LANGUAGE, UiFailure, uiHasFence, uiMayReferenceHost } from '@adecore/intelligent-ui';
 import { UiStream } from '@adecore/intelligent-ui/stream';
 import { commandLabel, isBackgroundWork, reportsOnBackgroundWork, runningInBackground } from './background-work.js';
 import { ChatError } from './errors.js';
 import { limitedTurn, limitResumeAt, limitResumeWake } from './limit-resume.js';
 import { isMainAgentOutput, ThreadProjector } from './projector.js';
+import { readableAssistantText } from './readable-text.js';
 import { ChatThread } from './thread.js';
 import { errorText } from '../error-text.js';
 import { systemClock } from '../outbox/outbox-worker.js';
 // Claude Code names a session about six seconds after its first prompt, and a first turn can run for minutes.
 const TITLE_RECHECK_MS = 10_000;
+// Longer than any fence line or the name of a tag a scan looks for, so a match never falls between two deltas.
+const UI_SCAN_OVERLAP = 64;
 /* One per limited turn, so a second fork of the same turn writes no second note. */
 function continuedNoteId(turnId) {
     return `continued-${turnId}`;
@@ -74,9 +77,17 @@ export class ChatSession {
     steering = new Set();
     uiStreams = new Map();
     uiCompiled = new Map();
+    capturedUiAccess;
+    // How much of a streaming reply's text the fence and host scans already covered, so a delta scans only its tail.
+    uiScanned = new Map();
+    uiReferencing = new Set();
+    uiAttachments = new Map();
+    uiFenceLanguage;
     constructor(options) {
         this.options = options;
+        this.uiFenceLanguage = options.uiFenceLanguage ?? UI_FENCE_LANGUAGE;
         this.pendingPreambles = options.preambles ?? [];
+        this.capturedUiAccess = new Map(Object.entries(options.uiAccess ?? {}));
         this.thread = new ChatThread(options.info, options.items);
         this.projector = new ThreadProjector(this.thread, { providerName: options.provider.name });
     }
@@ -182,6 +193,21 @@ export class ChatSession {
         this.dispatch(text, extras, turnId);
         return { queued: false, turnId };
     }
+    /* What a UI host captured for a reply; null where the capture was denied or is still out, undefined where none started. */
+    uiAccess(itemId) {
+        return this.capturedUiAccess.get(itemId);
+    }
+    setUiAccess(itemId, access) {
+        if (this.frozen) {
+            return;
+        }
+        this.capturedUiAccess.set(itemId, access);
+        this.options.persistSoon();
+    }
+    /* The captured access of the replies still in the thread, for the record. */
+    get uiAccessRecord() {
+        return Object.fromEntries([...this.capturedUiAccess].filter(([itemId]) => this.thread.get(itemId) !== undefined));
+    }
     updateUiQueries(itemId, uiQueries) {
         const item = this.thread.get(itemId);
         if (this.frozen || item?.kind !== 'assistant' || item.parentToolUseId) {
@@ -1598,7 +1624,7 @@ export class ChatSession {
         this.naming = true;
         const turnId = done[0].id;
         const answer = items
-            .map((item) => (item.kind === 'assistant' && item.turnId === turnId ? item.text : ''))
+            .map((item) => (item.kind === 'assistant' && item.turnId === turnId ? readableAssistantText(item) : ''))
             .filter((text) => text !== '')
             .join('\n\n');
         const agentSessionId = this.thread.info.agentSessionId;
@@ -1652,19 +1678,28 @@ export class ChatSession {
             if (event.type === 'reset') {
                 this.clearUi();
             }
+            if (event.type === 'item' && event.item.kind === 'tool') {
+                this.uiAttachments.delete(event.item.turnId);
+            }
             const item = event.type === 'item' ? event.item : event.type === 'delta' ? this.thread.get(event.itemId) : null;
             if (item?.kind !== 'assistant' || item.parentToolUseId) {
                 this.options.emit(event);
                 continue;
             }
+            const tail = this.unscannedUiText(item, event.type === 'item');
+            if (uiMayReferenceHost(tail)) {
+                this.uiReferencing.add(item.id);
+            }
             let stream = this.uiStreams.get(item.id);
-            if (!stream && !item.text.includes('ruimte-ui')) {
+            if (!stream && !uiHasFence(tail, this.uiFenceLanguage)) {
+                this.forgetUiScan(item);
                 this.options.emit(event);
                 continue;
             }
             if (!stream) {
                 stream = new UiStream({
                     querySchemas: this.options.ui?.schemas,
+                    fenceLanguage: this.uiFenceLanguage,
                     id: item.id,
                     clock: this.options.clock ?? systemClock,
                     emit: (preview) => {
@@ -1674,7 +1709,10 @@ export class ChatSession {
                 });
                 this.uiStreams.set(item.id, stream);
             }
-            this.options.ui?.observe(item, false);
+            if (this.uiReferencing.has(item.id)) {
+                this.options.ui?.observe(item, false);
+            }
+            this.forgetUiScan(item);
             const latestAttachment = this.latestUiAttachment(item.turnId);
             if (event.type === 'item' && !item.streaming) {
                 const ui = stream
@@ -1684,7 +1722,7 @@ export class ChatSession {
                 this.uiCompiled.delete(item.id);
                 const diagnostics = [...new Set(ui.flatMap((block) => block.diagnostics.map((diagnostic) => diagnostic.message)))].slice(0, 6);
                 if (diagnostics.length > 0) {
-                    const repair = `Your last ruimte-ui block had these diagnostics: ${diagnostics.join(' ')} Use the catalog's supported props and components.`.slice(0, 1200);
+                    const repair = `Your last ${this.uiFenceLanguage} block had these diagnostics: ${diagnostics.join(' ')} Use the catalog's supported props and components.`.slice(0, 1200);
                     if (!this.pendingPreambles.includes(repair)) {
                         this.pendingPreambles = [...this.pendingPreambles, repair];
                     }
@@ -1701,7 +1739,36 @@ export class ChatSession {
             }
         }
     }
+    /*
+     * The text a scan has not covered yet, from the start of the line the last scan ended in, since a fence
+     * is one line; a long line is cut short, behind a character no fence or tag can follow.
+     */
+    unscannedUiText(item, whole) {
+        const scanned = whole ? 0 : (this.uiScanned.get(item.id) ?? 0);
+        this.uiScanned.set(item.id, item.text.length);
+        if (scanned === 0 || scanned > item.text.length) {
+            return item.text;
+        }
+        const line = item.text.lastIndexOf('\n', scanned - 1) + 1;
+        const from = Math.max(line, scanned - UI_SCAN_OVERLAP);
+        return from === line ? item.text.slice(from) : `\0${item.text.slice(from)}`;
+    }
+    forgetUiScan(item) {
+        if (!item.streaming) {
+            this.uiScanned.delete(item.id);
+            this.uiReferencing.delete(item.id);
+        }
+    }
+    /* Looked up once per turn, and again only after one of its tool calls changed. */
     latestUiAttachment(turnId) {
+        if (this.uiAttachments.has(turnId)) {
+            return this.uiAttachments.get(turnId);
+        }
+        const attachment = this.findUiAttachment(turnId);
+        this.uiAttachments.set(turnId, attachment);
+        return attachment;
+    }
+    findUiAttachment(turnId) {
         for (const item of this.thread.list().toReversed()) {
             if (item.kind !== 'tool' || item.turnId !== turnId || item.name !== 'ImageGeneration' || item.state !== 'done') {
                 continue;
@@ -1719,6 +1786,9 @@ export class ChatSession {
         }
         this.uiStreams.clear();
         this.uiCompiled.clear();
+        this.uiScanned.clear();
+        this.uiReferencing.clear();
+        this.uiAttachments.clear();
     }
     /* Said on the info as well as by the rows, since a client with the thread closed sees only the info. */
     delegatingChange(events) {

package/dist/chat/chat-store.d.ts

@@ -8,6 +8,7 @@ export interface ChatRecord {
     seq: number;
     resetSeq: number;
     preambles: string[];
+    uiAccess: Record<string, unknown>;
     extras: ChatRecordExtras;
     lines: ChatLogLine[];
 }
@@ -28,8 +29,8 @@ export declare class ChatStore {
     list(): Promise<string[]>;
     has(chatId: string): Promise<boolean>;
     discardLog(chatId: string): Promise<number>;
-    write(chatId: string, info: ChatInfo, items: ChatItem[], at?: ChatSeq, preambles?: readonly string[], extras?: ChatRecordExtras): Promise<number>;
-    writeSync(chatId: string, info: ChatInfo, items: ChatItem[], at?: ChatSeq, preambles?: readonly string[], extras?: ChatRecordExtras): void;
+    write(chatId: string, info: ChatInfo, items: ChatItem[], at?: ChatSeq, preambles?: readonly string[], extras?: ChatRecordExtras, uiAccess?: Readonly<Record<string, unknown>>): Promise<number>;
+    writeSync(chatId: string, info: ChatInfo, items: ChatItem[], at?: ChatSeq, preambles?: readonly string[], extras?: ChatRecordExtras, uiAccess?: Readonly<Record<string, unknown>>): void;
     read(chatId: string): Promise<ChatRecord | null>;
     unreadable(chatId: string): Promise<boolean>;
     private readSnapshot;

package/dist/chat/chat-store.js

@@ -4,12 +4,12 @@ import { join } from 'node:path';
 import { ChatInfoSchema, ChatItemSchema } from '@adecore/agent-contracts';
 import { z } from 'zod';
 import { isNotFound, writeAtomic, writeAtomicSync } from '../fs.js';
-import { isBookmarkFileName } from './bookmark-store.js';
+import { recordFileName } from '../record-directory.js';
 import { migrateInlineAttachments } from './attachment-store.js';
+import { isBookmarkFileName } from './bookmark-store.js';
 import { parseLog } from './chat-log.js';
 import { ChatThread } from './thread.js';
 import { isVisualFileName } from './visual-store.js';
-import { recordFileName } from '../record-directory.js';
 // zod strips what it does not know inside the info and the items, so a file written by an older build
 // (with `interactionMode`, say) still parses and loses only the dropped field. A record without `seq`
 // predates the log. Keys beside these are the host's own, and come back to it as they were written.
@@ -19,20 +19,40 @@ const RecordSchema = z.looseObject({
     seq: z.number().int().nonnegative().optional(),
     resetSeq: z.number().int().nonnegative().optional(),
     // Never on the wire: what goes in front of the next real prompt, once (a fork's note for its agent).
-    preambles: z.array(z.string()).optional()
+    preambles: z.array(z.string()).optional(),
+    // Never on the wire: the access a UI host captured for each reply that reads it, by item id.
+    uiAccess: z.record(z.string(), z.unknown()).optional()
 });
-const OWN_KEYS = new Set(['info', 'items', 'seq', 'resetSeq', 'preambles']);
-function extrasOf(record) {
+const OWN_KEYS = new Set(['info', 'items', 'seq', 'resetSeq', 'preambles', 'uiAccess']);
+function withoutOwnKeys(record) {
     return Object.fromEntries(Object.entries(record).filter(([key]) => !OWN_KEYS.has(key)));
 }
 function logName(chatId) {
     return `${encodeURIComponent(chatId)}.log`;
 }
-function recordBody(info, items, at, preambles, extras) {
-    return JSON.stringify({ info, items, ...at, ...(preambles.length === 0 ? {} : { preambles }), ...withoutOwnKeys(extras) });
+function recordBody(info, items, at, preambles, extras, uiAccess) {
+    return JSON.stringify({
+        info,
+        items,
+        ...at,
+        ...(preambles.length === 0 ? {} : { preambles }),
+        ...(Object.keys(uiAccess).length === 0 ? {} : { uiAccess }),
+        ...withoutOwnKeys(extras)
+    });
 }
-function withoutOwnKeys(extras) {
-    return Object.fromEntries(Object.entries(extras).filter(([key]) => !OWN_KEYS.has(key)));
+/* A record from before `uiAccess` kept the access inside each reply's `uiQueries`, which the item schema now drops. */
+function liftUiAccess(record) {
+    if (typeof record !== 'object' || record === null || 'uiAccess' in record || !Array.isArray(record.items)) {
+        return record;
+    }
+    const uiAccess = {};
+    for (const item of record.items) {
+        const queries = item?.uiQueries;
+        if (typeof queries === 'object' && queries !== null && 'access' in queries) {
+            uiAccess[String(item.id)] = queries.access;
+        }
+    }
+    return Object.keys(uiAccess).length === 0 ? record : { ...record, uiAccess };
 }
 /*
  * One JSON file per chat under `<home>/chats`, written while a turn runs and on shutdown, with
@@ -80,8 +100,8 @@ export class ChatStore {
         return lines.at(-1)?.seq ?? 0;
     }
     /* Answers how many bytes the record took, which is what tells a caller whether writing it is cheap. */
-    async write(chatId, info, items, at = { seq: 0, resetSeq: 0 }, preambles = [], extras = {}) {
-        const body = recordBody(info, items, at, preambles, extras);
+    async write(chatId, info, items, at = { seq: 0, resetSeq: 0 }, preambles = [], extras = {}, uiAccess = {}) {
+        const body = recordBody(info, items, at, preambles, extras, uiAccess);
         await mkdir(this.dir, { recursive: true, mode: 0o700 });
         await writeAtomic(join(this.dir, recordFileName(chatId)), body);
         return body.length;
@@ -90,9 +110,9 @@ export class ChatStore {
      * The same write without a turn of the event loop. A `bun --watch` reload restarts the module
      * before an awaited write comes back, so a shutdown has to put the threads down synchronously.
      */
-    writeSync(chatId, info, items, at = { seq: 0, resetSeq: 0 }, preambles = [], extras = {}) {
+    writeSync(chatId, info, items, at = { seq: 0, resetSeq: 0 }, preambles = [], extras = {}, uiAccess = {}) {
         mkdirSync(this.dir, { recursive: true, mode: 0o700 });
-        writeAtomicSync(join(this.dir, recordFileName(chatId)), recordBody(info, items, at, preambles, extras));
+        writeAtomicSync(join(this.dir, recordFileName(chatId)), recordBody(info, items, at, preambles, extras, uiAccess));
     }
     /* Null for a chat with nothing on disk to make it of, and for one whose record does not parse (see `unreadable`). */
     async read(chatId) {
@@ -117,7 +137,15 @@ export class ChatStore {
                 resetSeq = line.seq;
             }
         }
-        return { ...thread.snapshot(), seq, resetSeq, preambles: snapshot.preambles ?? [], extras: extrasOf(snapshot), lines };
+        return {
+            ...thread.snapshot(),
+            seq,
+            resetSeq,
+            preambles: snapshot.preambles ?? [],
+            uiAccess: snapshot.uiAccess ?? {},
+            extras: withoutOwnKeys(snapshot),
+            lines
+        };
     }
     /*
      * Whether a record is on disk that this host cannot read: one a newer version wrote, one cut short,
@@ -146,7 +174,7 @@ export class ChatStore {
                 await writeAtomic(join(this.dir, recordFileName(chatId)), JSON.stringify(migrated));
             }
         }
-        const parsed = RecordSchema.safeParse(record);
+        const parsed = RecordSchema.safeParse(liftUiAccess(record));
         return parsed.success ? parsed.data : UNREADABLE;
     }
     async delete(chatId) {
@@ -199,5 +227,5 @@ function fromLogAlone(lines) {
             resetSeq = line.seq;
         }
     }
-    return { ...thread.snapshot(), seq: 0, resetSeq, preambles: [], extras: {}, lines };
+    return { ...thread.snapshot(), seq: 0, resetSeq, preambles: [], uiAccess: {}, extras: {}, lines };
 }

package/dist/chat/chat-title.js

@@ -1,5 +1,5 @@
-import { cleanTitle } from '../title-file.js';
 import { runProcess } from '../run-process.js';
+import { cleanTitle } from '../title-file.js';
 // Enough of a conversation to name it; the rest of a long prompt or answer says nothing a title needs.
 const MAX_PROMPT_CHARS = 2000;
 const MAX_ANSWER_CHARS = 1500;
@@ -8,10 +8,7 @@ const TIMEOUT_MS = 45_000;
 function cap(text, limit) {
     return text.length <= limit ? text : `${text.slice(0, limit)}...`;
 }
-/*
- * What the CLI is asked. JSON again, as for a commit message: a model left to write freely opens
- * with a sentence, and that sentence would become the name of the node.
- */
+/* JSON, since a model left to write freely opens with a sentence, and that sentence would become the name. */
 export function buildTitlePrompt(prompt, answer) {
     return [
         'Write a short title for the conversation below, as a person would name it in a list of chats.',
@@ -30,9 +27,8 @@ export function buildTitlePrompt(prompt, answer) {
     ].join('\n');
 }
 /*
- * The title out of what the CLI printed, or null. Strict on purpose, unlike a commit message: a run
- * that holds no `{"title": "..."}` object printed something other than a title, and a derived name
- * is better than a stray line of it.
+ * Strict on purpose: a run that holds no `{"title": "..."}` object printed something other than a
+ * title, and a derived name is better than a stray line of it.
  */
 export function parseTitle(output) {
     const start = [...output.matchAll(/\{\s*"title"/g)].at(-1)?.index;

package/dist/chat/claude-backend.d.ts

@@ -27,6 +27,7 @@ export declare class ClaudeBackend implements ChatBackend {
     declineRequest(requestId: string, message: string): boolean;
     stop(): void;
     dispose(): Promise<void>;
+    private userMessage;
     private readLines;
     private handleLine;
     private readLine;

package/dist/chat/claude-backend.js

@@ -1,5 +1,5 @@
-import { errorText } from '../error-text.js';
 import { randomUUID } from 'node:crypto';
+import { errorText } from '../error-text.js';
 import { claudeArgs, claudeEnv, promptPrefix } from '../providers/claude.js';
 import { ChatChild } from './chat-process.js';
 import { ClaudeProtocol } from './claude-protocol.js';
@@ -59,12 +59,10 @@ export class ClaudeBackend {
         return Promise.resolve();
     }
     sendTurn(input) {
-        // The prefix is what the CLI must see first (ultrathink), then the note about the links, then what was typed.
-        const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
         const promptId = input.promptId ?? randomUUID();
         this.active = true;
         this.protocol.beginPrompt(promptId);
-        this.write(buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId }));
+        this.write(this.userMessage(input, promptId));
     }
     steerTurn(input) {
         if (!this.child || !this.active || this.stdinClosed) {
@@ -75,8 +73,7 @@ export class ClaudeBackend {
             this.steers.set(promptId, { resolve, reject });
             this.protocol.beginSteer(promptId);
             try {
-                const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
-                this.write(buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId }));
+                this.write(this.userMessage(input, promptId));
             }
             catch (error) {
                 this.steers.delete(promptId);
@@ -126,6 +123,11 @@ export class ClaudeBackend {
         this.child = null;
         return child?.end() ?? Promise.resolve();
     }
+    userMessage(input, promptId) {
+        // What the CLI must see first (ultrathink), then the preamble, then what was typed.
+        const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
+        return buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId });
+    }
     async readLines(child) {
         const reader = child.process.stdout.getReader();
         const decoder = new TextDecoder();

package/dist/chat/claude-title.js

@@ -1,8 +1,8 @@
 import { existsSync } from 'node:fs';
 import { readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { usageRoots } from '../usage/roots.js';
 import { cleanTitle, readLines } from '../title-file.js';
+import { usageRoots } from '../usage/roots.js';
 // The two records carry these words; a line without them is never parsed.
 const MARKERS = ['"ai-title"', '"custom-title"'];
 /*