@adecore/agents 0.31.2 → 0.31.4

package/src/chat/acp-protocol.ts

@@ -58,6 +58,48 @@ const SessionNotificationSchema = z.looseObject({ sessionId: z.string(), update:
 
 const PromptResponseSchema = z.looseObject({ stopReason: z.string() });
 
+const tokenCount = z.number().int().nonnegative();
+
+// Unstable in the protocol (`PromptResponse.usage`); only the three totals are required.
+const PromptUsageSchema = z.looseObject({
+    totalTokens: tokenCount,
+    inputTokens: tokenCount,
+    outputTokens: tokenCount,
+    thoughtTokens: tokenCount.nullish(),
+    cachedReadTokens: tokenCount.nullish(),
+    cachedWriteTokens: tokenCount.nullish()
+});
+
+/* The tokens of one turn with their kinds apart, as a usage record keeps them: `reasoning` is a part of `output`. */
+export interface AcpTurnUsage {
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+    output: number;
+    reasoning: number;
+}
+
+/*
+ * The `usage` a `session/prompt` response carries, or null where the agent reports none. The protocol
+ * leaves open whether the input holds the cached part, so the total decides: when the kinds add up
+ * to more than it, the input counted the cache too and loses it here.
+ */
+export function promptUsageOf(result: unknown): AcpTurnUsage | null {
+    const response = z.looseObject({ usage: PromptUsageSchema }).safeParse(result);
+    if (!response.success) {
+        return null;
+    }
+    const usage = response.data.usage;
+    const cacheRead = usage.cachedReadTokens ?? 0;
+    const cacheWrite = usage.cachedWriteTokens ?? 0;
+    const apart = usage.inputTokens + usage.outputTokens + cacheRead + cacheWrite <= usage.totalTokens;
+    const input = apart ? usage.inputTokens : Math.max(0, usage.inputTokens - cacheRead - cacheWrite);
+    if (input + cacheRead + cacheWrite + usage.outputTokens === 0) {
+        return null;
+    }
+    return { input, cacheRead, cacheWrite, output: usage.outputTokens, reasoning: usage.thoughtTokens ?? 0 };
+}
+
 const ModeStateSchema = z.looseObject({
     currentModeId: z.string(),
     availableModes: z.array(z.unknown())
@@ -65,7 +107,7 @@ const ModeStateSchema = z.looseObject({
 
 const ModeSchema = z.looseObject({ id: z.string(), name: z.string() });
 
-const SelectValueSchema = z.looseObject({ value: z.string(), name: z.string() });
+const SelectValueSchema = z.looseObject({ value: z.string(), name: z.string(), description: z.string().nullish() });
 
 const ConfigOptionSchema = z.looseObject({
     id: z.string(),
@@ -179,14 +221,27 @@ export interface AcpModeState {
     configId: string | null;
 }
 
+export interface AcpChoice {
+    id: string;
+    name: string;
+    description: string | null;
+}
+
+/* The reasoning effort a session offers: the config option that sets it, the value it runs at and the values it takes. */
+export interface AcpThoughtLevel {
+    configId: string;
+    current: string;
+    choices: AcpChoice[];
+}
+
 /* What `session/new`, `session/load` or `session/resume` said about the session, for a host that fills its catalog from it. */
 export interface AcpSessionInfo {
     sessionId: string;
     agent: AcpAgentInfo | null;
     models: AcpModelState | null;
     modes: AcpModeState | null;
-    // The reasoning effort a session offers, as a config option with the `thought_level` category.
-    thoughtLevel: { configId: string; current: string; values: string[] } | null;
+    // A config option of the `thought_level` category, or one with the id `reasoning_effort` where an agent sets no category.
+    thoughtLevel: AcpThoughtLevel | null;
 }
 
 type ConfigOption = z.infer<typeof ConfigOptionSchema>;
@@ -201,6 +256,22 @@ function selectOption(options: ConfigOption[], category: string): ConfigOption |
     return options.find((option) => option.type === 'select' && option.category === category && typeof option.currentValue === 'string') ?? null;
 }
 
+function thoughtOption(options: ConfigOption[]): ConfigOption | null {
+    return (
+        selectOption(options, 'thought_level') ??
+        options.find((option) => option.type === 'select' && option.id === 'reasoning_effort' && typeof option.currentValue === 'string') ??
+        null
+    );
+}
+
+/* The reasoning effort in a response that carries the session's config options; undefined when it carries none. */
+export function thoughtLevelOf(result: unknown): AcpThoughtLevel | null | undefined {
+    if (!isRecord(result) || !Array.isArray(result.configOptions)) {
+        return undefined;
+    }
+    return sessionState(validItems(ConfigOptionSchema, result.configOptions), null, null).thoughtLevel;
+}
+
 export function parseSessionInfo(result: unknown, sessionId: string, agent: AcpAgentInfo | null): AcpSessionInfo {
     const record = isRecord(result) ? result : {};
     const options = validItems(ConfigOptionSchema, Array.isArray(record.configOptions) ? record.configOptions : []);
@@ -210,7 +281,7 @@ export function parseSessionInfo(result: unknown, sessionId: string, agent: AcpA
 function sessionState(options: ConfigOption[], modes: unknown, models: unknown): Omit<AcpSessionInfo, 'sessionId' | 'agent'> {
     const modelOption = selectOption(options, 'model');
     const modeOption = selectOption(options, 'mode');
-    const thoughtOption = selectOption(options, 'thought_level');
+    const thought = thoughtOption(options);
     const modeState = ModeStateSchema.safeParse(modes);
     const modelState = ModelStateSchema.safeParse(models);
     return {
@@ -244,8 +315,12 @@ function sessionState(options: ConfigOption[], modes: unknown, models: unknown):
                     configId: null
                 }
               : null,
-        thoughtLevel: thoughtOption
-            ? { configId: thoughtOption.id, current: thoughtOption.currentValue as string, values: selectValues(thoughtOption).map((value) => value.value) }
+        thoughtLevel: thought
+            ? {
+                  configId: thought.id,
+                  current: thought.currentValue as string,
+                  choices: selectValues(thought).map((value) => ({ id: value.value, name: value.name, description: value.description ?? null }))
+              }
             : null
     };
 }
@@ -440,11 +515,22 @@ function toolOutput(tool: ToolState): string | null {
     return null;
 }
 
+/* What an agent asks permission for, in the plain form a host's `autoAllow` judges it by. */
+export interface AcpPermissionRequest {
+    // The ACP tool kind (`execute`, `edit`, `fetch`, ...), or null when the agent names none.
+    kind: string | null;
+    title: string | null;
+    // Every text the call carries that may be what it runs: the command in its raw input and each text in its
+    // content. The agent decides which one it runs, so a host allows the call only when every one passes.
+    commands: string[];
+}
+
 /* A permission request as the backend acts on it: the event it raises, and the tool kind a runtime mode may answer it by. */
 export interface AcpPermission {
     requestId: string;
     rpcId: number | string;
     kind: string | null;
+    request: AcpPermissionRequest;
     events: BackendEvent[];
 }
 
@@ -562,7 +648,9 @@ export class AcpProtocol {
             description: tool.title === '' ? null : tool.title,
             canAllowAlways: options.some((option) => option.kind === 'allow_always')
         });
-        return { requestId, rpcId, kind: tool.kind, events };
+        const command = rawField(tool.rawInput, 'command', 'cmd');
+        const asked = { kind: tool.kind, title: tool.title === '' ? null : tool.title, commands: [...(command === null ? [] : [command]), ...tool.text] };
+        return { requestId, rpcId, kind: tool.kind, request: asked, events };
     }
 
     /*

package/src/chat/index.ts

@@ -1,6 +1,18 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
-export { type AcpAgentSpec, type AcpClientInfo, createAcpBackend } from './acp-backend.ts';
-export type { AcpAgentInfo, AcpModel, AcpModelState, AcpMode, AcpModeState, AcpSessionInfo, AcpModeMap } from './acp-protocol.ts';
+export { type AcpAgentSpec, type AcpClientInfo, type AcpUsageReport, createAcpBackend } from './acp-backend.ts';
+export type {
+    AcpAgentInfo,
+    AcpModel,
+    AcpModelState,
+    AcpMode,
+    AcpModeState,
+    AcpPermissionRequest,
+    AcpSessionInfo,
+    AcpModeMap,
+    AcpChoice,
+    AcpThoughtLevel,
+    AcpTurnUsage
+} from './acp-protocol.ts';
 export { AttachmentStore } from './attachment-store.ts';
 export type { BackendLaunch, TurnInput, ApprovalDecision, BackendEvent, BackendHost, ChatBackend } from './backend.ts';
 export { runningInBackground, type BackgroundWork } from './background-work.ts';

package/src/providers/acp-provider.ts

@@ -1,7 +1,8 @@
-import type { AgentKind, ProviderCapabilities, ProviderInstall } from '@adecore/agent-contracts';
-import { createAcpBackend, type AcpAgentSpec } from '../chat/acp-backend.ts';
+import type { AgentKind, ModelOptionDescriptor, ProviderCapabilities, ProviderInstall } from '@adecore/agent-contracts';
+import { createAcpBackend, type AcpAgentSpec, type AcpUsageReport } from '../chat/acp-backend.ts';
 import type { AcpSessionInfo } from '../chat/acp-protocol.ts';
 import { askAcpAccount } from './accounts/acp-account.ts';
+import { writeAcpUsage } from './acp-usage-log.ts';
 import type { ModelCatalog } from './catalog.ts';
 import { detectCli, type CliDetection } from './detect.ts';
 import type { ChatProvider, ProviderHome } from './provider.ts';
@@ -53,21 +54,55 @@ export interface AcpProviderSpec extends AcpAgentSpec {
     accountProbe?: boolean;
     // Absent or true lets the models a session reports replace the catalog's; false keeps the catalog as the host built it.
     adoptModels?: boolean;
+    // The folder the usage of every turn the agent reports is logged to, for a usage root of the agent's kind; absent logs nothing.
+    usageLog?: string;
 }
 
+/* Agents whose own usage files the scanner reads; a log of their turns would count every one twice. */
+const OWN_USAGE_FILES: ReadonlySet<AgentKind> = new Set(['grok']);
+
 /* An agent's model id may reach a command line, so one that reads as a flag is left out. */
 function adoptableModels(info: AcpSessionInfo): Array<{ slug: string; name: string }> {
     return (info.models?.models ?? []).filter((model) => model.id !== '' && !model.id.startsWith('-')).map((model) => ({ slug: model.id, name: model.name }));
 }
 
+/* The reasoning effort a session offers, as the `effort` option the composer draws for every provider. */
+function effortOption(info: AcpSessionInfo): ModelOptionDescriptor[] {
+    const level = info.thoughtLevel;
+    if (level === null || !level.choices.some((choice) => choice.id === level.current)) {
+        return [];
+    }
+    return [
+        {
+            id: 'effort',
+            label: 'Reasoning',
+            type: 'select',
+            defaultChoice: level.current,
+            choices: level.choices.map((choice) => ({
+                id: choice.id,
+                label: choice.name,
+                ...(choice.description === null ? {} : { description: choice.description })
+            }))
+        }
+    ];
+}
+
 export function createAcpProvider(spec: AcpProviderSpec): ChatProvider {
     const capabilities = { ...ACP_CAPABILITIES, ...spec.capabilities };
     const onSession = (info: AcpSessionInfo): void => {
         if (spec.adoptModels !== false && info.models !== null) {
-            spec.catalog.adopt(adoptableModels(info), info.models.current);
+            spec.catalog.adopt(adoptableModels(info), info.models.current, effortOption(info));
         }
         spec.onSession?.(info);
     };
+    const usageLog = spec.usageLog === undefined || OWN_USAGE_FILES.has(spec.kind) ? null : spec.usageLog;
+    const onUsage =
+        usageLog === null
+            ? spec.onUsage
+            : (report: AcpUsageReport): void => {
+                  writeAcpUsage(usageLog, report, Date.now());
+                  spec.onUsage?.(report);
+              };
     return {
         kind: spec.kind,
         name: spec.name,
@@ -99,6 +134,6 @@ export function createAcpProvider(spec: AcpProviderSpec): ChatProvider {
                           onSession
                       })
               }),
-        createBackend: createAcpBackend({ ...spec, onSession })
+        createBackend: createAcpBackend({ ...spec, onSession, ...(onUsage === undefined ? {} : { onUsage }) })
     };
 }

package/src/providers/acp-usage-log.ts

@@ -0,0 +1,26 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import type { AcpUsageReport } from '../chat/acp-backend.ts';
+import { errorText } from '../error-text.ts';
+import { hostUsageLine } from '../usage/readers/host-log.ts';
+
+/*
+ * Appends one turn to the session's own file in the folder, so a scan that hashes what it already read
+ * of a file never rereads the log of every other session. Written at once, since it is one line per turn.
+ */
+export function writeAcpUsage(folder: string, report: AcpUsageReport, at: number): void {
+    const { sessionId, cwd, model, ...tokens } = report;
+    try {
+        mkdirSync(folder, { recursive: true, mode: 0o700 });
+        appendFileSync(
+            join(folder, `${encodeURIComponent(sessionId === '' ? 'session' : sessionId)}.jsonl`),
+            hostUsageLine({ at, model, session: sessionId, cwd, ...tokens }),
+            {
+                mode: 0o600
+            }
+        );
+    } catch (e) {
+        // A turn whose line could not be written is missing from the usage page; the chat itself goes on.
+        console.warn('Could not write the usage of an ACP turn:', errorText(e));
+    }
+}

package/src/providers/catalog.ts

@@ -1,4 +1,4 @@
-import type { ModelCatalogData, ModelCatalogProfile, ModelInfo, ModelSelection } from '@adecore/agent-contracts';
+import type { ModelCatalogData, ModelCatalogProfile, ModelInfo, ModelOptionDescriptor, ModelSelection } from '@adecore/agent-contracts';
 import manifest from './claude-models.json' with { type: 'json' };
 
 // What a host builds a catalog from; one that is never replaced needs no date.
@@ -41,13 +41,16 @@ export class ModelCatalog {
     /*
      * Takes the models an agent reported for itself in place of the list, the agent's current model as the
      * default and its order kept; answers whether the models changed. Every model gets the profile the
-     * default has now, as an agent names its models but not what each can be asked for.
+     * default has now, as an agent names its models but not what each can be asked for, with `options`
+     * in place of the profile's options of the same id.
      */
-    adopt(models: ReadonlyArray<{ slug: string; name: string }>, defaultModel: string): boolean {
+    adopt(models: ReadonlyArray<{ slug: string; name: string }>, defaultModel: string, options: readonly ModelOptionDescriptor[] = []): boolean {
         if (models.length === 0 || !models.some((model) => model.slug === defaultModel)) {
             return false;
         }
-        const profile = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
+        const base = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
+        const replaced = new Set(options.map((option) => option.id));
+        const profile = { ...base, options: [...base.options.filter((option) => !replaced.has(option.id)), ...options] };
         const data: ModelCatalogInput = {
             ...(this.data.updatedAt === undefined ? {} : { updatedAt: this.data.updatedAt }),
             defaultModel,

package/src/providers/index.ts

@@ -13,5 +13,6 @@ export { type CodexRules, codexRulesText, codexRulesPathIn, defaultCodexHome, in
 export { codexThreadOptions, codexServiceTier } from './codex.ts';
 export { type CliDetection, detectCli } from './detect.ts';
 export type { ChatProvider, ProviderHome } from './provider.ts';
+export { isOnlyCommands } from './shell-commands.ts';
 export { ProviderRegistry, type ProviderRegistryOptions } from './registry.ts';
 export { MODE_ORDER, narrowerMode, ceilingForOpening, modeFlag } from '../modes.ts';

package/src/providers/shell-commands.ts

@@ -0,0 +1,122 @@
+// Unquoted, each of these makes the shell do more than run a word list: a pipe, a redirect, an expansion,
+// a subshell or group, a glob, a comment or a history or negation mark.
+const REFUSED = new Set(['|', '>', '<', '$', '`', '(', ')', '{', '}', '*', '?', '[', '~', '#', '!']);
+
+/*
+ * Whether a shell command line is only simple commands, joined by `&&`, `||`, `;` or newlines, each of
+ * which starts with one of `allowed`. Anything the tokenizer cannot prove simple answers false, so a
+ * true is safe to act on without a person: a pipe, a redirect, an expansion, a subshell, a background
+ * `&`, an unquoted glob or an unbalanced quote all refuse the whole line.
+ */
+export function isOnlyCommands(command: string, allowed: readonly string[]): boolean {
+    let word = '';
+    let inWord = false;
+    let words: string[] = [];
+    let commands = 0;
+    // A separator that still needs a command after it; a trailing `;` or newline needs none.
+    let dangling = false;
+
+    const endWord = (): void => {
+        if (inWord) {
+            words.push(word);
+        }
+        word = '';
+        inWord = false;
+    };
+
+    const endCommand = (separator: string): boolean => {
+        endWord();
+        if (words.length === 0) {
+            // Blank lines are fine, and so is a newline after `&&` or `||`; an empty command before any other separator is not.
+            return separator === '\n';
+        }
+        if (!allowed.includes(words[0]!)) {
+            return false;
+        }
+        commands++;
+        words = [];
+        dangling = separator === '&&' || separator === '||';
+        return true;
+    };
+
+    for (let i = 0; i < command.length; i++) {
+        const char = command[i]!;
+        const next = command[i + 1];
+        if (char === ' ' || char === '\t') {
+            endWord();
+            continue;
+        }
+        if (char === '\n' || char === ';') {
+            if (!endCommand(char)) {
+                return false;
+            }
+            continue;
+        }
+        if ((char === '&' || char === '|') && next === char) {
+            if (!endCommand(char + next)) {
+                return false;
+            }
+            i++;
+            continue;
+        }
+        if (char === '&' || REFUSED.has(char)) {
+            return false;
+        }
+        if (char === '\\') {
+            if (next === undefined) {
+                return false;
+            }
+            i++;
+            if (next !== '\n') {
+                word += next;
+                inWord = true;
+            }
+            continue;
+        }
+        if (char === "'") {
+            const close = command.indexOf("'", i + 1);
+            if (close === -1) {
+                return false;
+            }
+            word += command.slice(i + 1, close);
+            inWord = true;
+            i = close;
+            continue;
+        }
+        if (char === '"') {
+            inWord = true;
+            let closed = false;
+            for (i++; i < command.length; i++) {
+                const quoted = command[i]!;
+                if (quoted === '"') {
+                    closed = true;
+                    break;
+                }
+                if (quoted === '$' || quoted === '`') {
+                    return false;
+                }
+                if (quoted === '\\') {
+                    const escaped = command[i + 1];
+                    if (escaped === undefined) {
+                        return false;
+                    }
+                    i++;
+                    if (escaped === '"' || escaped === '\\' || escaped === '$' || escaped === '`') {
+                        word += escaped;
+                    } else if (escaped !== '\n') {
+                        word += quoted + escaped;
+                    }
+                    continue;
+                }
+                word += quoted;
+            }
+            if (!closed) {
+                return false;
+            }
+            continue;
+        }
+        word += char;
+        inWord = true;
+    }
+    return endCommand('\n') && commands > 0 && !dangling;
+}

package/src/testing/fake-acp.ts

@@ -22,6 +22,11 @@ export interface FakeAcpOptions {
     legacyModels?: boolean;
     // Advertises and answers `session/close`.
     closeSession?: boolean;
+    // The `usage` every `session/prompt` response carries; absent reports none.
+    turnUsage?: Record<string, number>;
+    // Offers a reasoning effort as the config option `reasoning_effort`, without a category: Low and High, and
+    // Extra high on `fake-large`. `reject` refuses every change to it.
+    reasoningEffort?: 'accept' | 'reject';
 }
 
 export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
@@ -31,6 +36,7 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
         let sessionId = '';
         let mode = modes[0] ?? '';
         let model = 'fake-small';
+        let effort = 'low';
         let serverRequestId = 0;
         let callCounter = 0;
         let prompt: { rpcId: number | string; cancelled: boolean } | null = null;
@@ -63,7 +69,7 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                 return;
             }
             update({ sessionUpdate: 'usage_update', used: 1200, size: 200000, cost: { amount: 0.01, currency: 'USD' } });
-            respond(prompt.rpcId, { stopReason });
+            respond(prompt.rpcId, { stopReason, ...(options.turnUsage === undefined ? {} : { usage: options.turnUsage }) });
             prompt = null;
         };
 
@@ -72,11 +78,25 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                 { value: 'fake-small', name: 'Fake small' },
                 { value: 'fake-large', name: 'Fake large' }
             ];
+            const effortChoices = [
+                { value: 'low', name: 'Low', description: 'Answers quickly' },
+                { value: 'high', name: 'High' },
+                ...(model === 'fake-large' ? [{ value: 'xhigh', name: 'Extra high' }] : [])
+            ];
+            const effortOption =
+                options.reasoningEffort === undefined
+                    ? []
+                    : [{ id: 'reasoning_effort', name: 'Reasoning effort', type: 'select', currentValue: effort, options: effortChoices }];
             return {
                 ...(modes.length === 0 ? {} : { modes: { currentModeId: mode, availableModes: modes.map((id) => ({ id, name: id })) } }),
                 ...(options.legacyModels
                     ? { models: { currentModelId: model, availableModels: modelChoices.map((choice) => ({ modelId: choice.value, name: choice.name })) } }
-                    : { configOptions: [{ id: 'model', name: 'Model', type: 'select', category: 'model', currentValue: model, options: modelChoices }] })
+                    : {
+                          configOptions: [
+                              { id: 'model', name: 'Model', type: 'select', category: 'model', currentValue: model, options: modelChoices },
+                              ...effortOption
+                          ]
+                      })
             };
         };
 
@@ -275,6 +295,13 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                     if (params.configId === 'model') {
                         model = String(params.value);
                     }
+                    if (params.configId === 'reasoning_effort') {
+                        if (options.reasoningEffort === 'reject') {
+                            refuse(id, -32602, 'Reasoning effort is locked');
+                            return;
+                        }
+                        effort = String(params.value);
+                    }
                     respond(id, { configOptions: sessionState().configOptions ?? [] });
                     return;
                 case 'session/prompt':

package/src/usage/aggregate.ts

@@ -112,7 +112,7 @@ function foldBucket(
     }
     bucket.totals = addTotals(bucket.totals, record.totals);
     bucket.costUsd += cost;
-    bucket.priced ||= price !== null;
+    bucket.priced ||= price !== null || record.costUsd !== undefined;
     bucket.cacheSavingsUsd += price === null ? 0 : cacheSavingsOf(record.totals, price);
     if (record.sessionId !== '') {
         bucket.sessions.add(record.sessionId);
@@ -130,14 +130,15 @@ function foldModel(models: Map<string, ModelRow>, record: UsageRecord, account:
             totals: emptyTotals(),
             costUsd: 0,
             priced: false,
-            basis: lookup.basis,
-            pricedAs: lookup.pricedAs
+            // A cost the CLI reported is the bill itself, not a price looked up for the model.
+            basis: record.costUsd === undefined ? lookup.basis : 'exact',
+            pricedAs: record.costUsd === undefined ? lookup.pricedAs : null
         };
         models.set(key, model);
     }
     model.totals = addTotals(model.totals, record.totals);
     model.costUsd += cost;
-    model.priced ||= lookup.price !== null;
+    model.priced ||= lookup.price !== null || record.costUsd !== undefined;
 }
 
 function foldProject(project: ProjectAccumulator, record: UsageRecord, cost: number): void {
@@ -186,7 +187,7 @@ export async function aggregate(
             continue;
         }
         const lookup = prices.look(record.model);
-        const cost = lookup.price === null ? 0 : costOf(record.totals, lookup.price);
+        const cost = record.costUsd ?? (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 !== '') {

package/src/usage/index-file.ts

@@ -30,8 +30,9 @@ export type UsageIndex = Map<string, IndexedFile>;
  * directory and account strings over and over. Interning those and writing a record as a tuple is
  * what keeps the file at a few megabytes instead of tens of them. The account is one past its place
  * in its table, and 0 for the default account, which is also what a version 1 row without it means.
+ * A cost the CLI reported itself rides last, only on a row that has one, so every other row keeps its length.
  */
-type RecordRow = [number, number, number, number, number, number, number, number, number, number, number, string | 0, number?];
+type RecordRow = [number, number, number, number, number, number, number, number, number, number, number, string | 0, number?, number?];
 
 interface FileRow {
     p: UsageProvider;
@@ -75,21 +76,27 @@ export function encodeIndex(index: UsageIndex): string {
     const folders = new Interner();
     const accounts = new Interner();
     const files: Record<string, FileRow> = {};
-    const row = (record: UsageRecord): RecordRow => [
-        record.timestampMs,
-        models.index(record.model),
-        sessions.index(record.sessionId),
-        folders.index(record.cwd),
-        record.totals.calls,
-        record.totals.input,
-        record.totals.cacheRead,
-        record.totals.cacheWrite,
-        record.totals.cacheWrite1h,
-        record.totals.output,
-        record.totals.reasoning,
-        record.dedupeKey ?? 0,
-        record.account === undefined ? 0 : accounts.index(record.account) + 1
-    ];
+    const row = (record: UsageRecord): RecordRow => {
+        const counted: RecordRow = [
+            record.timestampMs,
+            models.index(record.model),
+            sessions.index(record.sessionId),
+            folders.index(record.cwd),
+            record.totals.calls,
+            record.totals.input,
+            record.totals.cacheRead,
+            record.totals.cacheWrite,
+            record.totals.cacheWrite1h,
+            record.totals.output,
+            record.totals.reasoning,
+            record.dedupeKey ?? 0,
+            record.account === undefined ? 0 : accounts.index(record.account) + 1
+        ];
+        if (record.costUsd !== undefined) {
+            counted.push(record.costUsd);
+        }
+        return counted;
+    };
     for (const [path, file] of index) {
         files[path] = {
             p: file.provider,
@@ -116,10 +123,11 @@ export function encodeIndex(index: UsageIndex): string {
 function isRow(row: unknown, version: number): row is RecordRow {
     return (
         Array.isArray(row) &&
-        row.length === (version === ACCOUNTLESS_VERSION ? 12 : 13) &&
+        (version === ACCOUNTLESS_VERSION ? row.length === 12 : row.length === 13 || row.length === 14) &&
         row.slice(0, 11).every((value) => typeof value === 'number') &&
         (typeof row[11] === 'string' || row[11] === 0) &&
-        (version === ACCOUNTLESS_VERSION || typeof row[12] === 'number')
+        (version === ACCOUNTLESS_VERSION || typeof row[12] === 'number') &&
+        (row.length < 14 || typeof row[13] === 'number')
     );
 }
 
@@ -176,6 +184,7 @@ export function decodeIndex(text: string): UsageIndex {
                     cwd,
                     ...(account === undefined ? {} : { account }),
                     totals: { calls: row[4], input: row[5], cacheRead: row[6], cacheWrite: row[7], cacheWrite1h: row[8], output: row[9], reasoning: row[10] },
+                    ...(row[13] === undefined ? {} : { costUsd: row[13] }),
                     dedupeKey: row[11] === 0 ? null : row[11]
                 });
             }

package/src/usage/limits/monitor.ts

@@ -15,6 +15,8 @@ const MAX_BACKOFF_MS = 60 * 60_000;
 const RECENT_USE_MS = 24 * 60 * 60_000;
 
 const PROVIDERS: readonly UsageProvider[] = USAGE_PROVIDERS;
+/* The CLIs the probes know how to ask; any other provider has a plan only through the host's `plans`. */
+const PROBED: readonly UsageProvider[] = ['claude', 'codex'];
 
 export type ProbeEnv = Record<string, string>;
 
@@ -167,6 +169,9 @@ export class UsageMonitor {
     private listed(): LimitAccount[] {
         const accounts = this.accounts?.list() ?? PROVIDERS.map((kind) => ({ id: kind, kind, label: kind, isDefault: true }));
         return PROVIDERS.flatMap((kind) => {
+            if (!PROBED.includes(kind) && this.plans[kind] === undefined) {
+                return [];
+            }
             const own = accounts.filter((account) => account.kind === kind);
             return [...own.filter((account) => account.isDefault), ...own.filter((account) => !account.isDefault)];
         });