@adecore/agents 0.21.1 → 0.21.2

package/dist/providers/accounts/service.js

@@ -2,6 +2,7 @@ import { existsSync, statSync } from 'node:fs';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { AgentKindSchema } 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 { accountEnv, accountFolder, canContinue, defaultFolder, expandHome, isDefaultAccount, isKnownKind, transcriptFolder } from './accounts.js';
@@ -10,7 +11,6 @@ import { prepareShadowHome } from './shadow-home.js';
 import { askAccountAs } from './status.js';
 import { acceptAccounts, accountsPath, InvalidAccountError, readAccounts, wireAccounts, writeAccounts } from './store.js';
 import { DEFAULT_ACCOUNTS_HOST, platformSecrets, secretKey, SecretsUnavailableError } from './variables.js';
-import { DEFAULT_CODEX_CLIENT } from '../../chat/codex-transport.js';
 /* Who is signed in changes by hand and rarely; often enough to notice, rarely enough not to start CLIs all day. */
 const CHECK_INTERVAL_MS = 15 * 60_000;
 const MAX_BACKOFF_MS = 60 * 60_000;
@@ -161,20 +161,10 @@ export class ProviderAccountsService {
         return accountEnv(key, account, provider, baseEnv, variables(account));
     }
     transcriptFolder(kind, id) {
-        const key = id ?? kind;
-        const account = this.accounts[key];
-        if (account === undefined || account.kind !== kind) {
-            return null;
-        }
-        return transcriptFolder(key, account, this.providers.get(kind), this.env);
+        return this.folderOf(kind, id, transcriptFolder);
     }
     homeFolder(kind, id) {
-        const key = id ?? kind;
-        const account = this.accounts[key];
-        if (account === undefined || account.kind !== kind) {
-            return null;
-        }
-        return accountFolder(key, account, this.providers.get(kind), this.env);
+        return this.folderOf(kind, id, accountFolder);
     }
     canContinue(kind, from, to) {
         const fromId = from ?? kind;
@@ -268,6 +258,14 @@ export class ProviderAccountsService {
         await this.queue(true);
         return this.snapshot();
     }
+    folderOf(kind, id, folder) {
+        const key = id ?? kind;
+        const account = this.accounts[key];
+        if (account === undefined || account.kind !== kind) {
+            return null;
+        }
+        return folder(key, account, this.providers.get(kind), this.env);
+    }
     async runWatch(id, watch) {
         while (this.now() < watch.deadline) {
             await this.sleep(LOGIN_POLL_MS);

package/dist/providers/claude.js

@@ -25,7 +25,6 @@ export function claudeRuntimeMode(mode) {
     }
     return Object.keys(PERMISSION_MODE).find((key) => PERMISSION_MODE[key] === mode);
 }
-/* The argument list for one Claude Code chat process. */
 export function claudeArgs(launch) {
     // The `=` form matters, since the flag is variadic and would swallow a prompt argument after it (measured on Claude Code 2.1.274).
     const args = [

package/dist/providers/detect.js

@@ -1,13 +1,5 @@
 import { spawnChatProcess } from '../chat/chat-process.js';
-function definedOnly(env) {
-    const defined = {};
-    for (const [key, value] of Object.entries(env)) {
-        if (value !== undefined) {
-            defined[key] = value;
-        }
-    }
-    return defined;
-}
+import { definedEnv } from './accounts/launch.js';
 /* Asks a CLI for its version; a missing binary is a plain "not installed", never an error. */
 export async function detectCli(command, env = process.env, spawn = spawnChatProcess) {
     try {
@@ -15,7 +7,7 @@ export async function detectCli(command, env = process.env, spawn = spawnChatPro
         const code = new Promise((resolve) => {
             exited = resolve;
         });
-        const proc = spawn({ command: [command, '--version'], cwd: process.cwd(), env: definedOnly(env), onExit: (exitCode) => exited(exitCode) });
+        const proc = spawn({ command: [command, '--version'], cwd: process.cwd(), env: definedEnv(env), onExit: (exitCode) => exited(exitCode) });
         proc.stdin.end();
         const output = await new Response(proc.stdout).text();
         if ((await code) !== 0) {

package/dist/record-directory.js

@@ -100,7 +100,6 @@ export class RecordDirectory {
         this.records.delete(id);
         return rm(this.pathOf(id), { force: true });
     }
-    /* Drops every record the predicate says is gone. */
     async prune(drop) {
         for (const record of this.all()) {
             if (drop(record)) {

package/dist/tasks/task-coordinator.d.ts

@@ -40,6 +40,7 @@ export declare class TaskCoordinator {
     private failed;
     private answers;
     private turnEnded;
+    private settleGone;
     private heldInBackground;
     private pauseFor;
     private turnStarted;

package/dist/tasks/task-coordinator.js

@@ -71,7 +71,6 @@ export class TaskCoordinator {
         }
         await this.deps.tasks.settled();
     }
-    /* For `chats.observe()`. */
     chatEvent(event) {
         if (this.stopped || event.event !== 'chat.event') {
             return;
@@ -201,38 +200,7 @@ export class TaskCoordinator {
                 return;
             }
             if (after === 'gone') {
-                if (task.background.itemIds.length === 0 && this.deps.limit.owed(task.id)) {
-                    return;
-                }
-                const lost = task.background.itemIds.filter((id) => {
-                    const item = items.find((item) => item.id === id);
-                    return !item || (item.kind === 'subagent' ? item.status !== 'done' : item.kind !== 'tool' || item.state !== 'done');
-                });
-                if (lost.length > 0 || task.background.commands.length > 0) {
-                    this.settle(task, 'failed', {
-                        text: `The agent ended before its background work completed: ${[
-                            ...lost.map((id) => {
-                                const row = items.find((item) => item.id === id);
-                                return row?.kind === 'subagent' ? row.description || row.toolUseId : row?.kind === 'tool' ? row.name : id;
-                            }),
-                            ...task.background.commands
-                        ].join(', ')}. This work will not send a result.`,
-                        source: 'exit',
-                        at: this.deps.now()
-                    });
-                }
-                else {
-                    const reports = task.background.itemIds.flatMap((id) => {
-                        const row = items.find((item) => item.id === id);
-                        const report = row?.kind === 'subagent' ? row.result : row?.kind === 'tool' ? row.output : null;
-                        return report ? [report] : [];
-                    });
-                    this.settle(task, 'done', {
-                        text: reports.join('\n\n') || resultOfTurn(turn, items, this.deps.now()).result.text,
-                        source: 'turn',
-                        at: this.deps.now()
-                    });
-                }
+                this.settleGone(task, task.background, turn, items);
                 return;
             }
         }
@@ -243,6 +211,38 @@ export class TaskCoordinator {
         const { status, result } = resultOfTurn(turn, items, this.deps.now());
         this.settle(task, status, result);
     }
+    /* The child's process went after its turn was held for background work; what that work left decides the task. */
+    settleGone(task, background, turn, items) {
+        if (background.itemIds.length === 0 && this.deps.limit.owed(task.id)) {
+            return;
+        }
+        const lost = background.itemIds.filter((id) => {
+            const item = items.find((item) => item.id === id);
+            return !item || (item.kind === 'subagent' ? item.status !== 'done' : item.kind !== 'tool' || item.state !== 'done');
+        });
+        if (lost.length > 0 || background.commands.length > 0) {
+            const names = lost.map((id) => {
+                const row = items.find((item) => item.id === id);
+                return row?.kind === 'subagent' ? row.description || row.toolUseId : row?.kind === 'tool' ? row.name : id;
+            });
+            this.settle(task, 'failed', {
+                text: `The agent ended before its background work completed: ${[...names, ...background.commands].join(', ')}. This work will not send a result.`,
+                source: 'exit',
+                at: this.deps.now()
+            });
+            return;
+        }
+        const reports = background.itemIds.flatMap((id) => {
+            const row = items.find((item) => item.id === id);
+            const report = row?.kind === 'subagent' ? row.result : row?.kind === 'tool' ? row.output : null;
+            return report ? [report] : [];
+        });
+        this.settle(task, 'done', {
+            text: reports.join('\n\n') || resultOfTurn(turn, items, this.deps.now()).result.text,
+            source: 'turn',
+            at: this.deps.now()
+        });
+    }
     /*
      * Whether work in the background keeps this task open past the turn. Commands and monitors alone hold
      * it only until the limit, owed from the moment they are all that is left; a subagent or a workflow
@@ -297,7 +297,7 @@ export class TaskCoordinator {
         if (!task || items === null || this.delegating(chatId)) {
             return;
         }
-        const last = [...items].reverse().find((item) => item.kind === 'turn');
+        const last = items.findLast((item) => item.kind === 'turn');
         if (last && last.state !== 'running' && last.createdAt >= task.createdAt) {
             this.turnEnded(chatId, last);
         }

package/dist/tasks/task-store.js

@@ -80,7 +80,7 @@ export class TaskStore {
         return this.sorted().filter((task) => task.projectId === projectId);
     }
     /*
-     * Ends an open task with its result; false when it was not open any more, which is how the first of
+     * Ends an open task with its result; null when it was not open any more, which is how the first of
      * `done`, the end of a turn and an exit wins. A cancelled task wakes nobody.
      */
     async settle(id, status, result, now) {

package/dist/tasks/task-work.js

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export const BackgroundLimitWorkSchema = z.object({
     kind: z.literal('background-limit'),
-    // The target is the child; the task its background commands hold open, and what they were when the limit started, for a child whose process went since.
-    // `restarted` marks an entry an earlier run of the host owed, whose commands went down with it.
+    // The target is the child. `commands` are what held its task open when the limit started, for a child whose
+    // process went since; `restarted` marks an entry an earlier run of the host owed, whose commands went down with it.
     payload: z.object({ taskId: z.string().min(1), commands: z.array(z.string()), restarted: z.literal(true).optional() })
 });
 export const WakeParentWorkSchema = z.object({

package/dist/tasks/waiting-child.js

@@ -51,7 +51,6 @@ export class WaitingObserver {
     stop() {
         this.stopped = true;
     }
-    /* For `chats.observe()`. */
     chatEvent(event) {
         if (this.stopped || event.event !== 'chat.event') {
             return;
@@ -71,13 +70,16 @@ export class WaitingObserver {
             .catch((e) => (this.deps.log ?? console.error)(`Owing a note about ${chatId} failed: ${errorText(e)}`));
     }
 }
+function oneLine(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
 function quoted(text) {
-    return JSON.stringify(text.replace(/\s+/g, ' ').trim());
+    return JSON.stringify(oneLine(text));
 }
 /* The one line a note shows before "Show more": a question longer than that is read in the node. */
 const NOTE_QUESTION_LENGTH = 200;
 function quotedShort(text) {
-    const line = text.replace(/\s+/g, ' ').trim();
+    const line = oneLine(text);
     return JSON.stringify(line.length > NOTE_QUESTION_LENGTH ? `${clipText(line, NOTE_QUESTION_LENGTH - 1)}…` : line);
 }
 /* One question as the parent's CLI reads it, with the choices it may pick from. */

package/dist/tasks/wake-parent.js

@@ -43,6 +43,19 @@ export function wakeLabel(tasks) {
 export function wakeNote(tasks) {
     return `Woken by ${tasks.length} finished ${tasks.length === 1 ? 'task' : 'tasks'}`;
 }
+/* An unacknowledged attempt waits for a person's next turn, rather than retrying on every chat event. */
+function deliveryBlocked(items, tasks) {
+    return items.some((item, index) => item.kind === 'turn' &&
+        item.deliveryPending &&
+        item.taskIds?.some((id) => tasks.some((task) => task.id === id)) &&
+        (item.state === 'running' || !items.slice(index + 1).some((later) => later.kind === 'turn' && later.origin !== 'agent')));
+}
+function deliveryPending(items, tasks) {
+    return tasks.some((task) => {
+        const turn = items.findLast((item) => item.kind === 'turn' && item.taskIds?.includes(task.id));
+        return turn?.kind === 'turn' && turn.deliveryPending;
+    });
+}
 /*
  * CLI acceptance lives in the saved turn before the task store consumes its result, so a restart
  * between those writes can finish delivery without opening another turn.
@@ -75,12 +88,7 @@ export function wakeParentHandler(deps) {
         if (tasks.length === 0) {
             return held();
         }
-        // An unacknowledged attempt waits for a person's next turn, rather than retrying on every chat event.
-        const blocked = items.some((item, index) => item.kind === 'turn' &&
-            item.deliveryPending &&
-            item.taskIds?.some((id) => tasks.some((task) => task.id === id)) &&
-            (item.state === 'running' || !items.slice(index + 1).some((later) => later.kind === 'turn' && later.origin !== 'agent')));
-        if (blocked) {
+        if (deliveryBlocked(items, tasks)) {
             return 'wait';
         }
         const teamsOut = deps.tasks.openBatches(parentId).length;
@@ -93,10 +101,7 @@ export function wakeParentHandler(deps) {
             return 'wait';
         }
         await chat.persist?.();
-        if (tasks.some((task) => {
-            const turn = chat.items().findLast((item) => item.kind === 'turn' && item.taskIds?.includes(task.id));
-            return turn?.kind === 'turn' && turn.deliveryPending;
-        })) {
+        if (deliveryPending(chat.items(), tasks)) {
             return 'wait';
         }
         await deps.tasks.markWoken(tasks.map((task) => task.id));

package/dist/tasks/wiring.js

@@ -1,6 +1,7 @@
 import { reportsOnBackgroundWork } from '../chat/background-work.js';
 import { chatOpener, loadChat } from '../chat/wake-chat.js';
 import { errorText } from '../error-text.js';
+import { chatNoticeTargets } from '../messages/deliver-notice.js';
 import { backgroundLimitHandler, backgroundLimits } from './background-limit.js';
 import { giveTaskHandler } from './give-task.js';
 import { TaskCoordinator } from './task-coordinator.js';
@@ -16,6 +17,7 @@ export function wireTasks(deps) {
     const { chats, outbox } = deps;
     const enqueue = (projectId, target, work, notBefore) => outbox.enqueue(projectId, target, work, notBefore);
     const limit = backgroundLimits(outbox);
+    const owesGiveTask = (taskId) => outbox.list().some((entry) => isGiveTask(entry) && entry.payload.taskId === taskId);
     const coordinator = new TaskCoordinator({
         tasks: deps.tasks,
         now,
@@ -23,7 +25,7 @@ export function wireTasks(deps) {
         placed: (nodeId) => deps.placed(nodeId),
         loading: (chatId) => chats.isLoading(chatId),
         // Until the turn that carries a task ran, no turn of the child is its answer.
-        owedTurn: (taskId) => outbox.list().some((entry) => isGiveTask(entry) && entry.payload.taskId === taskId),
+        owedTurn: owesGiveTask,
         oweWake: (task) => oweWake({ enqueue }, task),
         alert: (nodeId, title, body) => deps.alert(nodeId, title, body),
         ...(deps.retryAt ? { retryAt: deps.retryAt } : {}),
@@ -58,38 +60,38 @@ export function wireTasks(deps) {
         }
     });
     const chatFor = chatOpener({ chats, placed: deps.placed });
+    const targets = chatNoticeTargets(chats);
+    /* Owes again what an earlier run left of an open task, and lets its child's last turn settle it. */
+    const recoverOpen = async (task) => {
+        if (task.requiresTaskTurn === true && deps.placed(task.childId) && !owesGiveTask(task.id)) {
+            await enqueue(task.projectId, task.childId, { kind: 'give-task', payload: { taskId: task.id } });
+        }
+        const stored = await chats.storedBackground(task.childId);
+        const storedWork = stored.items.length > 0 || stored.commands.length > 0;
+        if (!deps.placed(task.childId) || (task.background === undefined && task.requiresTaskTurn !== true && !storedWork)) {
+            return;
+        }
+        if (task.background === undefined && stored.turnId !== null && storedWork) {
+            await deps.tasks.holdBackground(task.id, {
+                turnId: stored.turnId,
+                itemIds: stored.items.map((item) => item.id),
+                commands: stored.commands
+            });
+        }
+        const chat = await loadChat({ chats, placed: deps.placed }, task.childId);
+        if (chat && chat.info.activeTurnId === null) {
+            const last = chat.thread.list().findLast((item) => item.kind === 'turn');
+            if (last?.kind === 'turn') {
+                coordinator.chatEvent({ event: 'chat.event', payload: { chatId: task.childId, event: { type: 'item', item: last } } });
+            }
+        }
+    };
     return {
         coordinator,
         recover: async () => {
             for (const task of deps.tasks.all()) {
-                if (task.status === 'open' && task.requiresTaskTurn === true && deps.placed(task.childId)) {
-                    if (!outbox.list().some((entry) => isGiveTask(entry) && entry.payload.taskId === task.id)) {
-                        await enqueue(task.projectId, task.childId, { kind: 'give-task', payload: { taskId: task.id } });
-                    }
-                }
-                const storedBackground = task.status === 'open' ? await chats.storedBackground(task.childId) : { turnId: null, items: [], commands: [] };
-                if (task.status === 'open' &&
-                    deps.placed(task.childId) &&
-                    (task.background !== undefined ||
-                        task.requiresTaskTurn === true ||
-                        storedBackground.items.length > 0 ||
-                        storedBackground.commands.length > 0)) {
-                    if (task.background === undefined &&
-                        storedBackground.turnId !== null &&
-                        (storedBackground.items.length > 0 || storedBackground.commands.length > 0)) {
-                        await deps.tasks.holdBackground(task.id, {
-                            turnId: storedBackground.turnId,
-                            itemIds: storedBackground.items.map((item) => item.id),
-                            commands: storedBackground.commands
-                        });
-                    }
-                    const chat = await loadChat({ chats, placed: deps.placed }, task.childId);
-                    if (chat && chat.info.activeTurnId === null) {
-                        const last = chat.thread.list().findLast((item) => item.kind === 'turn');
-                        if (last?.kind === 'turn') {
-                            coordinator.chatEvent({ event: 'chat.event', payload: { chatId: task.childId, event: { type: 'item', item: last } } });
-                        }
-                    }
+                if (task.status === 'open') {
+                    await recoverOpen(task);
                 }
             }
             await coordinator.settled();
@@ -110,14 +112,7 @@ export function wireTasks(deps) {
                 await enqueue(task.projectId, task.childId, { kind: 'give-task', payload: { taskId: task.id } });
                 return task;
             },
-            chatState: async (nodeId) => {
-                const session = chats.get(nodeId);
-                if (session) {
-                    return session.info.activeTurnId === null ? 'idle' : 'running';
-                }
-                // A chat nobody has loaded is idle: the turn opens on the thread the host reads back from disk.
-                return (await chats.hasStored(nodeId)) ? 'idle' : 'none';
-            },
+            chatState: (nodeId) => targets.chat(nodeId),
             done: (childId, text) => coordinator.done(childId, text),
             involving: (nodeId) => deps.tasks.involving(nodeId)
         },

package/dist/usage/aggregate.js

@@ -28,6 +28,59 @@ function slotOf(format, timestampMs, resolution) {
 function emptyTotals() {
     return { ...EMPTY_TOTALS };
 }
+function foldBucket(buckets, slot, record, account, price, cost) {
+    const key = `${slot}\0${record.provider}\0${record.model}\0${account ?? ''}`;
+    let bucket = buckets.get(key);
+    if (bucket === undefined) {
+        bucket = {
+            slot,
+            provider: record.provider,
+            model: record.model,
+            account,
+            totals: emptyTotals(),
+            costUsd: 0,
+            priced: false,
+            cacheSavingsUsd: 0,
+            sessions: new Set()
+        };
+        buckets.set(key, bucket);
+    }
+    bucket.totals = addTotals(bucket.totals, record.totals);
+    bucket.costUsd += cost;
+    bucket.priced ||= price !== null;
+    bucket.cacheSavingsUsd += price === null ? 0 : cacheSavingsOf(record.totals, price);
+    if (record.sessionId !== '') {
+        bucket.sessions.add(record.sessionId);
+    }
+}
+function foldModel(models, record, account, lookup, cost) {
+    const key = `${record.provider}\0${record.model}\0${account ?? ''}`;
+    let model = models.get(key);
+    if (model === undefined) {
+        model = {
+            provider: record.provider,
+            model: record.model,
+            account,
+            totals: emptyTotals(),
+            costUsd: 0,
+            priced: false,
+            basis: lookup.basis,
+            pricedAs: lookup.pricedAs
+        };
+        models.set(key, model);
+    }
+    model.totals = addTotals(model.totals, record.totals);
+    model.costUsd += cost;
+    model.priced ||= lookup.price !== null;
+}
+function foldProject(project, record, cost) {
+    project.totals = addTotals(project.totals, record.totals);
+    project.costUsd += cost;
+    const share = project.byProvider.get(record.provider) ?? { costUsd: 0, tokens: 0 };
+    share.costUsd += cost;
+    share.tokens += totalTokensOf(record.totals);
+    project.byProvider.set(record.provider, share);
+}
 /* The account a record was made under, the default one under its CLI's kind. */
 export function accountOfRecord(record) {
     return record.account ?? record.provider;
@@ -41,8 +94,6 @@ export async function aggregate(records, payload, prices, known) {
     const format = slotFormatter(payload.timeZone, payload.resolution);
     const buckets = new Map();
     const models = new Map();
-    /* The basis of the first record of a model prices the whole row: a model has one price. */
-    const modelBasis = new Map();
     const projects = new Map();
     const sessions = new Set();
     const resolver = new ProjectResolver(known);
@@ -59,42 +110,13 @@ export async function aggregate(records, payload, prices, known) {
         if (day < payload.from || day > payload.to) {
             continue;
         }
-        const { price, basis, pricedAs } = prices.look(record.model);
-        const cost = price === null ? 0 : costOf(record.totals, price);
-        const bucketKey = `${slot}\0${record.provider}\0${record.model}\0${account ?? ''}`;
-        let bucket = buckets.get(bucketKey);
-        if (bucket === undefined) {
-            bucket = {
-                slot,
-                provider: record.provider,
-                model: record.model,
-                account,
-                totals: emptyTotals(),
-                costUsd: 0,
-                priced: false,
-                cacheSavingsUsd: 0,
-                sessions: new Set()
-            };
-            buckets.set(bucketKey, bucket);
-        }
-        bucket.totals = addTotals(bucket.totals, record.totals);
-        bucket.costUsd += cost;
-        bucket.priced ||= price !== null;
-        bucket.cacheSavingsUsd += price === null ? 0 : cacheSavingsOf(record.totals, price);
+        const lookup = prices.look(record.model);
+        const cost = lookup.price === null ? 0 : costOf(record.totals, lookup.price);
+        foldBucket(buckets, slot, record, account, lookup.price, cost);
+        foldModel(models, record, account, lookup, cost);
         if (record.sessionId !== '') {
-            bucket.sessions.add(record.sessionId);
             sessions.add(`${record.provider}\0${record.sessionId}`);
         }
-        const modelKey = `${record.provider}\0${record.model}\0${account ?? ''}`;
-        let model = models.get(modelKey);
-        if (model === undefined) {
-            model = { provider: record.provider, model: record.model, account, totals: emptyTotals(), costUsd: 0, priced: false };
-            models.set(modelKey, model);
-            modelBasis.set(modelKey, { basis, pricedAs });
-        }
-        model.totals = addTotals(model.totals, record.totals);
-        model.costUsd += cost;
-        model.priced ||= price !== null;
         let folder = folders.get(record.cwd);
         if (folder === undefined) {
             const resolved = await resolver.resolve(record.cwd);
@@ -104,13 +126,7 @@ export async function aggregate(records, payload, prices, known) {
                 projects.set(folder, { folder, name: resolved.name, projectId: resolved.projectId, byProvider: new Map(), totals: emptyTotals(), costUsd: 0 });
             }
         }
-        const project = projects.get(folder);
-        project.totals = addTotals(project.totals, record.totals);
-        project.costUsd += cost;
-        const share = project.byProvider.get(record.provider) ?? { costUsd: 0, tokens: 0 };
-        share.costUsd += cost;
-        share.tokens += totalTokensOf(record.totals);
-        project.byProvider.set(record.provider, share);
+        foldProject(projects.get(folder), record, cost);
     }
     return {
         buckets: [...buckets.values()]
@@ -128,15 +144,15 @@ export async function aggregate(records, payload, prices, known) {
             a.provider.localeCompare(b.provider) ||
             a.model.localeCompare(b.model) ||
             (a.account ?? '').localeCompare(b.account ?? '')),
-        models: [...models.entries()]
-            .map(([key, model]) => ({
+        models: [...models.values()]
+            .map((model) => ({
             provider: model.provider,
             model: model.model,
             ...(model.account === null ? {} : { account: model.account }),
             totals: model.totals,
             costUsd: model.priced ? model.costUsd : null,
-            priceBasis: modelBasis.get(key)?.basis ?? 'unknown',
-            pricedAs: modelBasis.get(key)?.pricedAs ?? null
+            priceBasis: model.basis,
+            pricedAs: model.pricedAs
         }))
             .sort((a, b) => (b.costUsd ?? -1) - (a.costUsd ?? -1)),
         projects: [...projects.values()]

package/dist/usage/exchange.js

@@ -1,7 +1,7 @@
 import { mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { isNotFound, writeAtomic } from '../fs.js';
 import { errorText } from '../error-text.js';
+import { isNotFound, writeAtomic } from '../fs.js';
 export const FRANKFURTER_URL = 'https://api.frankfurter.app/latest';
 /* The bank publishes one rate a day, so a rate a day old is the rate. */
 const TTL_MS = 24 * 60 * 60 * 1000;

package/dist/usage/limits/monitor.d.ts

@@ -1,8 +1,8 @@
 import type { UsageLimitsSnapshot, UsageProvider } from '@adecore/agent-contracts';
-import type { ProviderRegistry } from '../../providers/registry.ts';
+import type { CodexClientInfo } from '../../chat/codex-transport.ts';
 import type { AgentSink } from '../../events.ts';
+import type { ProviderRegistry } from '../../providers/registry.ts';
 import { type LimitsUpdate } from './normalize.ts';
-import type { CodexClientInfo } from '../../chat/codex-transport.ts';
 import { type ProbeResult } from './probe.ts';
 export type ProbeEnv = Record<string, string>;
 export interface LimitAccount {

package/dist/usage/limits/monitor.js

@@ -1,8 +1,8 @@
+import { ClientSinks } from '../../client-sinks.js';
+import { errorText } from '../../error-text.js';
 import { definedEnv } from '../../providers/accounts/launch.js';
 import { mergeWindows } from './normalize.js';
 import { probeClaude, probeCodex } from './probe.js';
-import { ClientSinks } from '../../client-sinks.js';
-import { errorText } from '../../error-text.js';
 /* Often enough that a bar is never far behind, rarely enough that two CLIs are not started all day. */
 const PROBE_INTERVAL_MS = 5 * 60_000;
 const MAX_BACKOFF_MS = 60 * 60_000;

package/dist/usage/limits/probe.js

@@ -1,8 +1,8 @@
 import { withTimeout } from '../../async.js';
 import { spawnChatProcess } from '../../chat/chat-process.js';
 import { CodexTransport, DEFAULT_CODEX_CLIENT } from '../../chat/codex-transport.js';
-import { readClaudeUsage, readCodexLimits } from './normalize.js';
 import { errorText } from '../../error-text.js';
+import { readClaudeUsage, readCodexLimits } from './normalize.js';
 /* A CLI that has not answered by now is not going to; the next pass tries again. */
 const PROBE_TIMEOUT_MS = 20_000;
 const CODEX_READ_TIMEOUT_MS = 3_000;

package/dist/usage/pricing.js

@@ -1,7 +1,7 @@
 import { mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { isNotFound, writeAtomic } from '../fs.js';
 import { errorText } from '../error-text.js';
+import { isNotFound, writeAtomic } from '../fs.js';
 import bundled from './prices-snapshot.json' with { type: 'json' };
 export const LITELLM_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
 /* A table a day old still prices everything anyone ran today, and nobody has to be online for it. */

package/dist/usage/roots.js

@@ -2,8 +2,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 /* Where in its config folder each CLI leaves its transcripts. */
 const TRANSCRIPTS = { claude: 'projects', codex: 'sessions' };
-/* Where each CLI leaves its transcripts. The same environment variables the hooks installer reads,
-   so the scanner and the installer never disagree about where a CLI keeps its things. */
+/* The transcripts of the default accounts, found through the variables the CLIs themselves read. */
 export function usageRoots(env = process.env) {
     const home = env.HOME ?? homedir();
     return [