@adecore/agents 0.38.0 → 0.40.0

package/dist/async.d.ts

@@ -1,2 +1,7 @@
 export declare function wait(ms: number, signal?: AbortSignal): Promise<void>;
+export interface DeadlineTimer {
+    setTimeout(run: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+export declare function withDeadline<T>(promise: Promise<T>, ms: number, message: string, timer?: DeadlineTimer): Promise<T>;
 export declare function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T>;

package/dist/async.js

@@ -1,3 +1,4 @@
+import { asError } from './error-text.js';
 /*
  * 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.
@@ -11,16 +12,23 @@ export function wait(ms, signal) {
         }, { once: true });
     });
 }
+const SYSTEM_TIMER = {
+    setTimeout: (run, ms) => setTimeout(run, ms),
+    clearTimeout: (handle) => clearTimeout(handle)
+};
 /* 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) {
+export function withDeadline(promise, ms, message, timer = SYSTEM_TIMER) {
     return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(message)), ms);
+        const handle = timer.setTimeout(() => reject(new Error(message)), ms);
         promise.then((value) => {
-            clearTimeout(timer);
+            timer.clearTimeout(handle);
             resolve(value);
         }, (e) => {
-            clearTimeout(timer);
-            reject(e instanceof Error ? e : new Error(String(e)));
+            timer.clearTimeout(handle);
+            reject(asError(e));
         });
     });
 }
+export function withTimeout(promise, ms, message) {
+    return withDeadline(promise, ms, message);
+}

package/dist/chat/acp-protocol.js

@@ -1,5 +1,6 @@
 import { isRecord } from '@adecore/agent-contracts';
 import { z } from 'zod';
+import { filledStr } from '../fields.js';
 import { MODE_ORDER } from '../modes.js';
 import { cleanTitle } from '../title-file.js';
 /*
@@ -357,12 +358,9 @@ function withheld(text, afterRefusal) {
 function foldSpace(text) {
     return text.replace(/\s+/g, ' ').trim();
 }
-function str(value) {
-    return typeof value === 'string' && value !== '' ? value : null;
-}
-/* A field of the agent's own input, which no schema promises; the first one that is a non-empty string. */
 // Where agents put the command a call runs; Antigravity names it `CommandLine`.
 const COMMAND_KEYS = ['command', 'cmd', 'CommandLine'];
+/* A field of the agent's own input, which no schema promises; the first one that is a non-empty string. */
 function rawField(raw, ...keys) {
     if (!isRecord(raw)) {
         return null;
@@ -372,7 +370,7 @@ function rawField(raw, ...keys) {
         if (Array.isArray(value) && value.every((part) => typeof part === 'string') && value.length > 0) {
             return value.join(' ');
         }
-        if (str(value) !== null) {
+        if (filledStr(value) !== null) {
             return value;
         }
     }

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

@@ -229,6 +229,7 @@ export declare class ChatCore {
     unqueue(chatId: string, messageId: string): ChatQueuedMessage;
     sendNow(chatId: string, messageId: string): void;
     skills(chatId: string): Promise<ChatSkill[]>;
+    skillsIn(provider: AgentKind, cwd: string): Promise<ChatSkill[]>;
     restart(chatId: string): Promise<void>;
     compact(chatId: string): void;
     clear(chatId: string, force?: boolean): Promise<void>;

package/dist/chat/chat-core.js

@@ -173,7 +173,6 @@ export class ChatCore {
         const folder = this.accounts?.transcriptFolder('claude', info.account) ?? null;
         return folder === null ? '' : join(folder, 'projects');
     }
-    /* Whether a conversation of one account of this CLI can go on under the other. */
     canContinue(kind, from, to) {
         if ((from ?? kind) === (to ?? kind)) {
             return true;
@@ -184,7 +183,6 @@ export class ChatCore {
     requireAccount(kind, account) {
         launchEnv(this.accounts, kind, account, this.env);
     }
-    /* What a person calls an account of this CLI. */
     accountLabel(kind, account) {
         return isDefaultAccountOf(kind, account) || account === undefined ? this.providers.get(kind).name : (this.accounts?.labelOf(account) ?? account);
     }
@@ -421,6 +419,11 @@ export class ChatCore {
      * read leaves its list out rather than the thread.
      */
     async attachWithBookmarks(chatId, clientId, historyLimit, since) {
+        // A client that only watches a chat sends no create, so a chat on disk nobody loaded since the host started is loaded for it.
+        await this.loaded(chatId);
+        if (!this.chats.has(chatId) && (await this.store?.has(chatId)) === true) {
+            await this.create({ chatId });
+        }
         this.require(chatId);
         const unreadable = (what) => (e) => {
             console.error(`The ${what} of chat ${chatId} could not be read:`, errorText(e));
@@ -722,6 +725,10 @@ export class ChatCore {
         const session = this.require(chatId);
         return session.skills(() => this.skillIndex.list(session.info.provider, session.info.cwd));
     }
+    /* What a CLI would run as a skill in a folder before any chat of it exists there, such as for a prompt saved to send later. */
+    skillsIn(provider, cwd) {
+        return this.skillIndex.list(provider, 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);

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

@@ -24,6 +24,7 @@ export interface ProcessTreeKillOptions {
     run?(command: string[]): void;
 }
 export declare function killProcessTree(pid: number, signal: 'SIGTERM' | 'SIGKILL', options?: ProcessTreeKillOptions): void;
+export declare const KILL_GRACE_MS = 2000;
 export declare class StreamTail {
     readonly done: Promise<void>;
     private text;

package/dist/chat/chat-process.js

@@ -77,7 +77,7 @@ function runQuietly([command, ...args]) {
 // After stdin closed, a CLI that is still around is not going to say more.
 const EXIT_GRACE_MS = 3000;
 // What a CLI and everything it started get between the SIGTERM and the SIGKILL.
-const KILL_GRACE_MS = 2000;
+export const KILL_GRACE_MS = 2000;
 // How long a crash note waits for the last of stderr; a process the CLI started may hold the pipe open.
 const STDERR_DRAIN_MS = 250;
 // A pipe nobody reads is buffered in memory for as long as the CLI lives, so stderr is read into this much and no more.

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

@@ -191,6 +191,8 @@ export declare class ChatSession {
         taskIds: string[];
         summaryFor?: string;
         messageFrom?: string[];
+        mentions?: string[];
+        skills?: string[];
     }): string | null;
     resumeSettingChanged(): void;
     takeUpAfterLimit(turnId: string): 'opened' | 'wait' | 'lapsed';

package/dist/chat/chat-session.js

@@ -8,7 +8,7 @@ import { isMainAgentOutput, ThreadProjector } from './projector.js';
 import { readableAssistantText } from './readable-text.js';
 import { ChatThread } from './thread.js';
 import { UiReplies } from './ui-replies.js';
-import { errorText } from '../error-text.js';
+import { asError, errorText } from '../error-text.js';
 import { systemClock } from '../outbox/outbox-worker.js';
 import { cleanTitle } from '../title-file.js';
 // Claude Code names a session about six seconds after its first prompt, and a first turn can run for minutes.
@@ -239,9 +239,7 @@ export class ChatSession {
         this.drainQueue();
         this.emit([this.thread.patchInfo({})]);
     }
-    /*
-     * Internal follow-ups wait for a new turn. User input goes through `sendInput`, which can steer native work.
-     */
+    /* Internal follow-ups wait for a new turn. User input goes through `sendInput`, which can steer native work. */
     send(text, sent = {}) {
         const extras = this.vetted(sent);
         const turnId = newId('turn');
@@ -872,7 +870,8 @@ export class ChatSession {
      * turn carrying what woke it, so a turn it opens cannot itself wake anyone. A caller passes `note`
      * only when its news is not already written in the thread. Checked and opened in one step, so null
      * means a turn (or a shutdown) was in the way. Never through `send`, which would step on a turn
-     * with `origin: 'agent'` and close the wake it just made.
+     * with `origin: 'agent'` and close the wake it just made. `mentions` and `skills` reach a CLI that
+     * expands them itself, as a person's picks in a message do.
      */
     wake(wake) {
         if (this.frozen || this.relocating || this.thread.info.activeTurnId !== null || this.replacementWaits()) {
@@ -906,7 +905,7 @@ export class ChatSession {
         ]);
         this.options.persist();
         this.turnReady = this.checkpoint(turnId);
-        this.submit(turnId, { text: wake.text, preamble, attachments: [], mentions: [], skills: [] });
+        this.submit(turnId, { text: wake.text, preamble, attachments: [], mentions: wake.mentions ?? [], skills: wake.skills ?? [] });
         return turnId;
     }
     /* The host's switch or this chat's own changed: a limit still ahead is owed a resume now, or what was owed lapses. */
@@ -1523,7 +1522,7 @@ export class ChatSession {
         }
         catch (error) {
             // What the host prepares for a launch (its folders, its instructions) can throw too; the turn already opened, so it fails.
-            backend = Promise.reject(error instanceof Error ? error : new Error(String(error)));
+            backend = Promise.reject(asError(error));
         }
         const generation = this.generation;
         void Promise.all([backend, this.turnReady, this.options.save?.()])
@@ -1626,7 +1625,7 @@ export class ChatSession {
             this.launchedAccount = this.thread.info.account;
         }
         catch (error) {
-            return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+            return Promise.reject(asError(error));
         }
         this.generation = nextGeneration();
         const generation = this.generation;
@@ -1668,7 +1667,7 @@ export class ChatSession {
             });
         }
         catch (error) {
-            return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+            return Promise.reject(asError(error));
         }
         const backend = made.backend;
         this.backend = backend;
@@ -1680,7 +1679,7 @@ export class ChatSession {
         }
         catch (error) {
             // A spawn that throws on the spot (no such executable) is a start that failed like any other.
-            started = Promise.reject(error instanceof Error ? error : new Error(String(error)));
+            started = Promise.reject(asError(error));
         }
         this.starting = started
             .then(() => backend)

package/dist/chat/claude-protocol.js

@@ -1,12 +1,7 @@
 import { isRecord } from '@adecore/agent-contracts';
 import { readClaudeEvent } from '../usage/limits/normalize.js';
+import { num, str } from '../fields.js';
 import { claudeRuntimeMode } from '../providers/claude.js';
-function str(value) {
-    return typeof value === 'string' ? value : null;
-}
-function num(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
-}
 // A tool result is a string or a list of content blocks; only the text is worth showing.
 function resultText(content) {
     if (typeof content === 'string') {

package/dist/chat/claude-transcript.js

@@ -2,14 +2,12 @@ import { existsSync } from 'node:fs';
 import { readdir, readFile, stat } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { isRecord } from '@adecore/agent-contracts';
+import { filledStr as str } from '../fields.js';
 import { fileExists } from '../fs.js';
 import { readLines } from '../title-file.js';
 import { ClaudeProtocol } from './claude-protocol.js';
 import { readingThread, settledReading } from './subagent-projection.js';
 const CHUNK_BYTES = 4 * 1024 * 1024;
-function str(value) {
-    return typeof value === 'string' && value !== '' ? value : null;
-}
 /* The words of a user line that somebody said, or null for a line that carries tool results. */
 export function spokenText(content) {
     if (typeof content === 'string') {

package/dist/chat/codex-protocol.js

@@ -2,13 +2,8 @@ import { generatedImage } from './generated-image.js';
 import { isRecord } from '@adecore/agent-contracts';
 import { readCodexLimits } from '../usage/limits/normalize.js';
 import { codexRuntimeMode } from '../providers/codex.js';
+import { num, str } from '../fields.js';
 import { cleanTitle } from '../title-file.js';
-function str(value) {
-    return typeof value === 'string' ? value : null;
-}
-function num(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
-}
 const GOAL_STATUSES = {
     active: 'active',
     paused: 'paused',

package/dist/chat/projector.js

@@ -1,5 +1,6 @@
 import { isRecord } from '@adecore/agent-contracts';
 import { clipText } from '@adecore/agent-contracts/text';
+import { str } from '../fields.js';
 import { estimateContextBreakdown } from './context-breakdown.js';
 /*
  * Content of the main conversation, which the CLI only writes inside a turn it closes with a `result`.
@@ -26,9 +27,6 @@ export function isMainAgentOutput(event) {
 function startsAgentTurn(event) {
     return isMainAgentOutput(event) || ((event.type === 'approval.requested' || event.type === 'question.requested') && event.background !== true);
 }
-function str(value) {
-    return typeof value === 'string' ? value : null;
-}
 /* A markdown code block around text that may hold backticks of its own. */
 function fenced(text) {
     const longest = Math.max(0, ...(text.match(/`+/g) ?? []).map((run) => run.length));

package/dist/chat/request-summary.js

@@ -1,7 +1,5 @@
 import { isRecord, CHAT_REQUEST_LIMITS } from '@adecore/agent-contracts';
-function str(value) {
-    return typeof value === 'string' ? value : null;
-}
+import { str } from '../fields.js';
 // The keys a tool's input names its subject under, in the order a person would look for one.
 const SUBJECT_KEYS = ['file_path', 'notebook_path', 'path', 'url', 'query', 'pattern', 'skill', 'description'];
 /* Cuts text at `max` code units, never between the halves of a surrogate pair. */

package/dist/coded-error.js

@@ -1,8 +1,4 @@
-/*
- * The shape every failure on the wire has: a code a client can branch on and a message a person reads.
- * A domain gives it a union of its own codes, so a typo in a code is a compile error instead of a
- * string the other end never matches.
- */
+/* The shape every failure on the wire has: a code a client can branch on and a message a person reads. */
 export class CodedError extends Error {
     code;
     /* What the actor can do instead. Only a refusal fills this; the rest carry an empty list. */

package/dist/context/argv.js

@@ -2,8 +2,7 @@
  * Splits the words after a verb into positionals, `--flag value` pairs (`--flag=value` too, for a
  * value that itself starts with `--`) and the switches the verb declared. Anything not declared a
  * switch takes a value, so a flag that lost its argument is refused instead of swallowing the next
- * word, and a flag given twice is refused rather than one of the two silently winning. A name that is
- * both a switch and a flag is on when written bare and takes a value only after `=` (`--state=full`).
+ * word. A name that is both a switch and a flag takes a value only after `=` (`--state=full`).
  */
 export function parseArgv(argv, known, switches = []) {
     const positionals = [];

package/dist/context/verb.js

@@ -57,11 +57,9 @@ export function createVerbRegistry(options) {
      * points at these, so an agent never gets a silent nothing from a dry run that was never dry.
      */
     const dryRunVerbs = [];
-    /* What a refusal over arguments points at; for an action `name` is both words, which is what `help` takes. */
-    const usageLinesOf = (name, usage) => [`usage\t${name}\t${usage}`, `detail\t${cli} help ${name}`];
     /* One set of arguments parsed and run. `name` is what a refusal calls it, so `view new` refuses under both its words. */
     const runArgs = async (name, usage, spec, argv, call) => {
-        const usageLines = usageLinesOf(name, usage);
+        const usageLines = [`usage\t${name}\t${usage}`, `detail\t${cli} help ${name}`];
         const { values, switches } = flagsOf(spec);
         const parsed = parseArgv(argv, values, switches);
         if (!parsed.ok) {

package/dist/error-text.d.ts

@@ -1,5 +1,6 @@
 /** The message of an error, or its whole stack with `debug` set. */
 export declare function describeError(error: unknown, debug: boolean): string;
+export declare function asError(thrown: unknown): Error;
 export declare function setErrorStacks(on: boolean): void;
 /** `describeError` as the host set it, for a log line or a note. */
 export declare function errorText(error: unknown): string;

package/dist/error-text.js

@@ -13,6 +13,10 @@ export function describeError(error, debug) {
     }
     return error.message === '' ? error.name : error.message;
 }
+/* What was thrown, as an Error a rejection can carry. */
+export function asError(thrown) {
+    return thrown instanceof Error ? thrown : new Error(String(thrown));
+}
 // The host decides once whether a stack is worth showing; the package reads no variable of its own.
 let showStacks = false;
 export function setErrorStacks(on) {

package/dist/fields.d.ts

@@ -0,0 +1,3 @@
+export declare function str(value: unknown): string | null;
+export declare function num(value: unknown): number;
+export declare function filledStr(value: unknown): string | null;

package/dist/fields.js

@@ -0,0 +1,12 @@
+/* A field of a frame or a file that no schema promises a string in. */
+export function str(value) {
+    return typeof value === 'string' ? value : null;
+}
+/* A count of a frame, zero for anything that is not a finite number. */
+export function num(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+/* The same, with an empty string read as nothing said. */
+export function filledStr(value) {
+    return typeof value === 'string' && value !== '' ? value : null;
+}

package/dist/fs.d.ts

@@ -1,3 +1,4 @@
+export declare function hasErrorCode(e: unknown, ...codes: string[]): boolean;
 export declare function tempNameFor(target: string): string;
 export interface WriteAtomicOptions {
     durable?: boolean;

package/dist/fs.js

@@ -1,6 +1,7 @@
 import { renameSync, writeFileSync } from 'node:fs';
 import { open, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
+import { wait } from './async.js';
 // Windows can refuse a rename while a watcher or an indexer holds the target; a few short retries cover it.
 const RENAME_RETRIES = 5;
 const RENAME_RETRY_MS = 40;
@@ -8,8 +9,11 @@ const RENAME_RETRY_MS = 40;
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
+export function hasErrorCode(e, ...codes) {
+    return typeof e === 'object' && e !== null && 'code' in e && codes.includes(e.code);
+}
 function isTransient(e) {
-    return typeof e === 'object' && e !== null && 'code' in e && (e.code === 'EPERM' || e.code === 'EBUSY' || e.code === 'EACCES');
+    return hasErrorCode(e, 'EPERM', 'EBUSY', 'EACCES');
 }
 // Two writes of the same file in flight at once (a fire-and-forget save next to an awaited one) must not share a temp name.
 let nextTemp = 0;
@@ -62,7 +66,7 @@ export async function writeAtomic(target, content, mode = 0o600, options = {}) {
             if (!isTransient(e) || attempt >= RENAME_RETRIES) {
                 throw e;
             }
-            await new Promise((resolve) => setTimeout(resolve, RENAME_RETRY_MS));
+            await wait(RENAME_RETRY_MS);
         }
     }
     if (options.durable) {
@@ -94,7 +98,7 @@ export function writeAtomicSync(target, content, mode = 0o600) {
     replaceSync(temp, target);
 }
 export function isNotFound(e) {
-    return typeof e === 'object' && e !== null && 'code' in e && e.code === 'ENOENT';
+    return hasErrorCode(e, 'ENOENT');
 }
 // Bun on Windows fails a forced rm with EFAULT while another delete of the same file is pending; it goes either way.
 export async function removeFile(path, remove = rm) {
@@ -102,7 +106,7 @@ export async function removeFile(path, remove = rm) {
         await remove(path, { force: true });
     }
     catch (e) {
-        if (!(typeof e === 'object' && e !== null && 'code' in e && e.code === 'EFAULT')) {
+        if (!hasErrorCode(e, 'EFAULT')) {
             throw e;
         }
     }

package/dist/lineage.js

@@ -51,9 +51,10 @@ export class AgentLineageStore {
     descendants(nodeId) {
         const found = [];
         const seen = new Set([nodeId]);
+        const entries = this.opened.all();
         for (let i = -1; i < found.length; i++) {
             const parent = i === -1 ? nodeId : found[i];
-            for (const entry of this.opened.all()) {
+            for (const entry of entries) {
                 if (entry.openedBy === parent && openedByAgent(entry) && entry.endedAt === undefined && !seen.has(entry.nodeId)) {
                     seen.add(entry.nodeId);
                     found.push(entry.nodeId);
@@ -89,7 +90,8 @@ export class AgentLineageStore {
     }
     /* The nodes of this project whose opener it no longer places, and that no cascade ended yet. */
     orphans(projectId, ids) {
-        return [...this.opened.all()]
+        return this.opened
+            .all()
             .filter((entry) => entry.projectId === projectId && openedByAgent(entry) && entry.endedAt === undefined && ids.has(entry.nodeId) && !ids.has(entry.openedBy))
             .map((entry) => ({ nodeId: entry.nodeId, openedBy: entry.openedBy }));
     }
@@ -102,7 +104,7 @@ export class AgentLineageStore {
     peerOf(nodeId) {
         return this.opened.get(nodeId)?.peer ?? null;
     }
-    /* How deep a node sits. A node nobody wrote down is one a person made, which is where a chain starts. */
+    /* A node nobody wrote down is one a person made, which is where a chain starts. */
     depthOf(nodeId) {
         return this.opened.get(nodeId)?.depth ?? 0;
     }
@@ -132,11 +134,15 @@ export class AgentLineageStore {
         return entry?.relation === 'fork' ? entry.openedBy : null;
     }
     forksOf(nodeId) {
-        return [...this.opened.all()].filter((entry) => entry.relation === 'fork' && entry.openedBy === nodeId).map((entry) => entry.nodeId);
+        return this.opened
+            .all()
+            .filter((entry) => entry.relation === 'fork' && entry.openedBy === nodeId)
+            .map((entry) => entry.nodeId);
     }
     /* The forks of this project whose node is gone, read before `prune` forgets them. */
     forksLeaving(projectId, ids) {
-        return [...this.opened.all()]
+        return this.opened
+            .all()
             .filter((entry) => entry.projectId === projectId && entry.relation === 'fork' && !ids.has(entry.nodeId))
             .map((entry) => entry.nodeId);
     }

package/dist/messages/notice-store.js

@@ -28,10 +28,9 @@ const NoticeSchema = z.object({
 /* A queue waits in the file of the node it is for, so the first message in it names that node. */
 const FileSchema = z.object({ notices: z.array(NoticeSchema).min(1) });
 /*
- * The messages waiting for each node, held until that node's agent has a moment to hear them, under
- * `<dataDir>/notices`. On disk because the receiver may well be a node nobody has mounted yet, and a
- * host that restarts must not lose what was left for it. Delivered once, whichever channel gets there
- * first.
+ * The messages waiting for each node, held until that node's agent has a moment to hear them. On disk
+ * because the receiver may well be a node nobody has mounted yet, and a host that restarts must not
+ * lose what was left for it.
  */
 export class NoticeStore {
     dir;

package/dist/providers/accounts/acp-account.js

@@ -1,31 +1,14 @@
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { withDeadline } from '../../async.js';
 import { DEFAULT_ACP_CLIENT } from '../../chat/acp-backend.js';
 import { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, parseInitialize, parseSessionInfo, sessionIdOf, sessionUpdateOf } from '../../chat/acp-protocol.js';
 import { JsonRpcError, JsonRpcTransport } from '../../chat/json-rpc-transport.js';
+import { definedEnv } from './launch.js';
 import { ASK_TIMEOUT_MS } from './status.js';
 const SIGNED_OUT = { signedIn: false, email: null, plan: null, organization: null };
 const SIGNED_IN = { signedIn: true, email: null, plan: null, organization: null };
-const REAL_TIMER = {
-    setTimeout: (run, ms) => setTimeout(run, ms),
-    clearTimeout: (handle) => clearTimeout(handle)
-};
-function definedEnv(env) {
-    return Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== undefined));
-}
-function withDeadline(work, ms, timer, message) {
-    return new Promise((resolve, reject) => {
-        const handle = timer.setTimeout(() => reject(new Error(message)), ms);
-        work.then((value) => {
-            timer.clearTimeout(handle);
-            resolve(value);
-        }, (e) => {
-            timer.clearTimeout(handle);
-            reject(e instanceof Error ? e : new Error(String(e)));
-        });
-    });
-}
 /*
  * Asks an ACP agent whether the account's environment is signed in: a session it opens means yes, "authentication
  * required" means no. ACP has no request that says who, so a reading carries no email or plan. The session is opened
@@ -102,7 +85,7 @@ export async function askAcpAccount(probe) {
             }
             return SIGNED_IN;
         };
-        return await withDeadline(reading(), probe.timeoutMs ?? ASK_TIMEOUT_MS, probe.timer ?? REAL_TIMER, `${probe.name} did not answer in time`);
+        return await withDeadline(reading(), probe.timeoutMs ?? ASK_TIMEOUT_MS, `${probe.name} did not answer in time`, probe.timer);
     }
     finally {
         await transport?.dispose();

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

@@ -42,7 +42,7 @@ export declare class ProviderAccountsService implements AccountLaunches {
     private readonly now;
     private readonly sleep;
     private readonly watches;
-    private writes;
+    private readonly writes;
     private readonly sinks;
     private readonly listeners;
     private readonly launches;
@@ -74,7 +74,6 @@ export declare class ProviderAccountsService implements AccountLaunches {
     private runWatch;
     private kinds;
     private accountProviders;
-    private serial;
     private commit;
     private planSecrets;
     private requireSecrets;

package/dist/providers/accounts/service.js

@@ -5,6 +5,7 @@ import { KNOWN_AGENT_KINDS } from '@adecore/agent-contracts';
 import { DEFAULT_CODEX_CLIENT } from '../../chat/codex-transport.js';
 import { ClientSinks } from '../../client-sinks.js';
 import { errorText } from '../../error-text.js';
+import { Serializer } from '../../serializer.js';
 import { accountEnv, accountFolder, canContinue, defaultFolder, expandHome, isDefaultAccount, isOfferedKind, transcriptFolder } from './accounts.js';
 import { AccountError, isDefaultAccountOf } from './launch.js';
 import { prepareShadowHome } from './shadow-home.js';
@@ -72,7 +73,8 @@ export class ProviderAccountsService {
     now;
     sleep;
     watches = new Map();
-    writes = Promise.resolve();
+    // One change of the file at a time: a create and a save both read what the other just wrote.
+    writes = new Serializer();
     sinks = new ClientSinks();
     listeners = new Set();
     // When a CLI last started under each account, by id; kept in memory, so a restart forgets it.
@@ -228,14 +230,14 @@ export class ProviderAccountsService {
     }
     /* Answers at once; an account that changed reads `checking` until its CLI answered, which arrives as `accounts.changed`. */
     save(accounts) {
-        return this.serial(() => this.commit(accounts, this.folderExists));
+        return this.writes.run(() => this.commit(accounts, this.folderExists));
     }
     /*
      * An account in a folder of its own under `<home>/accounts`, signed in by nobody yet. A
      * Codex account is a shadow home over the CLI's own folder, so its threads go on under the other.
      */
     create(payload) {
-        return this.serial(async () => {
+        return this.writes.run(async () => {
             const { kind, label, color } = payload;
             const provider = this.providers.get(kind);
             if (provider.home === undefined) {
@@ -303,12 +305,6 @@ export class ProviderAccountsService {
     accountProviders() {
         return { kinds: this.kinds(), get: (kind) => this.providers.get(kind) };
     }
-    /* One change of the file at a time: a create and a save both read what the other just wrote. */
-    serial(work) {
-        const next = this.writes.then(work);
-        this.writes = next.catch(() => undefined);
-        return next;
-    }
     async commit(accounts, isDirectory) {
         const stored = acceptAccounts(accounts, this.stored, this.accountProviders(), this.env, isDirectory, this.host);
         const { writes, removals } = this.planSecrets(stored);

package/dist/providers/accounts/status.js

@@ -1,12 +1,10 @@
 import { isRecord } from '@adecore/agent-contracts';
 import { withTimeout } from '../../async.js';
+import { filledStr as text } from '../../fields.js';
 import { CodexTransport } from '../../chat/codex-transport.js';
 import { runProcess } from '../../run-process.js';
 /* A CLI that has not said who is signed in by now is not going to; the next pass asks again. */
 export const ASK_TIMEOUT_MS = 20_000;
-function text(value) {
-    return typeof value === 'string' && value !== '' ? value : null;
-}
 /* `claude auth status --json`, as Claude Code 2.1.282 prints it: `loggedIn`, `email`, `orgName`, `subscriptionType`. */
 export function readClaudeAuthStatus(output) {
     let status;

package/dist/providers/acp-agent-state.js

@@ -79,9 +79,7 @@ export class AcpAgentState {
         if (!this.options.adoptModels || info.models === null) {
             return;
         }
-        const adopted = { defaultModel: info.models.current, models: adoptableModels(info), options: effortOption(info) };
-        const changed = this.adopt(adopted);
-        this.settle(changed);
+        this.settle(this.adopt({ defaultModel: info.models.current, models: adoptableModels(info), options: effortOption(info) }));
     }
     commandsListed(commands) {
         const names = [...new Set(commands)].sort();

package/dist/providers/claude.js

@@ -80,7 +80,6 @@ export function claudeArgs(launch) {
 export function claudeEnv(selection) {
     return selection.options.contextWindow === '200k' ? { CLAUDE_CODE_AUTO_COMPACT_WINDOW: '200000' } : {};
 }
-// What the CLI can do, as far as a client has to know.
 export const CLAUDE_CAPABILITIES = {
     chat: true,
     terminal: true,