@adecore/agents 0.46.2 → 0.47.0

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

@@ -1,4 +1,4 @@
-import { type AgentKind, type ChatAttachment, type ChatAttachResult, type ChatAttachmentUpload, type ChatBookmark, type ChatCheckpointDiff, type ChatConfigurePayload, type ChatCreatePayload, type ChatEvent, type ChatHistoryResult, type ChatGoalAction, 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 AgentKind, type ChatAttachment, type ChatAttachResult, type ChatAttachmentUpload, type ChatBookmark, type ChatCheckpointDiff, type ChatConfigurePayload, type ChatCreatePayload, type ChatEvent, type ChatHistoryResult, type ChatGoalAction, type ChatInfo, type ChatItem, type ChatNoteMessage, 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 { AgentEvent, AgentSink } from '../events.ts';
 import type { OutboxOutcome } from '../outbox/outbox-worker.ts';
 import { type AccountLaunches } from '../providers/accounts/launch.ts';
@@ -82,6 +82,7 @@ export interface ChatCoreOptions {
     };
     accounts?: AccountLaunches;
     hooks?: ChatCoreHooks;
+    unloadAfterMs?: number;
 }
 export declare class ChatCore {
     protected readonly bookmarks: BookmarkStore | null;
@@ -123,6 +124,9 @@ export declare class ChatCore {
     private readonly nameChat;
     private readonly onInterruptedRun;
     private readonly limitResume;
+    private readonly unloadAfterMs;
+    private readonly unloadTimers;
+    private readonly unloadedInfo;
     constructor(options: ChatCoreOptions);
     codexProcess(info: Pick<ChatInfo, 'cwd' | 'account'>): CodexProcessSpec;
     claudeProjectsDirOf(info: Pick<ChatInfo, 'account'>): string;
@@ -176,7 +180,7 @@ export declare class ChatCore {
     writeRecord(chatId: string, info: ChatInfo, items: ChatItem[], preambles?: string[]): Promise<void>;
     deleteRecord(chatId: string): Promise<boolean>;
     lastTurn(chatId: string): Promise<ChatTurnItem | null>;
-    addNote(chatId: string, level: 'info' | 'warning' | 'error', text: string): Promise<void>;
+    addNote(chatId: string, level: 'info' | 'warning' | 'error', text: string, message?: ChatNoteMessage): Promise<void>;
     deliverNote(chatId: string, delivery: {
         noteId: string;
         note: string;
@@ -257,6 +261,11 @@ export declare class ChatCore {
         updatedAt: number;
     }[];
     list(): ChatInfo[];
+    unloadIdle(chatId: string): Promise<boolean>;
+    private unloadable;
+    private scheduleUnload;
+    private cancelUnload;
+    private forgetLoaded;
     get(chatId: string): ChatSession | undefined;
     resumeRun(chatId: string, turnId: string, attempt: number): Promise<void>;
     takeUpAfterLimit(chatId: string, turnId: string): Promise<OutboxOutcome>;

package/dist/chat/chat-core.js

@@ -94,6 +94,10 @@ export class ChatCore {
     nameChat;
     onInterruptedRun;
     limitResume;
+    unloadAfterMs;
+    unloadTimers = new Map();
+    // The last info of each chat that left memory, so `list` still answers what it was doing.
+    unloadedInfo = new Map();
     constructor(options) {
         this.uiQueries = options.intelligentUi ? new ChatUiQueries(options.intelligentUi) : null;
         this.uiFenceLanguage = options.uiFenceLanguage;
@@ -111,6 +115,7 @@ export class ChatCore {
         this.nameChat = options.nameChat ?? null;
         this.onInterruptedRun = options.onInterruptedRun ?? null;
         this.limitResume = options.limitResume ?? null;
+        this.unloadAfterMs = options.store && options.unloadAfterMs !== undefined ? options.unloadAfterMs : null;
         this.hooks = options.hooks ?? {};
         this.commands = {
             ...(options.command ? { claude: options.command } : {}),
@@ -325,12 +330,15 @@ export class ChatCore {
             ...(this.limitResume ? { limitResume: limitHooks(this.limitResume, payload.chatId) } : {})
         });
         this.chats.set(session.id, session);
+        this.unloadedInfo.delete(session.id);
         if (stored) {
             session.settleStored(selection, resume);
             session.settleOwedResume();
             await session.settleOrphanedSubagents();
         }
         await this.hooks.opened?.(session, stored ?? null);
+        // A chat loaded for someone who never attaches, such as a host reading it, leaves again on its own.
+        this.scheduleUnload(session.id);
         return session.info;
     }
     async storedBackground(chatId) {
@@ -392,6 +400,7 @@ export class ChatCore {
         // client is on the list: the text is either in the snapshot or in the stream, never both.
         this.coalescers.get(chatId)?.flush();
         clients.add(clientId);
+        this.cancelUnload(chatId);
         const log = this.logs.get(chatId);
         const events = since === undefined ? null : log.after(since);
         if (events !== null) {
@@ -509,12 +518,14 @@ export class ChatCore {
     detach(chatId, clientId) {
         this.coalescers.get(chatId)?.flush();
         this.attached.get(chatId)?.delete(clientId);
+        this.scheduleUnload(chatId);
     }
     detachAll(clientId) {
         for (const [chatId, clients] of this.attached) {
             if (clients.has(clientId)) {
                 this.coalescers.get(chatId)?.flush();
                 clients.delete(clientId);
+                this.scheduleUnload(chatId);
             }
         }
         this.subagents.releaseClient(clientId);
@@ -613,6 +624,7 @@ export class ChatCore {
         if (this.chats.has(chatId) || this.creating.has(chatId)) {
             return false;
         }
+        this.unloadedInfo.delete(chatId);
         await Promise.all([
             this.store?.delete(chatId),
             this.attachments.removeAll(chatId),
@@ -631,7 +643,7 @@ export class ChatCore {
         return stored?.items.findLast((item) => item.kind === 'turn') ?? null;
     }
     /* A line from the host in a chat's thread, loading the chat when nobody has; nothing for a chat that is gone. */
-    async addNote(chatId, level, text) {
+    async addNote(chatId, level, text, message) {
         await this.loaded(chatId);
         if (!(await this.hasStored(chatId))) {
             return;
@@ -639,7 +651,7 @@ export class ChatCore {
         if (!this.chats.has(chatId)) {
             await this.create({ chatId });
         }
-        this.chats.get(chatId)?.addNote(level, text);
+        this.chats.get(chatId)?.addNote(level, text, message);
     }
     /*
      * Leaves a note and its preamble in a chat, loading that chat when nobody has; false when it was
@@ -897,21 +909,9 @@ export class ChatCore {
         // A write already out would put the record back after the delete.
         const writing = this.writes.get(chatId);
         const ended = session.dispose();
-        this.subagents.releaseChat(chatId);
-        this.uiQueries?.forget(chatId);
-        this.coalescers.get(chatId)?.dispose();
-        this.coalescers.delete(chatId);
-        this.logs.get(chatId)?.close();
-        this.logs.delete(chatId);
-        this.cancelWaiting(chatId);
-        this.sizes.delete(chatId);
-        this.unlogged.delete(chatId);
-        this.writes.delete(chatId);
-        this.activity.delete(chatId);
-        this.chats.delete(chatId);
+        this.forgetLoaded(chatId);
         this.attached.delete(chatId);
-        this.listChanges.delete(chatId);
-        this.announced.delete(chatId);
+        this.unloadedInfo.delete(chatId);
         const snapshot = session.thread.snapshot();
         this.hooks.forgotten?.(chatId);
         await writing;
@@ -944,7 +944,75 @@ export class ChatCore {
         return targets;
     }
     list() {
-        return [...this.chats.values()].map((session) => session.info);
+        return [...[...this.chats.values()].map((session) => session.info), ...this.unloadedInfo.values()];
+    }
+    /*
+     * Puts a chat nobody needs in memory back on disk alone: nobody reads it, it has no CLI, no turn,
+     * request, hold or move is under way, and no resume is owed. Answers whether it left. The next
+     * create, attach or note loads it again from its record, as after a restart.
+     */
+    async unloadIdle(chatId) {
+        this.cancelUnload(chatId);
+        if (!this.unloadable(chatId)) {
+            return false;
+        }
+        await this.persistNow(chatId, true);
+        const session = this.chats.get(chatId);
+        // Someone may have attached or sent while the record was written.
+        if (!session || !this.unloadable(chatId)) {
+            return false;
+        }
+        this.forgetLoaded(chatId);
+        this.attached.delete(chatId);
+        this.unloadedInfo.set(chatId, session.info);
+        await session.dispose();
+        return true;
+    }
+    unloadable(chatId) {
+        const session = this.chats.get(chatId);
+        return (session !== undefined &&
+            this.store !== null &&
+            (this.attached.get(chatId)?.size ?? 0) === 0 &&
+            !this.creating.has(chatId) &&
+            !this.relocations.has(chatId) &&
+            session.pid === null &&
+            session.relocatable &&
+            session.info.resumeAt === undefined &&
+            (session.info.requests?.length ?? 0) === 0);
+    }
+    scheduleUnload(chatId) {
+        if (this.unloadAfterMs === null || (this.attached.get(chatId)?.size ?? 0) > 0) {
+            return;
+        }
+        this.cancelUnload(chatId);
+        const timer = setTimeout(() => {
+            this.unloadTimers.delete(chatId);
+            void this.unloadIdle(chatId).catch((e) => console.error(`Unloading chat ${chatId} failed:`, errorText(e)));
+        }, this.unloadAfterMs);
+        timer.unref?.();
+        this.unloadTimers.set(chatId, timer);
+    }
+    cancelUnload(chatId) {
+        clearTimeout(this.unloadTimers.get(chatId));
+        this.unloadTimers.delete(chatId);
+    }
+    /* Drops what the core keeps of a loaded chat beside its session, which a kill and an unload share. */
+    forgetLoaded(chatId) {
+        this.subagents.releaseChat(chatId);
+        this.uiQueries?.forget(chatId);
+        this.coalescers.get(chatId)?.dispose();
+        this.coalescers.delete(chatId);
+        this.logs.get(chatId)?.close();
+        this.logs.delete(chatId);
+        this.cancelWaiting(chatId);
+        this.cancelUnload(chatId);
+        this.sizes.delete(chatId);
+        this.unlogged.delete(chatId);
+        this.writes.delete(chatId);
+        this.activity.delete(chatId);
+        this.chats.delete(chatId);
+        this.listChanges.delete(chatId);
+        this.announced.delete(chatId);
     }
     get(chatId) {
         return this.chats.get(chatId);
@@ -1032,6 +1100,7 @@ export class ChatCore {
         }
         for (const chatId of this.chats.keys()) {
             this.cancelWaiting(chatId);
+            this.cancelUnload(chatId);
         }
         // A thread that cannot be written still ends its CLI, whose process group would otherwise outlive the host.
         const written = await Promise.allSettled([...this.chats.keys()].map((chatId) => this.persistNow(chatId, true)));
@@ -1173,6 +1242,8 @@ export class ChatCore {
         for (const clientId of this.attached.get(chatId) ?? []) {
             this.sinks.to(clientId, { event: 'chat.event', payload });
         }
+        // A chat nobody reads counts its time from what it said last, such as its CLI going down.
+        this.scheduleUnload(chatId);
         // After the thread, so a client reading it has already had this info and the status is a no-op there.
         if (event.type === 'info' || event.type === 'reset') {
             this.announceStatus(chatId, event.info);

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

@@ -1,4 +1,4 @@
-import type { ChatAttachment, ChatCheckpointDiff, ChatEvent, ChatGoalAction, ChatInfo, ChatItem, ChatQueuedMessage, ChatQuoteSource, ChatSkill, ChatUiChoiceOrigin, ChatUiChoicePayload, ChatUiQueryState, ModelSelection, RuntimeMode } from '@adecore/agent-contracts';
+import type { ChatAttachment, ChatCheckpointDiff, ChatEvent, ChatGoalAction, ChatInfo, ChatItem, ChatNoteMessage, ChatQueuedMessage, ChatQuoteSource, ChatSkill, ChatUiChoiceOrigin, ChatUiChoicePayload, ChatUiQueryState, ModelSelection, RuntimeMode } from '@adecore/agent-contracts';
 import type { ChatProvider } from '../providers/provider.ts';
 import type { LimitsUpdate } from '../usage/limits/normalize.ts';
 import type { BackendLaunch } from './backend.ts';
@@ -211,7 +211,7 @@ export declare class ChatSession {
         preamble: string;
     }): boolean;
     upsertItems(items: readonly ChatItem[]): void;
-    addNote(level: 'info' | 'warning' | 'error', text: string): void;
+    addNote(level: 'info' | 'warning' | 'error', text: string, message?: ChatNoteMessage): void;
     end(reason: string): void;
     restart(): Promise<void>;
     dropProcess(): Promise<void>;

package/dist/chat/chat-session.js

@@ -1057,8 +1057,18 @@ export class ChatSession {
         this.options.persistSoon();
     }
     /* A line in the thread outside any turn, for something the host has to say about work it gave up on. */
-    addNote(level, text) {
-        this.emit([this.thread.upsert({ id: newId('note'), kind: 'note', createdAt: Date.now(), turnId: null, level, text })]);
+    addNote(level, text, message) {
+        this.emit([
+            this.thread.upsert({
+                id: newId('note'),
+                kind: 'note',
+                createdAt: Date.now(),
+                turnId: null,
+                level,
+                text,
+                ...(message === undefined ? {} : { message })
+            })
+        ]);
         this.options.persist();
     }
     /*

package/dist/chat/payload-store.js

@@ -8,7 +8,7 @@ import { CHAT_PAYLOAD_INLINE_BYTES, ChatCheckpointDiffSchema } from '@adecore/ag
 import { isNotFound, writeAtomic, writeAtomicSync } from '../fs.js';
 import { ChatError } from './errors.js';
 /* How much of a value stored apart the item keeps: what a timeline shows before anyone asks for the rest. */
-export const PAYLOAD_PREVIEW_BYTES = 8 * 1024;
+export const PAYLOAD_PREVIEW_BYTES = 2 * 1024;
 const FOLDER_SUFFIX = '.payloads';
 const ID_PATTERN = /^[0-9a-f]{64}$/;
 const CONTINUATION_MASK = 0xc0;

package/dist/messages/deliver-notice.d.ts

@@ -1,4 +1,4 @@
-import type { ChatItem } from '@adecore/agent-contracts';
+import type { ChatItem, ChatNoteMessage } from '@adecore/agent-contracts';
 import type { ChatCore } from '../chat/chat-core.ts';
 import type { Notice, NoticeStore } from './notice-store.ts';
 export interface MessageWords {
@@ -20,6 +20,7 @@ export declare function chatNoticeTargets(chats: Pick<ChatCore, 'get' | 'hasStor
 export declare function deliverToChat(store: Pick<NoticeStore, 'put'>, targets: ChatNoticeTargets, notice: Omit<Notice, 'createdAt'>): Promise<ChatDelivery>;
 export interface NoticeChat {
     has(id: string): Promise<boolean>;
-    note(id: string, text: string): Promise<void>;
+    note(id: string, text: string, message: ChatNoteMessage): Promise<void>;
 }
+export declare function noticeMessage(notice: Notice): ChatNoteMessage;
 export declare function showNotices(store: Pick<NoticeStore, 'show'>, chat: NoticeChat, words: Pick<MessageWords, 'shown'>, targetId: string): Promise<void>;

package/dist/messages/deliver-notice.js

@@ -57,6 +57,10 @@ export async function deliverToChat(store, targets, notice) {
     }
     return { outcome: 'wake', waiting };
 }
+/* The message itself on the line in the thread, so a client can draw it as said to the chat. */
+export function noticeMessage(notice) {
+    return { from: notice.from, title: notice.fromTitle, text: notice.text };
+}
 /*
  * Shows a person the message in the chat's thread the moment it lands, not when the model gets round
  * to it. An id no chat holds shows and marks nothing, so a chat that opens on it later still has all of it.
@@ -66,6 +70,6 @@ export async function showNotices(store, chat, words, targetId) {
         return;
     }
     for (const notice of await store.show(targetId)) {
-        await chat.note(targetId, words.shown(notice));
+        await chat.note(targetId, words.shown(notice), noticeMessage(notice));
     }
 }

package/dist/messages/notice-notes.d.ts

@@ -1,5 +1,6 @@
+import type { ChatNoteMessage } from '@adecore/agent-contracts';
 import type { PromptNotes } from '../chat/chat-session.ts';
-import type { MessageWords } from './deliver-notice.ts';
+import { type MessageWords } from './deliver-notice.ts';
 import type { NoticeStore } from './notice-store.ts';
 export declare class NoticeNotes implements PromptNotes {
     private readonly store;
@@ -12,4 +13,7 @@ export declare class NoticeNotes implements PromptNotes {
     };
     reset(): void;
 }
-export declare function unshownNotes(store: Pick<NoticeStore, 'show'>, chatId: string, words: Pick<MessageWords, 'shown'>): Promise<string[]>;
+export declare function unshownNotes(store: Pick<NoticeStore, 'show'>, chatId: string, words: Pick<MessageWords, 'shown'>): Promise<{
+    text: string;
+    message: ChatNoteMessage;
+}[]>;

package/dist/messages/notice-notes.js

@@ -1,3 +1,4 @@
+import { noticeMessage } from './deliver-notice.js';
 /*
  * What another node left for a chat, taken from the queue in front of its next prompt so the model
  * hears it once. Nothing of it is shown: a person read each message in the thread as it landed
@@ -22,5 +23,5 @@ export class NoticeNotes {
  * reload writes none again. The model still hears the messages themselves from the queue.
  */
 export async function unshownNotes(store, chatId, words) {
-    return (await store.show(chatId)).map((notice) => words.shown(notice));
+    return (await store.show(chatId)).map((notice) => ({ text: words.shown(notice), message: noticeMessage(notice) }));
 }

package/package.json

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

package/src/chat/chat-core.ts

@@ -17,6 +17,7 @@ import {
     type ChatGoalAction,
     type ChatInfo,
     type ChatItem,
+    type ChatNoteMessage,
     type ChatQueuedMessage,
     type ChatUiChoicePayload,
     type ChatUiQueryPayload,
@@ -215,6 +216,12 @@ export interface ChatCoreOptions {
     // The accounts a chat may run under; without them every chat runs under its CLI's default account.
     accounts?: AccountLaunches;
     hooks?: ChatCoreHooks;
+    /*
+     * How long a chat stays in memory once nobody reads it, its CLI is gone and nothing is under way;
+     * after that only its info stays, for `list`, until something loads it again. Without it, or
+     * without a store, a loaded chat stays until it is removed or the host stops.
+     */
+    unloadAfterMs?: number;
 }
 
 /*
@@ -272,6 +279,10 @@ export class ChatCore {
     private readonly nameChat: ChatCoreOptions['nameChat'] | null;
     private readonly onInterruptedRun: ChatCoreOptions['onInterruptedRun'] | null;
     private readonly limitResume: ChatCoreOptions['limitResume'] | null;
+    private readonly unloadAfterMs: number | null;
+    private readonly unloadTimers = new Map<string, ReturnType<typeof setTimeout>>();
+    // The last info of each chat that left memory, so `list` still answers what it was doing.
+    private readonly unloadedInfo = new Map<string, ChatInfo>();
 
     constructor(options: ChatCoreOptions) {
         this.uiQueries = options.intelligentUi ? new ChatUiQueries(options.intelligentUi) : null;
@@ -290,6 +301,7 @@ export class ChatCore {
         this.nameChat = options.nameChat ?? null;
         this.onInterruptedRun = options.onInterruptedRun ?? null;
         this.limitResume = options.limitResume ?? null;
+        this.unloadAfterMs = options.store && options.unloadAfterMs !== undefined ? options.unloadAfterMs : null;
         this.hooks = options.hooks ?? {};
 
         this.commands = {
@@ -549,6 +561,7 @@ export class ChatCore {
         });
 
         this.chats.set(session.id, session);
+        this.unloadedInfo.delete(session.id);
 
         if (stored) {
             session.settleStored(selection, resume);
@@ -557,6 +570,8 @@ export class ChatCore {
         }
 
         await this.hooks.opened?.(session, stored ?? null);
+        // A chat loaded for someone who never attaches, such as a host reading it, leaves again on its own.
+        this.scheduleUnload(session.id);
 
         return session.info;
     }
@@ -642,6 +657,7 @@ export class ChatCore {
         // client is on the list: the text is either in the snapshot or in the stream, never both.
         this.coalescers.get(chatId)?.flush();
         clients.add(clientId);
+        this.cancelUnload(chatId);
         const log = this.logs.get(chatId)!;
         const events = since === undefined ? null : log.after(since);
 
@@ -797,6 +813,7 @@ export class ChatCore {
     detach(chatId: string, clientId: string): void {
         this.coalescers.get(chatId)?.flush();
         this.attached.get(chatId)?.delete(clientId);
+        this.scheduleUnload(chatId);
     }
 
     detachAll(clientId: string): void {
@@ -804,6 +821,7 @@ export class ChatCore {
             if (clients.has(clientId)) {
                 this.coalescers.get(chatId)?.flush();
                 clients.delete(clientId);
+                this.scheduleUnload(chatId);
             }
         }
 
@@ -931,6 +949,8 @@ export class ChatCore {
             return false;
         }
 
+        this.unloadedInfo.delete(chatId);
+
         await Promise.all([
             this.store?.delete(chatId),
             this.attachments.removeAll(chatId),
@@ -955,7 +975,7 @@ export class ChatCore {
     }
 
     /* A line from the host in a chat's thread, loading the chat when nobody has; nothing for a chat that is gone. */
-    async addNote(chatId: string, level: 'info' | 'warning' | 'error', text: string): Promise<void> {
+    async addNote(chatId: string, level: 'info' | 'warning' | 'error', text: string, message?: ChatNoteMessage): Promise<void> {
         await this.loaded(chatId);
 
         if (!(await this.hasStored(chatId))) {
@@ -966,7 +986,7 @@ export class ChatCore {
             await this.create({ chatId });
         }
 
-        this.chats.get(chatId)?.addNote(level, text);
+        this.chats.get(chatId)?.addNote(level, text, message);
     }
 
     /*
@@ -1295,21 +1315,9 @@ export class ChatCore {
         // A write already out would put the record back after the delete.
         const writing = this.writes.get(chatId);
         const ended = session.dispose();
-        this.subagents.releaseChat(chatId);
-        this.uiQueries?.forget(chatId);
-        this.coalescers.get(chatId)?.dispose();
-        this.coalescers.delete(chatId);
-        this.logs.get(chatId)?.close();
-        this.logs.delete(chatId);
-        this.cancelWaiting(chatId);
-        this.sizes.delete(chatId);
-        this.unlogged.delete(chatId);
-        this.writes.delete(chatId);
-        this.activity.delete(chatId);
-        this.chats.delete(chatId);
+        this.forgetLoaded(chatId);
         this.attached.delete(chatId);
-        this.listChanges.delete(chatId);
-        this.announced.delete(chatId);
+        this.unloadedInfo.delete(chatId);
         const snapshot = session.thread.snapshot();
         this.hooks.forgotten?.(chatId);
         await writing;
@@ -1349,7 +1357,91 @@ export class ChatCore {
     }
 
     list(): ChatInfo[] {
-        return [...this.chats.values()].map((session) => session.info);
+        return [...[...this.chats.values()].map((session) => session.info), ...this.unloadedInfo.values()];
+    }
+
+    /*
+     * Puts a chat nobody needs in memory back on disk alone: nobody reads it, it has no CLI, no turn,
+     * request, hold or move is under way, and no resume is owed. Answers whether it left. The next
+     * create, attach or note loads it again from its record, as after a restart.
+     */
+    async unloadIdle(chatId: string): Promise<boolean> {
+        this.cancelUnload(chatId);
+
+        if (!this.unloadable(chatId)) {
+            return false;
+        }
+
+        await this.persistNow(chatId, true);
+        const session = this.chats.get(chatId);
+
+        // Someone may have attached or sent while the record was written.
+        if (!session || !this.unloadable(chatId)) {
+            return false;
+        }
+
+        this.forgetLoaded(chatId);
+        this.attached.delete(chatId);
+        this.unloadedInfo.set(chatId, session.info);
+        await session.dispose();
+
+        return true;
+    }
+
+    private unloadable(chatId: string): boolean {
+        const session = this.chats.get(chatId);
+
+        return (
+            session !== undefined &&
+            this.store !== null &&
+            (this.attached.get(chatId)?.size ?? 0) === 0 &&
+            !this.creating.has(chatId) &&
+            !this.relocations.has(chatId) &&
+            session.pid === null &&
+            session.relocatable &&
+            session.info.resumeAt === undefined &&
+            (session.info.requests?.length ?? 0) === 0
+        );
+    }
+
+    private scheduleUnload(chatId: string): void {
+        if (this.unloadAfterMs === null || (this.attached.get(chatId)?.size ?? 0) > 0) {
+            return;
+        }
+
+        this.cancelUnload(chatId);
+
+        const timer = setTimeout(() => {
+            this.unloadTimers.delete(chatId);
+            void this.unloadIdle(chatId).catch((e) => console.error(`Unloading chat ${chatId} failed:`, errorText(e)));
+        }, this.unloadAfterMs);
+
+        timer.unref?.();
+        this.unloadTimers.set(chatId, timer);
+    }
+
+    private cancelUnload(chatId: string): void {
+        clearTimeout(this.unloadTimers.get(chatId));
+        this.unloadTimers.delete(chatId);
+    }
+
+    /* Drops what the core keeps of a loaded chat beside its session, which a kill and an unload share. */
+    private forgetLoaded(chatId: string): void {
+        this.subagents.releaseChat(chatId);
+        this.uiQueries?.forget(chatId);
+        this.coalescers.get(chatId)?.dispose();
+        this.coalescers.delete(chatId);
+        this.logs.get(chatId)?.close();
+        this.logs.delete(chatId);
+        this.cancelWaiting(chatId);
+        this.cancelUnload(chatId);
+        this.sizes.delete(chatId);
+        this.unlogged.delete(chatId);
+        this.writes.delete(chatId);
+        this.activity.delete(chatId);
+        this.chats.delete(chatId);
+        this.listChanges.delete(chatId);
+        this.announced.delete(chatId);
     }
 
     get(chatId: string): ChatSession | undefined {
@@ -1460,6 +1552,7 @@ export class ChatCore {
 
         for (const chatId of this.chats.keys()) {
             this.cancelWaiting(chatId);
+            this.cancelUnload(chatId);
         }
 
         // A thread that cannot be written still ends its CLI, whose process group would otherwise outlive the host.
@@ -1649,6 +1742,9 @@ export class ChatCore {
             this.sinks.to(clientId, { event: 'chat.event', payload });
         }
 
+        // A chat nobody reads counts its time from what it said last, such as its CLI going down.
+        this.scheduleUnload(chatId);
+
         // After the thread, so a client reading it has already had this info and the status is a no-op there.
         if (event.type === 'info' || event.type === 'reset') {
             this.announceStatus(chatId, event.info);

package/src/chat/chat-session.ts

@@ -6,6 +6,7 @@ import type {
     ChatGoalAction,
     ChatInfo,
     ChatItem,
+    ChatNoteMessage,
     ChatQueuedMessage,
     ChatQuoteSource,
     ChatSkill,
@@ -1470,8 +1471,18 @@ export class ChatSession {
     }
 
     /* A line in the thread outside any turn, for something the host has to say about work it gave up on. */
-    addNote(level: 'info' | 'warning' | 'error', text: string): void {
-        this.emit([this.thread.upsert({ id: newId('note'), kind: 'note', createdAt: Date.now(), turnId: null, level, text })]);
+    addNote(level: 'info' | 'warning' | 'error', text: string, message?: ChatNoteMessage): void {
+        this.emit([
+            this.thread.upsert({
+                id: newId('note'),
+                kind: 'note',
+                createdAt: Date.now(),
+                turnId: null,
+                level,
+                text,
+                ...(message === undefined ? {} : { message })
+            })
+        ]);
         this.options.persist();
     }
 

package/src/chat/payload-store.ts

@@ -9,7 +9,7 @@ import { isNotFound, writeAtomic, writeAtomicSync } from '../fs.ts';
 import { ChatError } from './errors.ts';
 
 /* How much of a value stored apart the item keeps: what a timeline shows before anyone asks for the rest. */
-export const PAYLOAD_PREVIEW_BYTES = 8 * 1024;
+export const PAYLOAD_PREVIEW_BYTES = 2 * 1024;
 
 const FOLDER_SUFFIX = '.payloads';
 const ID_PATTERN = /^[0-9a-f]{64}$/;

package/src/messages/deliver-notice.ts

@@ -1,4 +1,4 @@
-import type { ChatItem } from '@adecore/agent-contracts';
+import type { ChatItem, ChatNoteMessage } from '@adecore/agent-contracts';
 import type { ChatCore } from '../chat/chat-core.ts';
 import type { Notice, NoticeStore } from './notice-store.ts';
 
@@ -111,7 +111,12 @@ export interface NoticeChat {
     /* Whether the host holds a chat under the id, running or on disk. */
     has(id: string): Promise<boolean>;
     /* Puts a line in that chat's thread, loading the chat when nobody has. */
-    note(id: string, text: string): Promise<void>;
+    note(id: string, text: string, message: ChatNoteMessage): Promise<void>;
+}
+
+/* The message itself on the line in the thread, so a client can draw it as said to the chat. */
+export function noticeMessage(notice: Notice): ChatNoteMessage {
+    return { from: notice.from, title: notice.fromTitle, text: notice.text };
 }
 
 /*
@@ -124,6 +129,6 @@ export async function showNotices(store: Pick<NoticeStore, 'show'>, chat: Notice
     }
 
     for (const notice of await store.show(targetId)) {
-        await chat.note(targetId, words.shown(notice));
+        await chat.note(targetId, words.shown(notice), noticeMessage(notice));
     }
 }

package/src/messages/notice-notes.ts

@@ -1,5 +1,6 @@
+import type { ChatNoteMessage } from '@adecore/agent-contracts';
 import type { PromptNotes } from '../chat/chat-session.ts';
-import type { MessageWords } from './deliver-notice.ts';
+import { noticeMessage, type MessageWords } from './deliver-notice.ts';
 import type { NoticeStore } from './notice-store.ts';
 
 /*
@@ -29,6 +30,10 @@ export class NoticeNotes implements PromptNotes {
  * The lines a chat that just loaded owes a person for what landed while nobody held it, marked so a
  * reload writes none again. The model still hears the messages themselves from the queue.
  */
-export async function unshownNotes(store: Pick<NoticeStore, 'show'>, chatId: string, words: Pick<MessageWords, 'shown'>): Promise<string[]> {
-    return (await store.show(chatId)).map((notice) => words.shown(notice));
+export async function unshownNotes(
+    store: Pick<NoticeStore, 'show'>,
+    chatId: string,
+    words: Pick<MessageWords, 'shown'>
+): Promise<{ text: string; message: ChatNoteMessage }[]> {
+    return (await store.show(chatId)).map((notice) => ({ text: words.shown(notice), message: noticeMessage(notice) }));
 }