@adecore/agents 0.23.1 → 0.24.1

package/dist/chat/chat-core.js

@@ -1,6 +1,6 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { ChatAttachmentUploadsSchema, generatedImageAttachment } from '@adecore/agent-contracts';
+import { ChatAttachmentUploadsSchema, generatedImageAttachment, HOST_TASK_ORIGIN } from '@adecore/agent-contracts';
 import { ClientSinks } from '../client-sinks.js';
 import { errorText } from '../error-text.js';
 import { AccountError, definedEnv, isDefaultAccountOf, launchEnv, storedAccount } from '../providers/accounts/launch.js';
@@ -42,21 +42,25 @@ const DEFAULT_RESUME_WORDS = {
 /*
  * The chats of one host: a `ChatSession` per chat, its record and its log, and the clients that read
  * them. Everything here holds for any host. What a host adds (notes for the agent, rows of its own,
- * what a clear or a removal takes along) it adds by overriding the protected methods below, which
- * do nothing of their own.
+ * what a clear or a removal takes along) it adds through `ChatCoreOptions.hooks`. A subclass may add
+ * methods of its own over the public ones; the state behind them stays here.
  */
 export class ChatCore {
-    providers;
-    store;
+    // The stores the host handed in, which a subclass reads to copy a chat's bookmarks or visuals.
     bookmarks;
     visuals;
+    providers;
+    store;
     accounts;
     attachments;
     env;
+    hooks;
     chats = new Map();
     creating = new Map();
     sinks = new ClientSinks((clientId) => this.composerPreferences.forget(clientId));
     attached = new Map();
+    // How often a chat's bookmarks or visuals changed, so an attach can tell that its read went stale before it joined.
+    listChanges = new Map();
     coalescers = new Map();
     subagents;
     /* Where Claude Code keeps the projects of its default account on this machine; empty when it has none. */
@@ -105,6 +109,7 @@ export class ChatCore {
         this.nameChat = options.nameChat ?? null;
         this.onInterruptedRun = options.onInterruptedRun ?? null;
         this.limitResume = options.limitResume ?? null;
+        this.hooks = options.hooks ?? {};
         this.commands = {
             ...(options.command ? { claude: options.command } : {}),
             ...(options.codexCommand ? { codex: options.codexCommand } : {})
@@ -114,11 +119,13 @@ export class ChatCore {
         this.env = definedEnv(options.env ?? process.env);
         // Only whoever reads the thread has anything to point a bookmark at or to place a visual in, so the lists go where the thread goes.
         this.bookmarks?.listen((chatId, bookmarks) => {
+            this.listChanged(chatId);
             for (const clientId of this.attached.get(chatId) ?? []) {
                 this.sinks.to(clientId, { event: 'chat.bookmarks', payload: { chatId, bookmarks } });
             }
         });
         this.visuals?.listen((chatId, visuals) => {
+            this.listChanged(chatId);
             for (const clientId of this.attached.get(chatId) ?? []) {
                 this.sinks.to(clientId, { event: 'chat.visuals', payload: { chatId, visuals } });
             }
@@ -213,6 +220,10 @@ export class ChatCore {
     subscribe(clientId, sink) {
         return this.sinks.subscribe(clientId, sink);
     }
+    /* Sends one client an event of the host's own, such as a change to something it follows that no chat event carries. */
+    sendTo(clientId, event) {
+        this.sinks.to(clientId, event);
+    }
     /* Registers a chat; nothing is spawned until the first message. An existing chat answers its current info. */
     create(payload) {
         // A create in flight has the chat in the map before its first prompt is sent, so a second caller waits for all of it.
@@ -237,19 +248,20 @@ export class ChatCore {
         const kind = stored?.info.provider ?? payload.provider ?? 'claude';
         const provider = this.providers.get(kind);
         const catalog = provider.catalog;
-        const selection = catalog.normalize(stored?.info.selection ?? this.openingSelection(payload.chatId, kind) ?? payload.selection);
+        const selection = catalog.normalize(stored?.info.selection ?? this.hooks.openingSelection?.(payload.chatId, kind) ?? payload.selection);
         const cwd = stored?.info.cwd ?? payload.cwd ?? this.env.HOME ?? homedir();
-        await this.admit(payload.chatId, cwd);
+        await this.hooks.admit?.(payload.chatId, cwd);
         // A thread on disk keeps its account too. One it lost still opens, and says why on its next turn.
         // A new one without an account takes the person's pick for this CLI, which is refused rather than replaced when it went.
         const account = stored ? stored.info.account : storedAccount(kind, payload.account ?? this.composerPreferences.for(kind).account);
         if (!stored) {
             this.requireAccount(kind, account);
         }
+        const narrowed = (mode) => (this.hooks.runtimeModeFor ? this.hooks.runtimeModeFor(payload.chatId, mode) : mode);
         // Asked again for a chat on disk, since the host may have listed it since.
-        const hidden = this.hiddenFor(payload.chatId) ? { hidden: true } : {};
+        const hidden = this.hooks.hiddenFor?.(payload.chatId) ? { hidden: true } : {};
         const info = stored?.info
-            ? { ...withoutHidden(stored.info), runtimeMode: this.runtimeModeFor(payload.chatId, stored.info.runtimeMode), ...hidden }
+            ? { ...withoutHidden(stored.info), runtimeMode: narrowed(stored.info.runtimeMode), ...hidden }
             : {
                 ...hidden,
                 chatId: payload.chatId,
@@ -259,7 +271,7 @@ export class ChatCore {
                 agentSessionId: payload.resume ?? null,
                 model: null,
                 selection,
-                runtimeMode: this.runtimeModeFor(payload.chatId, payload.runtimeMode ?? 'full-access'),
+                runtimeMode: narrowed(payload.runtimeMode ?? 'full-access'),
                 status: 'idle',
                 running: false,
                 activeTurnId: null,
@@ -270,10 +282,10 @@ export class ChatCore {
         const resume = stored ? await this.owedResume(payload.chatId, stored) : { resumeTurnId: null, reason: null };
         const claudeTitles = this.claudeTitles;
         const nameChat = this.nameChat;
-        const base = this.envFor(payload.chatId, this.env);
+        const base = this.hooks.envFor ? this.hooks.envFor(payload.chatId, this.env) : this.env;
         this.logs.set(payload.chatId, await this.openLog(payload.chatId, stored ?? null));
-        const promptNotes = this.promptNotesFor(payload.chatId);
-        const references = this.referencesFor(payload.chatId);
+        const promptNotes = this.hooks.promptNotesFor?.(payload.chatId);
+        const references = this.hooks.referencesFor?.(payload.chatId);
         const session = new ChatSession({
             info,
             ...(this.uiFenceLanguage ? { uiFenceLanguage: this.uiFenceLanguage } : {}),
@@ -290,9 +302,9 @@ export class ChatCore {
                 return env;
             },
             saveGeneratedImage: (ref, upload) => this.attachments.saveGenerated(payload.chatId, ref, upload),
-            instructions: () => this.instructionsFor(payload.chatId),
-            resumeNote: () => this.resumeNoteFor(payload.chatId),
-            folders: () => this.foldersFor(payload.chatId),
+            instructions: () => (this.hooks.instructionsFor ? this.hooks.instructionsFor(payload.chatId) : this.instructions),
+            resumeNote: () => this.hooks.resumeNoteFor?.(payload.chatId) ?? null,
+            folders: () => this.hooks.foldersFor?.(payload.chatId) ?? [],
             ...(promptNotes ? { promptNotes } : {}),
             ...(references ? { references } : {}),
             ...(this.checkpoints ? { checkpoints: this.checkpoints } : {}),
@@ -302,7 +314,7 @@ export class ChatCore {
             save: () => this.persistNow(payload.chatId),
             persistSoon: () => this.persistSoon(payload.chatId),
             ...(kind === 'claude' && claudeTitles
-                ? { readTitle: (agentSessionId) => claudeTitles.forSession(agentSessionId, this.claudeProjectsDirOf(session.info)) }
+                ? { readTitle: (agentSessionId) => claudeTitles.forSession(agentSessionId, this.claudeProjectsDirOf(session.info), session.info.cwd) }
                 : {}),
             ...(kind === 'codex' && nameChat ? { nameThread: (input) => nameChat(kind, input) } : {}),
             ...(kind === 'claude' ? { subagentSettlement: (toolUseId) => this.subagents.claudeSettlement(payload.chatId, toolUseId) } : {}),
@@ -314,7 +326,7 @@ export class ChatCore {
             session.settleOwedResume();
             await session.settleOrphanedSubagents();
         }
-        await this.opened(session, stored ?? null);
+        await this.hooks.opened?.(session, stored ?? null);
         return session.info;
     }
     async storedBackground(chatId) {
@@ -322,7 +334,12 @@ export class ChatCore {
         const items = record?.items ?? [];
         const background = items.filter((item) => isBackgroundWork(item) && (runsInBackground(item) || items.some((note) => note.id === `lost-background-${item.id}`)));
         const last = items.findLast((item) => item.kind === 'turn');
-        return { turnId: background.at(-1)?.turnId ?? last?.id ?? null, items: background, commands: (record?.info.background ?? []).map(commandLabel) };
+        return {
+            turnId: background.at(-1)?.turnId ?? last?.id ?? null,
+            items: background,
+            commands: (record?.info.background ?? []).map(commandLabel),
+            goal: record?.info.goal?.status === 'active'
+        };
     }
     save(chatId) {
         return this.persistNow(chatId, true);
@@ -385,9 +402,10 @@ export class ChatCore {
         };
     }
     /*
-     * `attach` with the chat's bookmarks and visuals. They are read before the client joins, so a
-     * change written after the read reaches it as `chat.bookmarks` or `chat.visuals` and never falls
-     * between the two. A file that cannot be read leaves its list out rather than the thread.
+     * `attach` with the chat's bookmarks and visuals. They are read before the client joins, and
+     * read again when either changed during the read, so a change reaches the client in the answer
+     * or as `chat.bookmarks` or `chat.visuals` and never falls between the two. A file that cannot be
+     * read leaves its list out rather than the thread.
      */
     async attachWithBookmarks(chatId, clientId, historyLimit, since) {
         this.require(chatId);
@@ -395,13 +413,22 @@ export class ChatCore {
             console.error(`The ${what} of chat ${chatId} could not be read:`, errorText(e));
             return undefined;
         };
-        const [bookmarks, visuals] = await Promise.all([
-            this.bookmarks?.read(chatId).catch(unreadable('bookmarks')),
-            this.visuals?.list(chatId).catch(unreadable('visuals'))
-        ]);
+        let bookmarks;
+        let visuals;
+        let changes;
+        do {
+            changes = this.listChanges.get(chatId);
+            [bookmarks, visuals] = await Promise.all([
+                this.bookmarks?.read(chatId).catch(unreadable('bookmarks')),
+                this.visuals?.list(chatId).catch(unreadable('visuals'))
+            ]);
+        } while (this.listChanges.get(chatId) !== changes);
         const result = this.attach(chatId, clientId, historyLimit, since);
         return { ...result, ...(bookmarks === undefined ? {} : { bookmarks }), ...(visuals === undefined ? {} : { visuals }) };
     }
+    listChanged(chatId) {
+        this.listChanges.set(chatId, (this.listChanges.get(chatId) ?? 0) + 1);
+    }
     /* Marks a message of the chat's own thread; a message that already has one keeps it. */
     addBookmark(chatId, itemId, name) {
         const item = this.require(chatId).thread.get(itemId);
@@ -451,6 +478,7 @@ export class ChatCore {
         }
         return this.visuals;
     }
+    /* The page of a chat's thread before `cursor`, or its newest page without one. */
     history(chatId, cursor, limit) {
         const session = this.require(chatId);
         this.coalescers.get(chatId)?.flush();
@@ -500,7 +528,7 @@ export class ChatCore {
         if (row.status !== 'running') {
             return;
         }
-        if (row.origin === 'ruimte') {
+        if (row.origin === HOST_TASK_ORIGIN) {
             throw new ChatError('chat-unsupported', 'This row stands for work the host runs; stop it there');
         }
         session.stopSubagent(toolUseId);
@@ -510,6 +538,10 @@ export class ChatCore {
         await this.loaded(chatId);
         this.require(chatId).stopTask(taskId);
     }
+    async goal(chatId, action) {
+        await this.loaded(chatId);
+        await this.require(chatId).goal(action);
+    }
     /* The whole conversation of a subagent of the CLI's own, for an agent that reads it as text. */
     async subagentItems(chatId, toolUseId) {
         return this.subagents.readAll(chatId, toolUseId);
@@ -518,6 +550,55 @@ export class ChatCore {
     async hasStored(chatId) {
         return this.chats.has(chatId) || (await this.store?.has(chatId)) === true;
     }
+    /*
+     * Writes the whole record of a chat nobody has loaded, such as a fork's thread before anyone opens it.
+     * The files its messages and generated images point at are copied into its own folder, so removing
+     * the chat they came from leaves them.
+     */
+    async writeRecord(chatId, info, items, preambles = []) {
+        if (!this.store) {
+            throw new ChatError('chat-unsupported', 'This host keeps no chat records');
+        }
+        if (this.chats.has(chatId) || this.creating.has(chatId)) {
+            throw new ChatError('chat-busy', `Chat ${chatId} is already loaded`);
+        }
+        const copies = new Map();
+        const copy = (attachment) => {
+            let pending = copies.get(attachment.id);
+            if (!pending) {
+                pending = this.attachments.copy(chatId, attachment);
+                copies.set(attachment.id, pending);
+            }
+            return pending;
+        };
+        const copied = await Promise.all(items.map(async (item) => {
+            if (item.kind === 'user' && item.attachments?.length) {
+                return { ...item, attachments: await Promise.all(item.attachments.map(copy)) };
+            }
+            const generated = generatedImageAttachment(item);
+            if (item.kind === 'tool' && generated) {
+                return { ...item, input: { ...item.input, attachment: await copy(generated) } };
+            }
+            return item;
+        }));
+        await this.store.write(chatId, info, copied, { seq: 0, resetSeq: 0 }, preambles);
+    }
+    /*
+     * Removes what a chat nobody loaded keeps on disk: its record and log, attachments, bookmarks and
+     * visuals. False, with nothing removed, for a chat that is loaded or loading; `kill` removes that one.
+     */
+    async deleteRecord(chatId) {
+        if (this.chats.has(chatId) || this.creating.has(chatId)) {
+            return false;
+        }
+        await Promise.all([
+            this.store?.delete(chatId),
+            this.attachments.removeAll(chatId),
+            this.bookmarks?.removeChat(chatId),
+            this.visuals?.removeChat(chatId)
+        ]);
+        return true;
+    }
     /* The turn a chat took last, read off the record without loading a chat nobody has; null before its first. */
     async lastTurn(chatId) {
         const session = this.chats.get(chatId);
@@ -628,6 +709,13 @@ export class ChatCore {
         const session = this.require(chatId);
         return session.skills(() => this.skillIndex.list(session.info.provider, session.info.cwd));
     }
+    /* Ends the chat's CLI and keeps its conversation; the next message resumes it in a process that reads its skills and plugins again. */
+    async restart(chatId) {
+        const session = this.require(chatId);
+        const ended = session.restart();
+        this.skillIndex.forget(session.info.provider, session.info.cwd);
+        await ended;
+    }
     compact(chatId) {
         const session = this.require(chatId);
         if (session.busy) {
@@ -641,10 +729,10 @@ export class ChatCore {
         if (session.busy && !force) {
             throw new ChatError('chat-busy', `Chat ${chatId} is still working on the previous message`);
         }
-        await this.clearing(chatId);
+        await this.hooks.clearing?.(chatId);
         const ended = session.clear(force);
         // Before the record is written, so what it takes along from the record is gone from the write as well.
-        const cleared = this.cleared(chatId);
+        const cleared = this.hooks.cleared?.(chatId);
         // A debounced write still waiting holds the old thread and must not land after the empty one.
         this.cancelWaiting(chatId);
         // Folded right away: every line before the reset describes a thread that is gone.
@@ -683,6 +771,15 @@ export class ChatCore {
             throw new ChatError('request-not-found', `No question to dismiss under ${itemId}`);
         }
     }
+    /* Holds a chat at `needs-you` for what the host asks a person; false for a chat that is not here. */
+    holdForPerson(chatId, key) {
+        const session = this.chats.get(chatId);
+        session?.holdForPerson(key);
+        return session !== undefined;
+    }
+    releaseHold(chatId, key) {
+        this.chats.get(chatId)?.releaseHold(key);
+    }
     /* Removes a chat: its CLI, its record, its log, its attachments, its bookmarks and its visuals. */
     async kill(chatId) {
         await this.loaded(chatId);
@@ -703,9 +800,10 @@ export class ChatCore {
         this.activity.delete(chatId);
         this.chats.delete(chatId);
         this.attached.delete(chatId);
+        this.listChanges.delete(chatId);
         this.announced.delete(chatId);
         const snapshot = session.thread.snapshot();
-        this.forgotten(chatId);
+        this.hooks.forgotten?.(chatId);
         await writing;
         await ended;
         await Promise.all([
@@ -713,7 +811,7 @@ export class ChatCore {
             this.attachments.removeAll(chatId),
             this.bookmarks?.removeChat(chatId),
             this.visuals?.removeChat(chatId),
-            this.removed(chatId, snapshot)
+            this.hooks.removed?.(chatId, snapshot)
         ]);
     }
     /*
@@ -754,7 +852,7 @@ export class ChatCore {
             }
             await this.create({ chatId });
         }
-        await this.chats.get(chatId)?.resume(turnId, attempt, await this.resumeWords(chatId));
+        await this.chats.get(chatId)?.resume(turnId, attempt, (await this.hooks.resumeWords?.(chatId)) ?? DEFAULT_RESUME_WORDS);
     }
     /*
      * Takes up a turn that stopped on a limit, once its reset or its retry came. Loads the chat when
@@ -773,7 +871,7 @@ export class ChatCore {
             return;
         }
         const turn = session.thread.get(turnId);
-        const ended = this.endedAt(chatId);
+        const ended = this.hooks.endedAt?.(chatId) ?? null;
         if (turn !== undefined && ended !== null && ended >= turn.createdAt) {
             session.lapseResume();
             return;
@@ -803,6 +901,10 @@ export class ChatCore {
             if (this.chats.has(chatId) || this.creating.has(chatId)) {
                 continue;
             }
+            // Parsing the whole thread of every settled chat was most of the cost of a start.
+            if (await this.store.settled(chatId).catch(() => false)) {
+                continue;
+            }
             const record = await this.store.read(chatId).catch(() => null);
             const unowed = record?.info.resumeAt !== undefined && this.limitResume?.owed(chatId) === false;
             if (record !== null && (interruptedTurn(record) !== null || unowed)) {
@@ -847,7 +949,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), session.uiAccessRecord);
+                this.store.writeSync(chatId, info, items, { seq: log?.seq ?? 0, resetSeq: log?.resetSeq ?? 0 }, session.preambles, this.hooks.recordExtras?.(chatId) ?? {}, session.uiAccessRecord);
             }
             catch (e) {
                 console.error(`Chat record for ${chatId} failed:`, errorText(e));
@@ -862,10 +964,6 @@ export class ChatCore {
     async loaded(chatId) {
         await this.creating.get(chatId)?.catch(() => undefined);
     }
-    persist(chatId) {
-        this.cancelWaiting(chatId);
-        void this.persistNow(chatId).catch((e) => console.error(`Chat record for ${chatId} failed:`, errorText(e)));
-    }
     require(chatId) {
         const session = this.chats.get(chatId);
         if (!session) {
@@ -873,74 +971,9 @@ export class ChatCore {
         }
         return session;
     }
-    /* What the agent is told once at the start of every process of this chat; null for nothing. */
-    instructionsFor(_chatId) {
-        return this.instructions;
-    }
-    /* What of the instructions a resumed thread hears again in front of its next prompt, for a CLI that ignores them on a resume. */
-    resumeNoteFor(_chatId) {
-        return null;
-    }
-    /*
-     * Folders outside its working directory a chat's agent may reach without asking, absolute. Asked
-     * before every turn, so a host can hand one over for as long as it is needed: a change starts the
-     * next turn in a new process that resumes the thread, and never cuts a turn in flight.
-     */
-    foldersFor(_chatId) {
-        return [];
-    }
-    /* Whether no list of chats shows this one, which `ChatInfo.hidden` says to every client. */
-    hiddenFor(_chatId) {
-        return false;
-    }
-    /* What the host says in front of a chat's next real prompt, beside what the chat keeps itself. */
-    promptNotesFor(_chatId) {
-        return undefined;
-    }
-    /* How the chats a person attached to a message are named to the agent; without it they are dropped. */
-    referencesFor(_chatId) {
-        return undefined;
-    }
-    /* The environment of this chat's CLI before its account adds its own. */
-    envFor(_chatId, base) {
-        return base;
-    }
-    /* Throws for a folder this chat may not start in; asked every time a chat is loaded. */
-    async admit(_chatId, _cwd) { }
-    /* The model a new chat starts on when the host already knows; the explicit one still wins. */
-    openingSelection(_chatId, _kind) {
-        return undefined;
-    }
-    /* The mode a chat runs in, which a host may narrow whatever its record or its client says. */
-    runtimeModeFor(_chatId, mode) {
-        return mode;
-    }
-    /* A chat just loaded or made, its stored turns settled; whatever the host lays down in it goes here. */
-    async opened(_session, _stored) { }
-    /* What the host keeps in the chat's record beside the thread. */
-    recordExtras(_chatId) {
-        return {};
-    }
-    /* The chat was cleared; what runs before the first await is in the record written right after. */
-    async cleared(_chatId) { }
-    async clearing(_chatId) { }
-    /* The chat left memory for good, before its files go. */
-    forgotten(_chatId) { }
-    /* The chat was removed; what the host keeps of it goes along. */
-    async removed(_chatId, _chat) { }
-    /* An event of a chat went out, after the observers and before the clients reading its thread. */
-    broadcasted(_chatId, _event) { }
-    /* When whoever opened this chat stopped it; a turn from before that is never taken up again. */
-    endedAt(_chatId) {
-        return null;
-    }
-    /* Why a turn the host went down in stays down when `onInterruptedRun` says no, in the words of the note it ends with. */
-    unownedReason(_chatId) {
-        return 'nothing holds this chat any more';
-    }
-    /* How a turn the host went down in is taken up in this chat. */
-    async resumeWords(_chatId) {
-        return DEFAULT_RESUME_WORDS;
+    persist(chatId) {
+        this.cancelWaiting(chatId);
+        void this.persistNow(chatId).catch((e) => console.error(`Chat record for ${chatId} failed:`, errorText(e)));
     }
     /* A write that may wait: a long thread is not rewritten for every small change. */
     persistSoon(chatId) {
@@ -979,7 +1012,7 @@ 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 extras = this.hooks.recordExtras?.(chatId) ?? {};
             const uiAccess = session.uiAccessRecord;
             const unlogged = JSON.stringify([session.preambles, extras, uiAccess]);
             const folds = fold || log.size > COMPACT_ABOVE_BYTES || !log.onDisk;
@@ -1024,7 +1057,7 @@ export class ChatCore {
         for (const sink of this.observers) {
             sink({ event: 'chat.event', payload });
         }
-        this.broadcasted(chatId, event);
+        this.hooks.broadcasted?.(chatId, event);
         for (const clientId of this.attached.get(chatId) ?? []) {
             this.sinks.to(clientId, { event: 'chat.event', payload });
         }
@@ -1047,14 +1080,15 @@ export class ChatCore {
      */
     announceStatus(chatId, info) {
         // A limit, the resume owed after it and subagents still at work are what a header shows of an idle chat, so they count as a change too,
-        // and so does a request opening or settling while the chat already waits on another.
+        // and so does a request opening or settling while the chat already waits on another, and a goal set, moving on or gone.
         const said = JSON.stringify([
             info.status,
             info.limit ?? null,
             info.resumeAt ?? null,
             info.resumeAtReset ?? null,
             info.delegating ?? false,
-            info.requests?.map((request) => request.requestId) ?? []
+            info.requests?.map((request) => request.requestId) ?? [],
+            info.goal === undefined ? null : [info.goal.status, info.goal.objective]
         ]);
         if (this.announced.get(chatId) === said) {
             return;
@@ -1094,7 +1128,7 @@ export class ChatCore {
         if (stored.info.agentSessionId === null) {
             return skip('the agent had not started a session to resume yet');
         }
-        const ended = this.endedAt(chatId);
+        const ended = this.hooks.endedAt?.(chatId) ?? null;
         if (ended !== null && ended >= turn.createdAt) {
             return skip('the agent that opened it was stopped');
         }
@@ -1103,7 +1137,7 @@ export class ChatCore {
         }
         try {
             const owed = await this.onInterruptedRun({ chatId, turnId: turn.id, attempt: (turn.attempt ?? 1) + (turn.resumePending ? 0 : 1) });
-            return owed ? { resumeTurnId: turn.id, reason: null } : skip(this.unownedReason(chatId));
+            return owed ? { resumeTurnId: turn.id, reason: null } : skip(this.hooks.unownedReason?.(chatId) ?? 'nothing holds this chat any more');
         }
         catch (e) {
             console.error(`Owing a resume for chat ${chatId} failed:`, errorText(e));

package/dist/chat/chat-log.js

@@ -48,7 +48,7 @@ export class ChatLog {
     constructor(path, state = { seq: 0, resetSeq: 0, lines: [] }) {
         this.path = path;
         this.lines = state.lines;
-        this.bytes = state.lines.reduce((sum, line) => sum + JSON.stringify(line).length + 1, 0);
+        this.bytes = state.lines.reduce((sum, line) => sum + Buffer.byteLength(JSON.stringify(line)) + 1, 0);
         this.seqValue = Math.max(state.seq, state.lines.at(-1)?.seq ?? 0);
         this.resetSeqValue = state.resetSeq;
         const first = state.lines[0];
@@ -84,7 +84,7 @@ export class ChatLog {
         }
         const text = `${JSON.stringify(line)}\n`;
         this.lines.push(line);
-        this.bytes += text.length;
+        this.bytes += Buffer.byteLength(text);
         if (this.path !== null) {
             try {
                 this.fd ??= this.open(this.path);
@@ -122,7 +122,7 @@ export class ChatLog {
         this.lines = this.lines.filter((line) => line.seq > seq);
         this.base = seq;
         const text = this.lines.map((line) => `${JSON.stringify(line)}\n`).join('');
-        this.bytes = text.length;
+        this.bytes = Buffer.byteLength(text);
         if (this.path === null) {
             return;
         }

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

@@ -18,6 +18,12 @@ export interface ChatSpawnOptions {
 }
 export type SpawnChatProcess = (options: ChatSpawnOptions) => ChatProcess;
 export declare function spawnChatProcess(options: ChatSpawnOptions): ChatProcess;
+export interface ProcessTreeKillOptions {
+    platform?: NodeJS.Platform;
+    kill?(pid: number, signal: NodeJS.Signals): void;
+    run?(command: string[]): void;
+}
+export declare function killProcessTree(pid: number, signal: 'SIGTERM' | 'SIGKILL', options?: ProcessTreeKillOptions): void;
 export declare class StreamTail {
     readonly done: Promise<void>;
     private text;
@@ -25,6 +31,21 @@ export declare class StreamTail {
     lines(): string | null;
     private read;
 }
+export declare const MAX_LINE_LENGTH = 64000000;
+export declare class LineSplitter {
+    private readonly onLine;
+    private readonly onOverflow;
+    private readonly max;
+    private parts;
+    private length;
+    private dropping;
+    constructor(onLine: (line: string) => void, onOverflow: () => void, max?: number);
+    push(text: string): void;
+    end(): void;
+    private add;
+    private take;
+}
+export declare function readStreamLines(stream: ReadableStream<Uint8Array>, onLine: (line: string) => void, onOverflow: () => void, max?: number): Promise<void>;
 export interface ChatChildOptions extends Omit<ChatSpawnOptions, 'onExit'> {
     spawn?: SpawnChatProcess;
     onExit(exitCode: number | null, stderr: string | null): void;