@adecore/agents 0.31.5 → 0.31.7

package/dist/testing/fake-acp-capture.d.ts

@@ -0,0 +1,11 @@
+import type { FakeCli } from './fake-cli.ts';
+export interface AcpCapture {
+    sessionId: string;
+    initialize: unknown;
+    sessionNew: unknown;
+    commands: unknown[];
+    setConfigOption: unknown;
+    promptUpdates: unknown[];
+    promptResponse: unknown;
+}
+export declare function fakeAcpCapture(capture: AcpCapture): FakeCli;

package/dist/testing/fake-acp-capture.js

@@ -0,0 +1,50 @@
+export function fakeAcpCapture(capture) {
+    return (io) => {
+        const send = (frame) => {
+            io.out({ jsonrpc: '2.0', ...frame });
+        };
+        const update = (fields) => {
+            send({ method: 'session/update', params: { sessionId: capture.sessionId, update: fields } });
+        };
+        return {
+            onLine: (line) => {
+                const frame = JSON.parse(line);
+                const id = frame.id;
+                switch (frame.method) {
+                    case undefined:
+                        return;
+                    case 'initialize':
+                        send({ id, result: capture.initialize });
+                        return;
+                    case 'session/new':
+                        update({ sessionUpdate: 'available_commands_update', availableCommands: capture.commands });
+                        send({ id, result: capture.sessionNew });
+                        return;
+                    case 'session/set_config_option':
+                        send({ id, result: capture.setConfigOption });
+                        return;
+                    case 'session/set_mode':
+                    case 'session/close':
+                        send({ id, result: {} });
+                        return;
+                    case 'session/prompt': {
+                        const blocks = Array.isArray(frame.params?.prompt) ? frame.params.prompt : [];
+                        const text = blocks.find((block) => block.type === 'text')?.text;
+                        for (const fields of capture.promptUpdates) {
+                            const named = fields.sessionUpdate === 'session_info_update';
+                            update(named ? { ...fields, title: text } : fields);
+                        }
+                        send({ id, result: capture.promptResponse });
+                        return;
+                    }
+                    case 'session/cancel':
+                        return;
+                    default:
+                        if (id !== undefined) {
+                            send({ id, error: { code: -32601, message: `Method not found: ${String(frame.method)}` } });
+                        }
+                }
+            }
+        };
+    };
+}

package/dist/usage/aggregate.js

@@ -111,7 +111,7 @@ export async function aggregate(records, payload, prices, known) {
         if (day < payload.from || day > payload.to) {
             continue;
         }
-        const lookup = prices.look(record.model);
+        const lookup = prices.look(record.model, record.serviceTier, record.timestampMs);
         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);

package/dist/usage/index-file.d.ts

@@ -10,6 +10,8 @@ export interface IndexedFile {
     tail: UsageRecord[];
     codex: CodexParserState | null;
     head: string | null;
+    parserVersion?: number;
+    compressed?: boolean;
 }
 export type UsageIndex = Map<string, IndexedFile>;
 export declare function encodeIndex(index: UsageIndex): string;

package/dist/usage/index-file.js

@@ -1,6 +1,6 @@
 import { UsageProviderSchema } from '@adecore/agent-contracts';
