@adecore/agents 0.21.1 → 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;

package/dist/chat/chat-core.js

@@ -1,25 +1,25 @@
 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 { readableAssistantText } from './readable-text.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);
 }

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-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.
@@ -24,7 +24,7 @@ const RecordSchema = z.looseObject({
     uiAccess: z.record(z.string(), z.unknown()).optional()
 });
 const OWN_KEYS = new Set(['info', 'items', 'seq', 'resetSeq', 'preambles', 'uiAccess']);
-function extrasOf(record) {
+function withoutOwnKeys(record) {
     return Object.fromEntries(Object.entries(record).filter(([key]) => !OWN_KEYS.has(key)));
 }
 function logName(chatId) {
@@ -54,9 +54,6 @@ function liftUiAccess(record) {
     }
     return Object.keys(uiAccess).length === 0 ? record : { ...record, uiAccess };
 }
-function withoutOwnKeys(extras) {
-    return Object.fromEntries(Object.entries(extras).filter(([key]) => !OWN_KEYS.has(key)));
-}
 /*
  * One JSON file per chat under `<home>/chats`, written while a turn runs and on shutdown, with
  * the log of what happened since beside it (`ChatLog` appends to it; reading plays it back).
@@ -146,7 +143,7 @@ export class ChatStore {
             resetSeq,
             preambles: snapshot.preambles ?? [],
             uiAccess: snapshot.uiAccess ?? {},
-            extras: extrasOf(snapshot),
+            extras: withoutOwnKeys(snapshot),
             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"'];
 /*

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

@@ -7,12 +7,12 @@ export interface CodexBackendOptions {
 }
 export declare class CodexBackend implements ChatBackend {
     readonly acknowledgesTurns = true;
-    private promptId;
     private readonly launch;
-    private imageWrites;
     private readonly host;
     private readonly protocol;
     private readonly client;
+    private promptId;
+    private imageWrites;
     private transport;
     private threadId;
     private contextPending;

package/dist/chat/codex-backend.js

@@ -1,10 +1,10 @@
 import { accessSync, constants } from 'node:fs';
 import { attachmentImageMime } from '@adecore/agent-contracts';
+import { errorText } from '../error-text.js';
 import { codexServiceTier, codexThreadOptions } from '../providers/codex.js';
 import { CodexProtocol } from './codex-protocol.js';
-import { attachmentNote } from './input.js';
 import { CodexTransport, DEFAULT_CODEX_CLIENT } from './codex-transport.js';
-import { errorText } from '../error-text.js';
+import { attachmentNote } from './input.js';
 function textInput(text) {
     return [{ type: 'text', text, text_elements: [] }];
 }
@@ -37,18 +37,15 @@ export function parseSkillsList(result) {
  */
 export class CodexBackend {
     acknowledgesTurns = true;
-    promptId = null;
     launch;
-    imageWrites = null;
     host;
     protocol;
     client;
+    promptId = null;
+    imageWrites = null;
     transport = null;
     threadId = '';
-    /*
-     * Codex 0.154 ignores developer instructions on `thread/resume` (measured), so a thread started
-     * before anything was linked would never hear of its links; the first prompt of a resumed process says so instead.
-     */
+    // Codex 0.154 ignores developer instructions on `thread/resume` (measured), so the first prompt of a resumed process carries them.
     contextPending = null;
     imageInputSupported = null;
     /* A turn asked for that Codex has not named yet; `turn/interrupt` needs that name. */

package/dist/chat/codex-protocol.js

@@ -130,7 +130,7 @@ function elicitationInput(meta) {
     }
     return input;
 }
-// Every spent window must reset; one unknown reset keeps resuming a person's choice.
+// The latest reset of every spent window; one without a known reset leaves resuming to a person.
 function spentUntil(windows) {
     const spent = windows.filter((window) => window.used >= 1);
     if (spent.length === 0 || spent.some((window) => window.resetsAt === null)) {

package/dist/chat/codex-thread.js

@@ -1,8 +1,8 @@
+import { errorText } from '../error-text.js';
 import { CodexProtocol } from './codex-protocol.js';
 import { CodexTransport, DEFAULT_CODEX_CLIENT } from './codex-transport.js';
 import { ChatError } from './errors.js';
 import { readingThread, settledReading } from './subagent-projection.js';
-import { errorText } from '../error-text.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -85,14 +85,13 @@ async function nthTurnId(transport, threadId, turns) {
     let seen = 0;
     let cursor = null;
     do {
-        const page = await transport.request('thread/turns/list', { threadId, limit: 100, sortDirection: 'asc', ...(cursor === null ? {} : { cursor }) });
-        const data = isRecord(page) && Array.isArray(page.data) ? page.data.filter(isRecord) : [];
-        for (const turn of data) {
+        const page = parseThreadItemsPage(await transport.request('thread/turns/list', { threadId, limit: 100, sortDirection: 'asc', ...(cursor === null ? {} : { cursor }) }));
+        for (const turn of page.entries) {
             if (++seen === turns) {
                 return typeof turn.id === 'string' ? turn.id : null;
             }
         }
-        cursor = isRecord(page) && typeof page.nextCursor === 'string' && page.nextCursor !== '' ? page.nextCursor : null;
+        cursor = page.nextCursor;
     } while (cursor !== null);
     return null;
 }

package/dist/chat/composer-preferences.js

@@ -1,8 +1,7 @@
 /*
  * What each connected client says a new chat starts with, for the chats the host starts with no
- * client mounting them. Held per socket like the approval switch: a machine never remembers a
- * person's pick after that person's client is gone, so with nobody connected a chat gets the
- * host's own defaults.
+ * client mounting them. Held per client only, so with nobody connected a chat gets the host's own
+ * defaults rather than the pick of a person who left.
  */
 export class ComposerPreferences {
     byClient = new Map();

package/dist/chat/limit-resume.js

@@ -2,13 +2,8 @@
 export const LIMIT_RETRY_DELAYS_MS = [60_000, 5 * 60_000, 15 * 60_000];
 /* The last turn of a thread, when it stopped on a limit. */
 export function limitedTurn(items) {
-    for (let i = items.length - 1; i >= 0; i--) {
-        const item = items[i];
-        if (item.kind === 'turn') {
-            return item.state === 'error' && item.limit !== undefined ? item : null;
-        }
-    }
-    return null;
+    const last = items.findLast((item) => item.kind === 'turn');
+    return last?.kind === 'turn' && last.state === 'error' && last.limit !== undefined ? last : null;
 }
 /* How many turns in a row, up to and including this one, stopped on a limit: the tries a person did not step in between. */
 function limitedInARow(items, turn) {

package/dist/chat/visual-store.js

@@ -59,6 +59,12 @@ function tooLarge(bytes) {
     return refuse('visual-too-large', `The page is ${mebibytes(bytes)} and a visual may be at most ${mebibytes(VISUAL_LIMITS.bytes)}; ` +
         'load libraries from a public CDN URL and refer to large images by their http(s) URL instead of inlining them');
 }
+function refuseOversized(html) {
+    const bytes = Buffer.byteLength(html, 'utf8');
+    if (bytes > VISUAL_LIMITS.bytes) {
+        tooLarge(bytes);
+    }
+}
 /*
  * The visuals of every chat. The list of a chat is one file beside its record under `<home>/chats`;
  * each page is a file in the chat's attachment folder, `<id>.html`, so whatever serves an attachment
@@ -104,9 +110,7 @@ export class VisualStore {
         if (html.trim() === '') {
             refuse('visual-invalid', 'The page is empty; pass one self-contained HTML document');
         }
-        if (Buffer.byteLength(html, 'utf8') > VISUAL_LIMITS.bytes) {
-            tooLarge(Buffer.byteLength(html, 'utf8'));
-        }
+        refuseOversized(html);
         return this.writeWorkspaceFile(chatId, name, html);
     }
     writePreview(chatId, png) {
@@ -116,9 +120,7 @@ export class VisualStore {
     async publish(chatId, input) {
         const { title, html, maxHeight, layout, heights } = checked(input);
         // Before the bootstrap is added, so a page far too large is never copied first.
-        if (Buffer.byteLength(html, 'utf8') > VISUAL_LIMITS.bytes) {
-            tooLarge(Buffer.byteLength(html, 'utf8'));
-        }
+        refuseOversized(html);
         const page = Buffer.from(injectVisualBootstrap(html), 'utf8');
         if (page.byteLength > VISUAL_LIMITS.bytes) {
             tooLarge(page.byteLength);

package/dist/context/refusal.js

@@ -1,8 +1,7 @@
 /*
  * How every no reads: `refused`, the code a script branches on and the sentence a model reads, and
- * under it a line per thing the actor can do instead. One row per line, and a line is a row of
- * tab-separated fields of its own, so only a newline is taken out of it: that would split the row in
- * two, and everything under the first row is read as advice.
+ * under it a line per thing the actor can do instead. A line keeps its tabs but loses its newlines,
+ * since everything under the first row is read as advice.
  */
 /* A field that goes into a tab-separated line; a tab or a newline in a title would split the row. */
 export function field(value) {
@@ -19,10 +18,7 @@ export function refusalBody(code, message, lines = []) {
     const [first, ...rest] = rows(code, message, lines);
     return [`refused\t${first}`, ...rest].join('\n');
 }
-/*
- * The same without the word that names it, for a host that adds the prefix in its CLI:
- * The context CLI puts the prefix on, so a CLI of an older build still prints one refusal.
- */
+/* Without the `refused` prefix, for a host whose CLI adds it, so a CLI of an older build still prints one refusal. */
 export function refusalRows(code, message, lines = []) {
     return rows(code, message, lines).join('\n');
 }

package/dist/context/verb.js

@@ -223,11 +223,7 @@ export function lengthOf(input) {
 export function requiredField(needs) {
     return z.string({ error: needs }).min(1, needs);
 }
-/*
- * What a refusal lists, or one line saying the set is empty. A refusal that promises the groups of a
- * canvas and then prints nothing reads as a daemon that lost them, where the truth is that there are
- * none, which is a different thing to do something about.
- */
+/* A refusal that promises a list and prints nothing reads as a host that lost it, where there is none. */
 export function orNote(lines, note) {
     return lines.length === 0 ? [`note\t${note}`] : lines;
 }

package/dist/host/agent-host.js

@@ -10,8 +10,8 @@ function isAgentRequest(type) {
 }
 /*
  * The chats of an app that has no daemon: it answers the agent requests over any `FramePort` and
- * sends the agent events back on it, frames checked on arrival. One port is one client. Closing the host writes every thread and ends every CLI; a chat
- * goes on at the next start through its CLI's own session.
+ * sends the agent events back on it, frames checked on arrival. One port is one client. A chat
+ * closed with the host goes on at the next start through its CLI's own session.
  */
 export class AgentHost {
     chats;

package/dist/host/handlers.js

@@ -81,7 +81,6 @@ export function chatHandlers(chats, providers) {
         'chat.list': () => ({ chats: chats.list() })
     };
 }
-/* The accounts are the person's settings of this host. */
 export function accountHandlers(accounts) {
     return {
         'accounts.list': () => accounts.snapshot(),

package/dist/host/wiring.js

@@ -6,10 +6,10 @@ import { suggestChatTitle } from '../chat/chat-title.js';
 import { VisualStore } from '../chat/visual-store.js';
 import { ClaudeTitleReader } from '../chat/claude-title.js';
 import { DEFAULT_CODEX_CLIENT } from '../chat/codex-transport.js';
+import { errorText } from '../error-text.js';
 import { definedEnv } from '../providers/accounts/launch.js';
 import { ProviderAccountsService } from '../providers/accounts/service.js';
 import { createClaudeProvider } from '../providers/claude-provider.js';
-import { errorText } from '../error-text.js';
 import { createCodexProvider } from '../providers/codex-provider.js';
 import { codexRulesPathIn, defaultCodexHome, installCodexRules } from '../providers/codex-rules.js';
 import { ProviderRegistry } from '../providers/registry.js';

package/dist/lineage.js

@@ -25,8 +25,8 @@ function openedByAgent(entry) {
     return entry.agent && entry.relation !== 'fork';
 }
 /*
- * Lineage lives in `lineage` under the host's data folder, outside the agent-writable project, so agents
- * cannot reset their own depth. Persisting it also prevents a restart of the host from resetting recursion limits.
+ * Lives under the host's data folder, outside the agent-writable project, so an agent cannot reset its
+ * own depth; on disk, so a restart of the host does not reset it either.
  */
 export class AgentLineageStore {
     dir;
@@ -117,7 +117,6 @@ export class AgentLineageStore {
         const entry = this.opened.get(nodeId);
         return entry?.relation === 'fork' ? entry.openedBy : null;
     }
-    /* The forks made from a chat. */
     forksOf(nodeId) {
         return [...this.opened.all()].filter((entry) => entry.relation === 'fork' && entry.openedBy === nodeId).map((entry) => entry.nodeId);
     }

package/dist/messages/deliver-message.js

@@ -5,13 +5,11 @@ export const DeliverMessageWorkSchema = z.object({
     payload: z.object({ from: z.string().min(1) })
 });
 /*
- * Opens the turn a message earns a chat. The messages themselves are not carried here: they wait in
- * the notice store and the turn's preamble takes them (`NoticeNotes`), the same channel a person's
- * own prompt reads them through, so one message is heard once whichever of the two opens the turn.
+ * Opens the turn a message earns a chat. The messages wait in the notice store and the turn's preamble
+ * takes them (`NoticeNotes`), as a person's own prompt does, so a message is heard once either way.
  *
- * One attempt, never `wait`. A chat that turned out to be in a turn reads the message in front of its
- * next one, which is what a message to a busy chat has always done; holding the entry instead would
- * make the host start turns nobody asked for long after the news was worth anything.
+ * One attempt, never `wait`: a chat already in a turn reads the message in front of its next one, and
+ * holding the entry would start turns nobody asked for long after the news mattered.
  */
 export function deliverMessageHandler(deps) {
     return async (entry) => {
@@ -27,11 +25,8 @@ export function deliverMessageHandler(deps) {
         if (chat === null) {
             return;
         }
-        /*
-         * No note of its own, and the preamble stays off the thread. A person read the message as it
-         * landed (`showNotices`), so anything the turn adds about it only says the same thing again;
-         * the label on the turn already names who it came from.
-         */
+        // No note and no preamble on the thread: a person read the message as it landed (`showNotices`),
+        // and the label on the turn names who it came from.
         chat.wake({
             text: deps.words.prompt(waiting.length),
             label: deps.words.label(waiting),

package/dist/messages/deliver-notice.js

@@ -1,9 +1,8 @@
 /*
- * Whether the turn a chat is running was itself opened by a message. This is the whole of the stop:
- * two agents that read each other would otherwise wake each other for as long as they kept writing,
- * and nothing about that started with a person. It rides on the turn, so it survives a restart.
+ * Whether the turn a chat is running was itself opened by a message, which stops two agents that
+ * read each other from waking each other forever. It rides on the turn, so it survives a restart.
  * Between turns the last one counts, since work it left running (a background subagent) may still
- * write, and a turn the CLI opened by itself goes on with the step of the turn before it.
+ * write, and a turn the CLI opened by itself takes the step of the turn before it.
  */
 export function turnFromMessage(items, activeTurnId) {
     const from = activeTurnId === null ? items.findLastIndex((item) => item.kind === 'turn') : items.findIndex((item) => item.id === activeTurnId);
@@ -40,10 +39,9 @@ export function chatNoticeTargets(chats) {
 }
 /*
  * One message on its way to a chat, and whether the chat owes a turn on it. A chat between turns gets
- * one, the way a settled task gives one: a person watching two agents cannot tell a message from an
- * assignment, and a message nobody starts a turn for sits there until someone happens to prompt that
- * chat. One step deep, so the turn a message opened wakes nobody with a message of its own. A node the
- * host runs something else in, such as a terminal, is the host's to deliver to before this.
+ * one, as for a settled task, or the message sits there until someone happens to prompt that chat.
+ * One step deep: the turn a message opened wakes nobody with a message of its own. A node that runs
+ * something else, such as a terminal, is the host's to deliver to before this.
  */
 export async function deliverToChat(store, targets, notice) {
     const waiting = await store.put(notice);
@@ -60,10 +58,8 @@ export async function deliverToChat(store, targets, notice) {
     return { outcome: 'wake', waiting };
 }
 /*
- * What a chat has to show a person, in its thread, the moment a message lands and not when the model
- * gets round to it: without this a message left for a busy node is a file on disk and nothing else.
- * An id no chat holds shows nothing and marks nothing, so the chat that opens on that id later still
- * has all of it.
+ * 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.
  */
 export async function showNotices(store, chat, words, targetId) {
     if (!(await chat.has(targetId))) {

package/dist/messages/notice-store.js

@@ -5,10 +5,8 @@ import { RecordDirectory } from '../record-directory.js';
 // Per receiver. Past this the oldest goes: an agent in a loop must not fill a queue nobody reads.
 export const MAX_NOTICES = 10;
 /*
- * A message nobody picked up in this long is dropped rather than delivered. It is news about work
- * happening now ("the build is green"), and a model reading it six hours late would act on
- * something that has moved on. The cap alone would not do it: one message in a queue of one waits
- * for ever.
+ * A message is news about work happening now ("the build is green"), and a model reading it six hours
+ * late would act on something that moved on. The cap alone would leave a queue of one waiting forever.
  */
 export const NOTICE_MAX_AGE_MS = 6 * 60 * 60 * 1000;
 const NoticeSchema = z.object({
@@ -109,7 +107,7 @@ export class NoticeStore {
     fresh(notice) {
         return this.now() - notice.createdAt < NOTICE_MAX_AGE_MS;
     }
-    /* The queue of one node, emptied here and on disk both; an empty one leaves no file behind. */
+    /* In memory and on disk both; an empty queue leaves no file behind. */
     async persist(targetId, queue) {
         if (queue.length === 0) {
             await this.queues.remove(targetId);

package/dist/outbox/outbox-worker.js

@@ -80,6 +80,9 @@ export class OutboxWorker {
         const now = this.clock.now();
         const busy = new Set(this.running);
         let nextDue = null;
+        const dueAt = (at) => {
+            nextDue = nextDue === null ? at : Math.min(nextDue, at);
+        };
         for (const entry of this.store.list()) {
             // A waiting entry holds no lane. The resume of a chat must not queue behind a wake that waits for it.
             if (busy.has(entry.target) || this.waiting.has(entry.id)) {
@@ -87,7 +90,7 @@ export class OutboxWorker {
             }
             // Nor does work due at a later time, which nothing owed before it has to wait for.
             if (entry.attempts === 0 && entry.notBefore > now) {
-                nextDue = nextDue === null ? entry.notBefore : Math.min(nextDue, entry.notBefore);
+                dueAt(entry.notBefore);
                 continue;
             }
             const lanes = this.store.lanesOf(entry);
@@ -100,7 +103,7 @@ export class OutboxWorker {
                 continue;
             }
             if (entry.notBefore > now) {
-                nextDue = nextDue === null ? entry.notBefore : Math.min(nextDue, entry.notBefore);
+                dueAt(entry.notBefore);
                 continue;
             }
             void this.run(entry);

package/dist/providers/accounts/service.d.ts

@@ -1,4 +1,5 @@
 import { type AgentKind, type ProviderAccount, type ProviderAccountCreatePayload, type ProviderAccountCreateResult, type ProviderAccountMap, type ProviderAccounts, type ProviderInfo } from '@adecore/agent-contracts';
+import { type CodexClientInfo } from '../../chat/codex-transport.ts';
 import type { AgentSink } from '../../events.ts';
 import type { ChatProvider } from '../provider.ts';
 import { type Env } from './accounts.ts';
@@ -6,7 +7,6 @@ import { type AccountLaunches } from './launch.ts';
 import { type ShadowHomeReport } from './shadow-home.ts';
 import { type AskAccount } from './status.ts';
 import { type AccountsHost, type SecretStore } from './variables.ts';
-import { type CodexClientInfo } from '../../chat/codex-transport.ts';
 export interface ProviderAccountsOptions {
     home: string;
     host?: AccountsHost;
@@ -68,6 +68,7 @@ export declare class ProviderAccountsService implements AccountLaunches {
     create(payload: ProviderAccountCreatePayload): Promise<ProviderAccountCreateResult>;
     watchLogin(id: string): Promise<void>;
     refresh(): Promise<ProviderAccounts>;
+    private folderOf;
     private runWatch;
     private serial;
     private commit;