-/* Another version is thrown away rather than migrated, since rebuilding costs one cold scan; version 1 is read as it is. */
-const INDEX_VERSION = 2;
+/* Old records survive deleted transcripts; the scanner reparses existing Codex files with its current reader. */
+const INDEX_VERSION = 3;
 /* Before accounts: every record was the default account's, so it reads as that without a scan. */
 const ACCOUNTLESS_VERSION = 1;
 class Interner {
@@ -39,8 +39,11 @@ export function encodeIndex(index) {
             record.dedupeKey ?? 0,
             record.account === undefined ? 0 : accounts.index(record.account) + 1
         ];
-        if (record.costUsd !== undefined) {
-            counted.push(record.costUsd);
+        if (record.costUsd !== undefined || record.serviceTier !== undefined) {
+            counted[13] = record.costUsd;
+        }
+        if (record.serviceTier !== undefined) {
+            counted[14] = record.serviceTier;
         }
         return counted;
     };
@@ -53,7 +56,9 @@ export function encodeIndex(index) {
             c: file.codex,
             r: file.records.map(row),
             t: file.tail.map(row),
-            ...(file.head === null ? {} : { h: file.head })
+            ...(file.head === null ? {} : { h: file.head }),
+            ...(file.parserVersion === undefined ? {} : { v: file.parserVersion }),
+            ...(file.compressed === undefined ? {} : { z: file.compressed })
         };
     }
     const document = {
@@ -68,11 +73,12 @@ export function encodeIndex(index) {
 }
 function isRow(row, version) {
     return (Array.isArray(row) &&
-        (version === ACCOUNTLESS_VERSION ? row.length === 12 : row.length === 13 || row.length === 14) &&
+        (version === ACCOUNTLESS_VERSION ? row.length === 12 : row.length >= 13 && row.length <= (version === INDEX_VERSION ? 15 : 14)) &&
         row.slice(0, 11).every((value) => typeof value === 'number') &&
         (typeof row[11] === 'string' || row[11] === 0) &&
         (version === ACCOUNTLESS_VERSION || typeof row[12] === 'number') &&
-        (row.length < 14 || typeof row[13] === 'number'));
+        (row.length < 14 || row[13] === null || row[13] === undefined || typeof row[13] === 'number') &&
+        (row.length < 15 || typeof row[14] === 'string'));
 }
 /*
  * A row that does not read back costs a cold parse of the file it belonged to, never a wrong total,
@@ -88,7 +94,7 @@ export function decodeIndex(text) {
         return index;
     }
     const version = document?.version;
-    if ((version !== INDEX_VERSION && version !== ACCOUNTLESS_VERSION) ||
+    if ((version !== INDEX_VERSION && version !== 2 && version !== ACCOUNTLESS_VERSION) ||
         !Array.isArray(document.models) ||
         !Array.isArray(document.sessions) ||
         !Array.isArray(document.folders)) {
@@ -126,7 +132,8 @@ export function decodeIndex(text) {
                     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] }),
+                    ...(typeof row[13] === 'number' ? { costUsd: row[13] } : {}),
+                    ...(typeof row[14] === 'string' ? { serviceTier: row[14] } : {}),
                     dedupeKey: row[11] === 0 ? null : row[11]
                 });
             }
@@ -143,7 +150,9 @@ export function decodeIndex(text) {
                 records,
                 tail,
                 codex: file.c ?? null,
-                head: typeof file.h === 'string' ? file.h : null
+                head: typeof file.h === 'string' ? file.h : null,
+                ...(typeof file.v === 'number' ? { parserVersion: file.v } : {}),
+                ...(typeof file.z === 'boolean' ? { compressed: file.z } : {})
             });
         }
     }

package/dist/usage/pricing.d.ts

@@ -6,6 +6,7 @@ export interface ModelPrice {
     cacheRead: number;
     cacheWrite: number;
     cacheWrite1h: number;
+    tiers?: Partial<Record<string, ModelPrice>>;
 }
 export type PriceTable = Map<string, ModelPrice>;
 export interface PriceLookup {
@@ -14,7 +15,7 @@ export interface PriceLookup {
     pricedAs: string | null;
 }
 export declare function parsePriceTable(document: unknown): PriceTable;
-export declare function lookupPrice(table: PriceTable, model: string): PriceLookup;
+export declare function lookupPrice(table: PriceTable, model: string, serviceTier?: string, timestampMs?: number): PriceLookup;
 export declare function costOf(totals: UsageTotals, price: ModelPrice): number;
 export declare function cacheSavingsOf(totals: UsageTotals, price: ModelPrice): number;
 export declare class PriceBook {
@@ -27,7 +28,7 @@ export declare class PriceBook {
     private inFlight;
     constructor(home: string, allowFetch?: boolean);
     get pricing(): UsagePricing;
-    look(model: string): PriceLookup;
+    look(model: string, serviceTier?: string, timestampMs?: number): PriceLookup;
     load(): Promise<void>;
     ensure(): Promise<boolean>;
     private get file();

package/dist/usage/pricing.js

@@ -50,6 +50,23 @@ export function parsePriceTable(document) {
             cacheWrite: rate(value.cache_creation_input_token_cost) ?? input * CACHE_WRITE_SHARE,
             cacheWrite1h: input * CACHE_WRITE_1H_SHARE
         };
+        const tiers = {};
+        for (const [tier, multiplier] of [
+            ['priority', 2],
+            ['flex', 0.5],
+            ['ultrafast', 6]
+        ]) {
+            tiers[tier] = {
+                input: rate(value[`input_cost_per_token_${tier}`]) ?? input * multiplier,
+                output: rate(value[`output_cost_per_token_${tier}`]) ?? output * multiplier,
+                cacheRead: rate(value[`cache_read_input_token_cost_${tier}`]) ?? price.cacheRead * multiplier,
+                cacheWrite: rate(value[`cache_creation_input_token_cost_${tier}`]) ?? price.cacheWrite * multiplier,
+                cacheWrite1h: price.cacheWrite1h * multiplier
+            };
+        }
+        if (value.litellm_provider === 'openai') {
+            price.tiers = tiers;
+        }
         const key = name.trim().toLowerCase();
         table.set(key, price);
         const bare = key.slice(key.lastIndexOf('/') + 1);
@@ -64,12 +81,23 @@ function withoutDate(key) {
     const match = /^(.*)-\d{6,8}$/.exec(key);
     return match === null ? null : match[1];
 }
-/*
- * Exact first, then the same name without its date, then the longest family the table knows. A name
- * nobody prices is left unpriced rather than guessed at: `$0.00` for a model that costs money is a
- * worse answer than a question mark.
- */
-export function lookupPrice(table, model) {
+// The internal review alias has no published price; expose ccusage's dated estimate as a family match.
+// https://github.com/ccusage/ccusage/blob/main/rust/adapters/codex/src/codex-auto-review-fallbacks.json
+const REVIEW_MODELS = [
+    ['2026-07-30', 'gpt-5.6-luna'],
+    ['2026-03-05', 'gpt-5.4'],
+    ['2026-02-05', 'gpt-5.3-codex'],
+    ['2025-12-11', 'gpt-5.2-codex'],
+    ['2025-11-13', 'gpt-5.1-codex'],
+    ['2025-09-15', 'gpt-5-codex'],
+    ['2025-08-07', 'gpt-5']
+];
+export function lookupPrice(table, model, serviceTier, timestampMs) {
+    const found = lookupBasePrice(table, model, timestampMs);
+    const tier = serviceTier === 'fast' ? 'priority' : serviceTier;
+    return { ...found, price: (tier === undefined ? undefined : found.price?.tiers?.[tier]) ?? found.price };
+}
+function lookupBasePrice(table, model, timestampMs) {
     const key = model.trim().toLowerCase().split('[')[0];
     const bare = key.slice(key.lastIndexOf('/') + 1);
     if (bare === '' || AMBIGUOUS.has(bare)) {
@@ -79,6 +107,12 @@ export function lookupPrice(table, model) {
     if (exact !== undefined) {
         return { price: exact, basis: 'exact', pricedAs: null };
     }
+    if (bare === 'codex-auto-review' && timestampMs !== undefined && Number.isFinite(timestampMs)) {
+        const date = new Date(timestampMs).toISOString().slice(0, 10);
+        const fallback = REVIEW_MODELS.find(([released]) => date >= released)?.[1] ?? 'gpt-5';
+        const found = lookupBasePrice(table, fallback);
+        return { price: found.price, basis: found.price === null ? 'unknown' : 'family', pricedAs: found.price === null ? null : fallback };
+    }
     const dated = withoutDate(bare);
     const undated = dated === null ? undefined : table.get(dated);
     if (undated !== undefined && dated !== null) {
@@ -128,8 +162,8 @@ export class PriceBook {
     get pricing() {
         return { source: this.table.size === 0 ? 'none' : this.source, fetchedAt: this.fetchedAt, models: this.table.size };
     }
-    look(model) {
-        return lookupPrice(this.table, model);
+    look(model, serviceTier, timestampMs) {
+        return lookupPrice(this.table, model, serviceTier, timestampMs);
     }
     /* Reads the table an earlier run stored, once; asking LiteLLM is left to `ensure`. */
     load() {

package/dist/usage/readers/codex.d.ts

@@ -16,6 +16,15 @@ export interface CodexParserState {
     suppressing: boolean;
     anchorMs: number;
     lastSignature: string | null;
+    serviceTier: string | null;
+    pendingCompactions: Record<string, {
+        record: UsageRecord;
+        counts: CodexCounts;
+        threadTotal: CodexCounts | null;
+    }>;
+    compacted: string[];
+    handledResponses: string[];
+    latestResponse: string | null;
 }
 export declare function createCodexState(): CodexParserState;
 export declare function cloneCodexState(state: CodexParserState): CodexParserState;

package/dist/usage/readers/codex.js

@@ -1,7 +1,6 @@
 import { asObject, asString, int } from '../record.js';
-/* A `token_count` line carries the counts; the other two carry the model and the directory they belong to. */
 export function codexMightCarryUsage(line) {
-    return line.includes('token_count') || line.includes('turn_context') || line.includes('session_meta');
+    return ['token_count', 'turn_context', 'session_meta', 'thread_settings_applied', 'token_usage_record', 'compacted'].some((type) => line.includes(type));
 }
 /* A fork replays its ancestors' events into the new file the moment it is created, so anything this
    close to the file's own start is a copy of work that was already counted somewhere else. */
@@ -15,11 +14,16 @@ export function createCodexState() {
         sawSessionMeta: false,
         suppressing: false,
         anchorMs: 0,
-        lastSignature: null
+        lastSignature: null,
+        serviceTier: null,
+        pendingCompactions: {},
+        compacted: [],
+        handledResponses: [],
+        latestResponse: null
     };
 }
 export function cloneCodexState(state) {
-    return { ...state, total: state.total === null ? null : { ...state.total } };
+    return structuredClone(state);
 }
 function countsOf(usage) {
     return {
@@ -52,13 +56,8 @@ export function isForkOrSubagent(payload) {
     const spawn = asObject(asObject(payload.source)?.subagent)?.thread_spawn;
     return typeof asObject(spawn)?.parent_thread_id === 'string';
 }
-/*
- * One line of `~/.codex/sessions/**\/*.jsonl`, against the state of the file it came from. Codex
- * reports a cumulative total per turn, so the call is the difference with the line before it; when
- * that difference falls the run started over and `last_token_usage` is the turn on its own. Codex
- * counts cache reads and writes inside `input_tokens`, unlike Anthropic, so what is left after
- * taking both out is the input that was actually paid for at the full rate.
- */
+/* Codex includes cache reads and writes in input_tokens. Compaction can appear separately from
+   cumulative token_count events, so response identities prevent charging the same request twice. */
 export function parseCodexLine(line, state) {
     let parsed;
     try {
@@ -97,6 +96,16 @@ export function parseCodexLine(line, state) {
         }
         return null;
     }
+    if (payload.type === 'thread_settings_applied') {
+        const settings = asObject(payload.thread_settings);
+        if (settings !== null && typeof settings.service_tier === 'string') {
+            state.serviceTier = settings.service_tier;
+        }
+        return null;
+    }
+    if (record.type === 'token_usage_record' || record.type === 'compacted') {
+        return parseCompaction(record, payload, state);
+    }
     if (payload.type !== 'token_count') {
         return null;
     }
@@ -129,6 +138,58 @@ export function parseCodexLine(line, state) {
         // The first event that is not part of the replayed burst is this thread's own work.
         state.suppressing = false;
     }
+    let dedupeKey = null;
+    const pending = state.latestResponse === null ? undefined : state.pendingCompactions[state.latestResponse];
+    if (pending !== undefined && (sameCounts(pending.counts, counts) || sameCounts(pending.threadTotal, cumulative))) {
+        dedupeKey = `codex:response:${state.latestResponse}`;
+        delete state.pendingCompactions[state.latestResponse];
+        state.handledResponses.push(state.latestResponse);
+    }
+    return usageRecord(counts, timestampMs, state.model, state, dedupeKey);
+}
+function sameCounts(first, second) {
+    return (first !== null &&
+        first.input === second.input &&
+        first.cached === second.cached &&
+        first.cacheWrite === second.cacheWrite &&
+        first.output === second.output &&
+        first.reasoning === second.reasoning);
+}
+function parseCompaction(record, payload, state) {
+    const id = asString(record.type === 'compacted' ? payload.compaction_response_id : payload.response_id);
+    if (id === '' || state.handledResponses.includes(id)) {
+        return null;
+    }
+    if (record.type === 'compacted') {
+        if (!state.compacted.includes(id)) {
+            state.compacted.push(id);
+        }
+    }
+    else {
+        const usage = asObject(payload.usage);
+        const model = asString(payload.model) || state.model;
+        const timestampMs = Date.parse(asString(record.timestamp));
+        if (usage === null || model === null || !Number.isFinite(timestampMs)) {
+            return null;
+        }
+        const counts = countsOf(usage);
+        const parsed = usageRecord(counts, timestampMs, model, state, `codex:response:${id}`);
+        if (parsed === null) {
+            return null;
+        }
+        state.latestResponse = id;
+        const threadTotal = asObject(payload.thread_token_usage);
+        state.pendingCompactions[id] ??= { record: parsed, counts, threadTotal: threadTotal === null ? null : countsOf(threadTotal) };
+    }
+    const pending = state.pendingCompactions[id];
+    if (!state.compacted.includes(id) || pending === undefined) {
+        return null;
+    }
+    state.handledResponses.push(id);
+    delete state.pendingCompactions[id];
+    return pending.record;
+}
+function usageRecord(counts, timestampMs, model, state, dedupeKey) {
     const uncached = Math.max(0, counts.input - counts.cached - counts.cacheWrite);
     const totals = {
         calls: 1,
@@ -145,11 +206,11 @@ export function parseCodexLine(line, state) {
     return {
         provider: 'codex',
         timestampMs,
-        model: state.model,
+        model,
         sessionId: state.sessionId,
         cwd: state.cwd,
         totals,
-        // Fork copies are gone by here, so every event that is left is a call of its own.
-        dedupeKey: null
+        ...(state.serviceTier === null ? {} : { serviceTier: state.serviceTier }),
+        dedupeKey
     };
 }

package/dist/usage/record.d.ts

@@ -8,6 +8,7 @@ export interface UsageRecord {
     account?: string;
     totals: UsageTotals;
     costUsd?: number;
+    serviceTier?: string;
     dedupeKey: string | null;
 }
 export declare function int(value: unknown): number;

package/dist/usage/scanner.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { mkdir, open, readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
+import { zstdDecompressSync } from 'node:zlib';
 import { errorText } from '../error-text.js';
 import { isNotFound, writeAtomic } from '../fs.js';
 import { decodeIndex, encodeIndex } from './index-file.js';
@@ -11,6 +12,7 @@ import { hostLogMightCarryUsage, parseHostUsageLine } from './readers/host-log.j
 import { cloneCodexState, codexMightCarryUsage, createCodexState, parseCodexLine } from './readers/codex.js';
 import { usageRoots } from './roots.js';
 const HASH_CHUNK_BYTES = 65536;
+const CODEX_PARSER_VERSION = 2;
 /*
  * Hashes the bytes before `from` and returns the rest, in one pass over one handle, so verifying
  * what a transcript committed and parsing what it added never reads a byte twice.
@@ -55,7 +57,7 @@ function readsWhole(provider) {
     return provider === 'grok';
 }
 function isUsageFile(provider, name) {
-    return readsWhole(provider) ? name === GROK_USAGE_FILE : name.endsWith('.jsonl');
+    return readsWhole(provider) ? name === GROK_USAGE_FILE : name.endsWith('.jsonl') || (provider === 'codex' && name.endsWith('.jsonl.zst'));
 }
 async function listUsageFiles(dir, provider, out = []) {
     let entries;
@@ -215,7 +217,12 @@ export class UsageScanner {
             }
             let failure = null;
             const accountOf = accountResolver(root, sessionAccounts);
-            for (const path of await listUsageFiles(root.path, root.provider)) {
+            const paths = await listUsageFiles(root.path, root.provider);
+            const plain = new Set(paths);
+            for (const path of paths) {
+                if (root.provider === 'codex' && path.endsWith('.jsonl.zst') && plain.has(path.slice(0, -4))) {
+                    continue;
+                }
                 files += 1;
                 try {
                     if (await this.readFileInto(path, root.provider, accountOf)) {
@@ -246,15 +253,31 @@ export class UsageScanner {
     }
     async readFileInto(path, provider, accountOf) {
         const info = await stat(path);
-        const known = this.index.get(path);
-        if (known !== undefined && known.provider === provider && known.size === info.size && known.mtimeMs === info.mtimeMs) {
+        const compressed = provider === 'codex' && path.endsWith('.jsonl.zst');
+        const key = compressed ? path.slice(0, -4) : path;
+        const known = this.index.get(key);
+        const currentParser = provider !== 'codex' || known?.parserVersion === CODEX_PARSER_VERSION;
+        if (currentParser &&
+            known !== undefined &&
+            known.provider === provider &&
+            (known.compressed ?? false) === compressed &&
+            known.size === info.size &&
+            known.mtimeMs === info.mtimeMs) {
             return false;
         }
         if (readsWhole(provider)) {
             return this.readWholeInto(path, provider, accountOf, info);
         }
-        const appended = known !== undefined && known.provider === provider && info.size > known.size && known.head?.startsWith('sha256:') === true;
-        let read = await readHashed(path, appended ? known.offset : 0);
+        const appended = !compressed &&
+            currentParser &&
+            known?.compressed !== true &&
+            known !== undefined &&
+            known.provider === provider &&
+            info.size > known.size &&
+            known.head?.startsWith('sha256:') === true;
+        let read = compressed
+            ? { bytes: zstdDecompressSync(await readFile(path)), hash: createHash('sha256') }
+            : await readHashed(path, appended ? known.offset : 0);
         // A file only counts as grown while it starts the way it did; one rewritten larger is read again from the start.
         const grown = appended && headOf(read.hash) === known.head;
         if (appended && !grown) {
@@ -273,9 +296,10 @@ export class UsageScanner {
             records: foldByKey([...before, ...withAccount(parsed.records, accountOf)]),
             tail: withAccount(parsed.tail, accountOf),
             codex: parsed.codex,
-            head: headOf(read.hash)
+            head: headOf(read.hash),
+            ...(provider === 'codex' ? { parserVersion: CODEX_PARSER_VERSION, compressed } : {})
         };
-        this.index.set(path, entry);
+        this.index.set(key, entry);
         this.dirty = true;
         return true;
     }

package/package.json

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

package/src/chat/acp-backend.ts

@@ -357,7 +357,9 @@ export class AcpBackend implements ChatBackend {
         const named: ChatAttachment[] = input.attachments.filter((attachment) => !images.includes(attachment));
         const parts = [this.contextPending, input.preamble, input.text, attachmentNote(named)].filter((part): part is string => part !== null && part !== '');
         this.contextPending = null;
-        return [{ type: 'text', text: parts.join('\n\n') }, ...blocks, ...this.mentionBlocks(input.mentions)];
+        const text = parts.join('\n\n');
+        this.protocol.prompted(text);
+        return [{ type: 'text', text }, ...blocks, ...this.mentionBlocks(input.mentions)];
     }
 
     /*
@@ -577,13 +579,17 @@ export class AcpBackend implements ChatBackend {
         this.emit({ type: 'exit', exitCode, ...(stderr === null ? {} : { stderr }) });
     }
 
-    /* A cancelled turn still spent what it reports. */
+    /* A cancelled turn still spent what it reports. A host that fails to keep it costs the record, never the end of the turn. */
     private report(result: unknown): void {
         const usage = this.spec.onUsage === undefined ? null : promptUsageOf(result);
         if (usage === null) {
             return;
         }
-        this.spec.onUsage?.({ ...usage, sessionId: this.sessionId, cwd: this.launch.cwd, model: this.model ?? this.launch.selection.model });
+        try {
+            this.spec.onUsage?.({ ...usage, sessionId: this.sessionId, cwd: this.launch.cwd, model: this.model ?? this.launch.selection.model });
+        } catch (error) {
+            console.warn(`Could not keep the usage of a ${this.spec.name} turn:`, errorText(error));
+        }
     }
 
     private emitAll(events: BackendEvent[]): void {

package/src/chat/acp-protocol.ts

@@ -1,6 +1,7 @@
 import { isRecord, type ChatFileChange, type RuntimeMode } from '@adecore/agent-contracts';
 import { z } from 'zod';
 import { MODE_ORDER } from '../modes.ts';
+import { cleanTitle } from '../title-file.ts';
 import type { ApprovalDecision, BackendEvent } from './backend.ts';
 
 /*
@@ -463,6 +464,13 @@ const KIND_NAMES: Record<string, string> = {
     other: 'Tool'
 };
 
+// A session's title comes from its opening prompts; later ones are not kept.
+const KEPT_PROMPTS = 3;
+
+function foldSpace(text: string): string {
+    return text.replace(/\s+/g, ' ').trim();
+}
+
 function str(value: unknown): string | null {
     return typeof value === 'string' && value !== '' ? value : null;
 }
@@ -598,6 +606,8 @@ export class AcpProtocol {
     private thought: { ref: string; text: string } | null = null;
     private counter = 0;
     private costUsd = 0;
+    // The opening prompts of the process, whitespace folded, which an agent may hand back as the session's title.
+    private readonly prompts: string[] = [];
 
     constructor(generation: number, modes: AcpModeMap, words: AcpStopWords) {
         this.generation = generation;
@@ -647,13 +657,31 @@ export class AcpProtocol {
                 }
                 return [{ type: 'usage', contextTokens: usage.data.used, contextWindow: usage.data.size, ...(cost === undefined ? {} : { costUsd: cost }) }];
             }
-            case 'session_info_update':
-                return str(update.title) === null ? [] : [{ type: 'title', title: update.title as string }];
+            case 'session_info_update': {
+                const title = cleanTitle(update.title);
+                return title === null || this.restatesPrompt(title) ? [] : [{ type: 'title', title }];
+            }
             default:
                 return [];
         }
     }
 
+    /* Notes a prompt sent to the agent, so a title that only repeats its start is not taken for a name. */
+    prompted(text: string): void {
+        if (this.prompts.length < KEPT_PROMPTS) {
+            this.prompts.push(foldSpace(text));
+        }
+    }
+
+    /*
+     * Whether a title is only the start of a prompt, as Copilot CLI 1.0.101 names a session: with a host's instructions in
+     * front of the message that names every chat after them, and it keeps the host from naming the chat itself.
+     */
+    private restatesPrompt(title: string): boolean {
+        const start = foldSpace(title.endsWith('…') ? title.slice(0, -1) : title);
+        return start !== '' && this.prompts.some((prompt) => prompt.startsWith(start));
+    }
+
     modeEvent(modeId: string): BackendEvent {
         const runtimeMode = runtimeModeOf(modeId, this.modes);
         return { type: 'permissions', permissionMode: modeId, ...(runtimeMode === null ? {} : { effectiveRuntimeMode: runtimeMode }) };

package/src/chat/chat-session.ts

@@ -36,6 +36,7 @@ import { ChatThread } from './thread.ts';
 import { UiReplies, type UiReplyHost } from './ui-replies.ts';
 import { errorText } from '../error-text.ts';
 import { systemClock, type OutboxClock } from '../outbox/outbox-worker.ts';
+import { cleanTitle } from '../title-file.ts';
 
 /* What a host keeps of a chat's turns in git (or anything like it), so a turn can show what it changed. */
 export interface TurnCheckpoints {
@@ -2171,8 +2172,10 @@ export class ChatSession {
             .catch(() => undefined);
     }
 
-    private applyTitle(title: string): void {
-        if (title === this.thread.info.suggestedTitle) {
+    private applyTitle(raw: string): void {
+        // Every info a client reads carries the title, so one it would refuse would leave the chat stuck there.
+        const title = cleanTitle(raw);
+        if (title === null || title === this.thread.info.suggestedTitle) {
             return;
         }
         this.emit([this.thread.patchInfo({ suggestedTitle: title })]);