praxis-agent 0.16.0 → 0.17.0

package/dist/application/session-service.js

@@ -30,7 +30,9 @@ import { ClaudeTaskToolRegistry } from '../tools/claude-task-tools.js';
 import { ClaudeWorkflowToolRegistry } from '../tools/claude-workflow-tools.js';
 import { WorkflowManager, } from './workflow-manager.js';
 import { SessionWorktreeManager } from './session-worktree.js';
+import { ClaudeSessionCostTracker, } from './session-cost-tracker.js';
 import { ClaudeWorktreeToolRegistry } from '../tools/claude-worktree-tools.js';
+import { completeMeteredModelRequest } from './metered-model-completion.js';
 import { FilteredToolRegistry } from '../tools/filtered-tool-registry.js';
 import { generateToolUseSummary } from './tool-use-summary.js';
 import { ClaudeUserMessageToolRegistry, CLAUDE_USER_MESSAGE_PROMPT, } from '../tools/claude-user-message.js';
@@ -62,11 +64,207 @@ const emptyToolRegistry = {
 function mergeUsage(left, right) {
     const cacheReadInputTokens = (left.cacheReadInputTokens ?? 0) + (right.cacheReadInputTokens ?? 0);
     const cacheCreationInputTokens = (left.cacheCreationInputTokens ?? 0) + (right.cacheCreationInputTokens ?? 0);
+    const webSearchRequests = (left.webSearchRequests ?? 0) + (right.webSearchRequests ?? 0);
     return {
         inputTokens: left.inputTokens + right.inputTokens,
         outputTokens: left.outputTokens + right.outputTokens,
         ...(cacheReadInputTokens === 0 ? {} : { cacheReadInputTokens }),
         ...(cacheCreationInputTokens === 0 ? {} : { cacheCreationInputTokens }),
+        ...(webSearchRequests === 0 ? {} : { webSearchRequests }),
+    };
+}
+const sessionUsageCounterFields = [
+    'inputTokens',
+    'outputTokens',
+    'cacheReadInputTokens',
+    'cacheCreationInputTokens',
+    'webSearchRequests',
+];
+const sessionUsageMetadataFields = ['contextWindow', 'maxOutputTokens'];
+function assertValidSessionUsageEntry(model, usage) {
+    if (model.trim() === '') {
+        throw new Error('Model usage breakdown contains a blank model name');
+    }
+    for (const field of sessionUsageCounterFields) {
+        const value = usage[field];
+        if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+            throw new Error(`Model usage for "${model}" has an invalid ${field} counter`);
+        }
+    }
+    for (const field of sessionUsageMetadataFields) {
+        const value = usage[field];
+        if (value !== undefined && (!Number.isSafeInteger(value) || value < 1)) {
+            throw new Error(`Model usage for "${model}" has an invalid ${field} metadata value`);
+        }
+    }
+}
+function mergeSessionUsageMetadata(model, left, right) {
+    const contextWindow = mergeSessionUsageMetadataField(model, 'contextWindow', left.contextWindow, right.contextWindow);
+    const maxOutputTokens = mergeSessionUsageMetadataField(model, 'maxOutputTokens', left.maxOutputTokens, right.maxOutputTokens);
+    return {
+        ...(contextWindow === undefined ? {} : { contextWindow }),
+        ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }),
+    };
+}
+function mergeSessionUsageMetadataField(model, field, left, right) {
+    if (left === undefined)
+        return right;
+    if (right === undefined)
+        return left;
+    if (left !== right) {
+        throw new Error(`Model usage for "${model}" has conflicting ${field} values: ${left} vs ${right}`);
+    }
+    return left;
+}
+function addSessionUsageChecked(model, left, right) {
+    const inputTokens = left.inputTokens + right.inputTokens;
+    const outputTokens = left.outputTokens + right.outputTokens;
+    const cacheReadInputTokens = (left.cacheReadInputTokens ?? 0) + (right.cacheReadInputTokens ?? 0);
+    const cacheCreationInputTokens = (left.cacheCreationInputTokens ?? 0) + (right.cacheCreationInputTokens ?? 0);
+    const webSearchRequests = (left.webSearchRequests ?? 0) + (right.webSearchRequests ?? 0);
+    if (!Number.isSafeInteger(inputTokens) ||
+        !Number.isSafeInteger(outputTokens) ||
+        !Number.isSafeInteger(cacheReadInputTokens) ||
+        !Number.isSafeInteger(cacheCreationInputTokens) ||
+        !Number.isSafeInteger(webSearchRequests)) {
+        throw new Error('Model usage total overflow');
+    }
+    const metadata = mergeSessionUsageMetadata(model, left, right);
+    return {
+        inputTokens,
+        outputTokens,
+        ...(cacheReadInputTokens === 0 ? {} : { cacheReadInputTokens }),
+        ...(cacheCreationInputTokens === 0 ? {} : { cacheCreationInputTokens }),
+        ...(webSearchRequests === 0 ? {} : { webSearchRequests }),
+        ...metadata,
+    };
+}
+function mergeSessionRawModelUsage(...parts) {
+    const rows = [];
+    for (const part of parts) {
+        if (part === undefined)
+            continue;
+        for (const [model, usage] of Object.entries(part)) {
+            assertValidSessionUsageEntry(model, usage);
+            rows.push([model, usage]);
+        }
+    }
+    if (rows.length === 0)
+        return undefined;
+    // Validate every pairwise counter/metadata/overflow merge across all rows
+    // before any row becomes observable so a malformed or conflicting batch never
+    // merges partially.
+    const preview = new Map();
+    for (const [model, usage] of rows) {
+        const existing = preview.get(model);
+        preview.set(model, existing === undefined
+            ? { ...usage }
+            : addSessionUsageChecked(model, existing, usage));
+    }
+    const merged = new Map();
+    for (const [model, usage] of rows) {
+        const existing = merged.get(model);
+        merged.set(model, existing === undefined
+            ? { ...usage }
+            : addSessionUsageChecked(model, existing, usage));
+    }
+    return Object.fromEntries(merged);
+}
+function hasNonZeroUsage(usage) {
+    return (usage.inputTokens > 0 ||
+        usage.outputTokens > 0 ||
+        (usage.cacheReadInputTokens ?? 0) > 0 ||
+        (usage.cacheCreationInputTokens ?? 0) > 0 ||
+        (usage.webSearchRequests ?? 0) > 0);
+}
+function requireUsageCounter(value, field) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new TypeError(`${field} must be a nonnegative safe integer`);
+    }
+}
+function requireManualCompactUsage(usage) {
+    requireUsageCounter(usage.inputTokens, 'usage.inputTokens');
+    requireUsageCounter(usage.outputTokens, 'usage.outputTokens');
+    if (usage.cacheReadInputTokens !== undefined) {
+        requireUsageCounter(usage.cacheReadInputTokens, 'usage.cacheReadInputTokens');
+    }
+    if (usage.cacheCreationInputTokens !== undefined) {
+        requireUsageCounter(usage.cacheCreationInputTokens, 'usage.cacheCreationInputTokens');
+    }
+    if (usage.webSearchRequests !== undefined) {
+        requireUsageCounter(usage.webSearchRequests, 'usage.webSearchRequests');
+    }
+}
+function requireCompactionDurations(result) {
+    const durationMs = result.durationMs;
+    if (typeof durationMs !== 'number' ||
+        !Number.isFinite(durationMs) ||
+        durationMs < 0) {
+        throw new TypeError('compaction durationMs must be a finite nonnegative number');
+    }
+    if (result.durationWithoutRetriesMs === undefined) {
+        return { durationMs, durationWithoutRetriesMs: durationMs };
+    }
+    const durationWithoutRetriesMs = result.durationWithoutRetriesMs;
+    if (typeof durationWithoutRetriesMs !== 'number' ||
+        !Number.isFinite(durationWithoutRetriesMs) ||
+        durationWithoutRetriesMs < 0) {
+        throw new TypeError('compaction durationWithoutRetriesMs must be a finite nonnegative number');
+    }
+    return { durationMs, durationWithoutRetriesMs };
+}
+function addToolDuration(value, total) {
+    if (value === undefined)
+        return total;
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        throw new TypeError('durationToolMs must be a finite nonnegative number');
+    }
+    const next = total + value;
+    if (!Number.isFinite(next) || next < 0) {
+        throw new TypeError('durationToolMs total overflow');
+    }
+    return next;
+}
+function addApiDuration(value, total, field) {
+    if (value === undefined)
+        return total;
+    if (!Number.isFinite(value) || value < 0) {
+        throw new TypeError(`${field} must be a finite nonnegative number`);
+    }
+    const next = total + value;
+    if (!Number.isFinite(next) || next < 0) {
+        throw new TypeError(`${field} total overflow`);
+    }
+    return next;
+}
+function createLineCountAccumulator() {
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    const addCounter = (current, value, field) => {
+        if (value === undefined)
+            return current;
+        if (!Number.isSafeInteger(value) || value < 0) {
+            throw new TypeError(`${field} must be a nonnegative safe integer`);
+        }
+        const next = current + value;
+        if (!Number.isSafeInteger(next) || next < 0) {
+            throw new TypeError(`${field} total must be a nonnegative safe integer`);
+        }
+        return next;
+    };
+    return {
+        get linesAdded() {
+            return linesAdded;
+        },
+        get linesRemoved() {
+            return linesRemoved;
+        },
+        add(input) {
+            if (input.isError)
+                return;
+            linesAdded = addCounter(linesAdded, input.linesAdded, 'linesAdded');
+            linesRemoved = addCounter(linesRemoved, input.linesRemoved, 'linesRemoved');
+        },
     };
 }
 export function workflowTokenTarget(prompt) {
@@ -121,6 +319,9 @@ export class ClaudeSessionService {
     downloadedFileResourceSessions = new Set();
     activeProvider;
     mcpClosePromise;
+    sessionCostTrackers = new Map();
+    activeCostSessionId;
+    closeCostSavePromise;
     runtimeCwd;
     constructor(options) {
         this.options = options;
@@ -209,6 +410,8 @@ export class ClaudeSessionService {
         this.hostedSubagents.clear();
         this.backgroundTasks.clear();
         await this.workflowManager?.close();
+        this.closeCostSavePromise ??= this.persistActiveSessionCost();
+        await this.closeCostSavePromise;
         this.mcpClosePromise ??= this.options.mcp?.close?.() ?? Promise.resolve();
         await this.mcpClosePromise;
     }
@@ -456,30 +659,37 @@ export class ClaudeSessionService {
         const budget = this.contextBudget(provider);
         if (budget)
             budget.assertFits(budget.evaluate(messages));
-        let text = '';
-        let usage = { inputTokens: 0, outputTokens: 0 };
-        for await (const event of provider.complete({
+        await this.activateSessionCostTracker(activeSessionId);
+        const model = provider.model !== undefined && provider.model.trim() !== ''
+            ? provider.model
+            : 'praxis/provider';
+        const metrics = await completeMeteredModelRequest(provider, {
             messages,
             ...(this.options.effort ? { effort: this.options.effort } : {}),
             ...(signal ? { signal } : {}),
-        })) {
-            if (event.type === 'text-delta') {
-                text += event.delta;
-                onDelta?.(event.delta);
-            }
-            else if (event.type === 'usage') {
-                usage = event.usage;
-            }
-            else if (event.type === 'tool-call') {
-                throw new Error('Side questions cannot call tools; press f to fork');
-            }
+        }, {
+            ...(onDelta ? { onTextDelta: onDelta } : {}),
+            onMetrics: (recorded) => this.recordAuxiliaryMetrics(activeSessionId, recorded),
+        });
+        if (metrics.toolCalls.length > 0) {
+            throw new Error('Side questions cannot call tools; press f to fork');
         }
-        const pricing = this.options.pricing?.resolve(provider.model ?? 'praxis/provider');
+        const pricing = this.options.pricing?.resolve(model);
+        const costUsd = pricing ? usageCostUsd(metrics.usage, pricing) : undefined;
         return {
             sessionId: activeSessionId,
-            text,
-            usage,
-            ...(pricing ? { costUsd: usageCostUsd(usage, pricing) } : {}),
+            text: metrics.text,
+            usage: metrics.usage,
+            ...(costUsd === undefined ? {} : { costUsd }),
+            ...(hasNonZeroUsage(metrics.usage)
+                ? { modelUsage: { [model]: metrics.usage } }
+                : {}),
+            ...(metrics.durationApiMs === 0
+                ? {}
+                : {
+                    durationApiMs: metrics.durationApiMs,
+                    durationApiWithoutRetriesMs: metrics.durationApiWithoutRetriesMs,
+                }),
         };
     }
     async forkSideQuestion(sessionId, question, signal) {
@@ -570,21 +780,20 @@ export class ClaudeSessionService {
                 tools: mainAgentToolNames(this.options.tools, agent),
             })
             : this.options.tools;
-        let suggestion = '';
-        for await (const event of provider.complete({
+        await this.activateSessionCostTracker(sessionId);
+        const metrics = await completeMeteredModelRequest(provider, {
             messages,
             ...(provider.capabilities.tools
                 ? { tools: suggestionTools?.definitions() ?? [] }
                 : {}),
             ...(this.options.effort ? { effort: this.options.effort } : {}),
             ...(signal ? { signal } : {}),
-        })) {
-            if (event.type === 'text-delta')
-                suggestion += event.delta;
-            if (event.type === 'tool-call')
-                return null;
-        }
-        return validPromptSuggestion(suggestion);
+        }, {
+            onMetrics: (recorded) => this.recordAuxiliaryMetrics(sessionId, recorded),
+        });
+        if (metrics.toolCalls.length > 0)
+            return null;
+        return validPromptSuggestion(metrics.text);
     }
     async sessionNameSuggestion(sessionId, signal) {
         const provider = this.provider();
@@ -592,21 +801,20 @@ export class ClaudeSessionService {
         if (loaded.status === 'conflict' || loaded.value.entries.length === 0) {
             return null;
         }
-        let suggestion = '';
-        for await (const event of provider.complete({
+        await this.activateSessionCostTracker(sessionId);
+        const metrics = await completeMeteredModelRequest(provider, {
             messages: [
                 ...projectClaudeModelMessages(loaded.value.entries),
                 { role: 'user', content: SESSION_NAME_INSTRUCTION },
             ],
             ...(this.options.effort ? { effort: this.options.effort } : {}),
             ...(signal ? { signal } : {}),
-        })) {
-            if (event.type === 'text-delta')
-                suggestion += event.delta;
-            if (event.type === 'tool-call')
-                return null;
-        }
-        return validSessionName(suggestion);
+        }, {
+            onMetrics: (recorded) => this.recordAuxiliaryMetrics(sessionId, recorded),
+        });
+        if (metrics.toolCalls.length > 0)
+            return null;
+        return validSessionName(metrics.text);
     }
     async sessions() {
         const paths = this.paths(randomUUID());
@@ -1043,6 +1251,7 @@ export class ClaudeSessionService {
             if (snapshot.entries.length === 0) {
                 throw new Error(`Claude session not found: ${sessionId}`);
             }
+            await this.activateSessionCostTracker(sessionId);
             const activeEntries = selectClaudeActiveTranscript(snapshot.entries);
             const allMessages = projectClaudeModelMessages(activeEntries);
             let selectedEntries = activeEntries;
@@ -1100,12 +1309,55 @@ export class ClaudeSessionService {
             });
             if (signal?.aborted)
                 throw new AgentRunCancelledError();
-            const preTokens = estimateModelRequestTokens(allMessages);
+            const { durationMs: compactedDurationMs, durationWithoutRetriesMs: compactedDurationWithoutRetriesMs, } = requireCompactionDurations(compacted);
+            requireManualCompactUsage(compacted.usage);
+            const compactorModel = compacted.model;
+            const compactModel = compactorModel !== undefined && compactorModel.trim() !== ''
+                ? compactorModel
+                : provider.model;
             const summary = compacted.summary;
+            const meaningfulMetering = summary.trim().length > 0 &&
+                (hasNonZeroUsage(compacted.usage) || compactedDurationMs > 0);
+            if (meaningfulMetering &&
+                (compactModel === undefined || compactModel.trim() === '')) {
+                throw new Error('Manual compact usage requires a nonblank model identity');
+            }
+            const preTokens = estimateModelRequestTokens(allMessages);
             const preservedMessages = projectClaudeModelMessages(preservedEntries);
             const boundaryUuid = randomUUID();
             const summaryUuid = randomUUID();
             const uuids = [boundaryUuid, summaryUuid];
+            let meteringTurnInput;
+            if (meaningfulMetering &&
+                compactModel !== undefined &&
+                compactModel.trim() !== '') {
+                const tracker = this.sessionCostTrackers.get(sessionId);
+                if (!tracker) {
+                    throw new Error(`Session cost tracker is not active for session ${sessionId}`);
+                }
+                const pricing = this.options.pricing?.resolve(compactModel);
+                const costUsd = pricing
+                    ? usageCostUsd(compacted.usage, pricing)
+                    : undefined;
+                meteringTurnInput = {
+                    model: compactModel,
+                    usage: compacted.usage,
+                    ...(costUsd === undefined ? {} : { costUsd }),
+                    ...(compacted.usage.webSearchRequests === undefined
+                        ? {}
+                        : { webSearchRequests: compacted.usage.webSearchRequests }),
+                    apiDurationMs: compactedDurationMs,
+                    apiDurationWithoutRetriesMs: compactedDurationWithoutRetriesMs,
+                };
+                // Preflight the exact record input against a clone of the live
+                // tracker so a cumulative total overflow rejects before the compact
+                // boundary is appended rather than after a half-commit.
+                const preflight = new ClaudeSessionCostTracker({
+                    sessionId,
+                    restored: tracker.snapshot(),
+                });
+                preflight.recordTurn(meteringTurnInput);
+            }
             const entries = createClaudeCompactEntries({
                 sessionId,
                 logicalParentUuid,
@@ -1116,7 +1368,7 @@ export class ClaudeSessionService {
                     ...preservedMessages,
                 ]),
                 previousCumulativeDroppedTokens: getCumulativeDroppedTokens(snapshot.entries),
-                durationMs: compacted.durationMs,
+                durationMs: compactedDurationMs,
                 cwd: this.activeCwd(),
                 claudeVersion: this.options.claudeVersion,
                 gitBranch: null,
@@ -1142,6 +1394,13 @@ export class ClaudeSessionService {
                 preTokens,
                 uuid: boundaryUuid,
             });
+            if (meteringTurnInput !== undefined) {
+                const tracker = this.sessionCostTrackers.get(sessionId);
+                if (!tracker) {
+                    throw new Error(`Session cost tracker is not active for session ${sessionId}`);
+                }
+                tracker.recordTurn(meteringTurnInput);
+            }
             return {
                 summary,
                 usage: compacted.usage,
@@ -1306,6 +1565,83 @@ export class ClaudeSessionService {
             throw new Error(`Claude permission mode update conflict: ${result.reason}`);
         }
     }
+    async activateSessionCostTracker(sessionId) {
+        if (this.activeCostSessionId === sessionId)
+            return;
+        const store = this.options.costStateStore;
+        if (store) {
+            // Load the target native state before any save so the single
+            // `.claude.json` slot is not overwritten before it is read.
+            const loaded = await store.load(sessionId);
+            const currentId = this.activeCostSessionId;
+            if (currentId !== undefined) {
+                const current = this.sessionCostTrackers.get(currentId);
+                if (current)
+                    await store.save(current.snapshot());
+            }
+            if (!this.sessionCostTrackers.has(sessionId)) {
+                this.sessionCostTrackers.set(sessionId, new ClaudeSessionCostTracker({
+                    sessionId,
+                    ...(loaded ? { restored: loaded } : {}),
+                }));
+            }
+        }
+        else if (!this.sessionCostTrackers.has(sessionId)) {
+            this.sessionCostTrackers.set(sessionId, new ClaudeSessionCostTracker({ sessionId }));
+        }
+        this.activeCostSessionId = sessionId;
+    }
+    persistActiveSessionCost() {
+        const store = this.options.costStateStore;
+        const activeId = this.activeCostSessionId;
+        if (!store || activeId === undefined)
+            return Promise.resolve();
+        const tracker = this.sessionCostTrackers.get(activeId);
+        if (!tracker)
+            return Promise.resolve();
+        return store.save(tracker.snapshot());
+    }
+    recordAuxiliaryMetrics(sessionId, metrics) {
+        const tracker = this.sessionCostTrackers.get(sessionId);
+        if (!tracker) {
+            throw new Error(`Session cost tracker is not active for session ${sessionId}`);
+        }
+        const model = metrics.model !== undefined && metrics.model.trim() !== ''
+            ? metrics.model
+            : 'praxis/provider';
+        if (hasNonZeroUsage(metrics.usage)) {
+            const pricing = this.options.pricing?.resolve(model);
+            const costUsd = pricing ? usageCostUsd(metrics.usage, pricing) : undefined;
+            tracker.recordTurn({
+                model,
+                usage: metrics.usage,
+                ...(costUsd === undefined ? {} : { costUsd }),
+                ...(metrics.usage.webSearchRequests === undefined
+                    ? {}
+                    : { webSearchRequests: metrics.usage.webSearchRequests }),
+                apiDurationMs: metrics.durationApiMs,
+                apiDurationWithoutRetriesMs: metrics.durationApiWithoutRetriesMs,
+            });
+            return;
+        }
+        tracker.recordDurations({
+            apiDurationMs: metrics.durationApiMs,
+            apiDurationWithoutRetriesMs: metrics.durationApiWithoutRetriesMs,
+        });
+    }
+    async costSnapshot(sessionId) {
+        const existing = this.sessionCostTrackers.get(sessionId);
+        if (existing)
+            return existing.snapshot();
+        const store = this.options.costStateStore;
+        const loaded = store ? await store.load(sessionId) : null;
+        const tracker = new ClaudeSessionCostTracker({
+            sessionId,
+            ...(loaded ? { restored: loaded } : {}),
+        });
+        this.sessionCostTrackers.set(sessionId, tracker);
+        return tracker.snapshot();
+    }
     async executeTurn(sessionId, prompt, requireExisting, signal, name, images = [], documents = [], resumeSessionAt, shellCommand, skipUserPrompt = false) {
         this.assertWritable();
         if (prompt.length === 0 && images.length === 0 && documents.length === 0)
@@ -1316,6 +1652,7 @@ export class ClaudeSessionService {
         if (shellCommand !== undefined && shellCommand.trim().length === 0) {
             throw new Error('Shell command must not be empty');
         }
+        await this.activateSessionCostTracker(sessionId);
         await this.ensureFileResources(sessionId, signal);
         this.worktreeManager?.bindSession(sessionId);
         if (this.options.initialWorktree) {
@@ -1540,6 +1877,13 @@ export class ClaudeSessionService {
                         : {}),
                     permissionUpdates: () => this.sessionPermissionUpdates.get(sessionId) ?? [],
                     onPermissionUpdates: (updates) => this.applyPermissionUpdates(sessionId, updates),
+                    onLineChanges: (changes) => {
+                        const tracker = this.sessionCostTrackers.get(sessionId);
+                        if (!tracker) {
+                            throw new Error(`Session cost tracker is not active for session ${sessionId}`);
+                        }
+                        tracker.recordLineChanges(changes);
+                    },
                     ...(this.options.eventSink
                         ? { eventSink: this.options.eventSink }
                         : {}),
@@ -1665,7 +2009,7 @@ export class ClaudeSessionService {
                 emitInitialContextState: false,
                 ...(this.options.emitToolUseSummaries
                     ? {
-                        generateToolUseSummary: ({ tools, lastAssistantText, signal }) => generateToolUseSummary(provider, tools, signal, lastAssistantText),
+                        generateToolUseSummary: ({ tools, lastAssistantText, signal }) => generateToolUseSummary(provider, tools, signal, lastAssistantText, (metrics) => this.recordAuxiliaryMetrics(sessionId, metrics)),
                     }
                     : {}),
                 ...(this.options.pricing
@@ -1837,10 +2181,12 @@ export class ClaudeSessionService {
                     throw new Error(`Claude session tool call ${unresolvedToolCall.id} requires explicit recovery approval`);
                 }
                 const recoveryResults = await runtime.recoverToolCalls(unresolvedToolCalls, recoveryRequest);
-                const recoveryUsage = recoveryResults.reduce((usage, result) => ({
-                    inputTokens: usage.inputTokens + (result.usage?.inputTokens ?? 0),
-                    outputTokens: usage.outputTokens + (result.usage?.outputTokens ?? 0),
-                }), { inputTokens: 0, outputTokens: 0 });
+                const recoveryUsage = recoveryResults.reduce((usage, result) => result.usage ? mergeUsage(usage, result.usage) : usage, { inputTokens: 0, outputTokens: 0 });
+                const recoveryModelUsage = mergeSessionRawModelUsage(...recoveryResults.map((result) => result.isError ? undefined : result.modelUsage));
+                const foregroundLineChanges = createLineCountAccumulator();
+                for (const result of recoveryResults) {
+                    foregroundLineChanges.add(result);
+                }
                 if (this.options.agent &&
                     agent &&
                     getClaudeAgentSetting(snapshot.entries) !== this.options.agent) {
@@ -1904,6 +2250,9 @@ export class ClaudeSessionService {
                     inputTokens: 0,
                     outputTokens: 0,
                 };
+                let compactionDurationMs;
+                let compactionDurationWithoutRetriesMs;
+                let compactionModelUsage;
                 const definitions = provider.capabilities.tools
                     ? (structuredTools?.definitions() ?? [])
                     : [];
@@ -2015,6 +2364,16 @@ export class ClaudeSessionService {
                         contextWindowTokens: budget.contextWindowTokens,
                         ...(signal ? { signal } : {}),
                     });
+                    const { durationMs: compactedDurationMs, durationWithoutRetriesMs: compactedDurationWithoutRetriesMs, } = requireCompactionDurations(compacted);
+                    const proposedCompactionDurationMs = (compactionDurationMs ?? 0) + compactedDurationMs;
+                    if (!Number.isFinite(proposedCompactionDurationMs)) {
+                        throw new TypeError('compaction durationMs total overflow');
+                    }
+                    const proposedCompactionDurationWithoutRetriesMs = (compactionDurationWithoutRetriesMs ?? 0) +
+                        compactedDurationWithoutRetriesMs;
+                    if (!Number.isFinite(proposedCompactionDurationWithoutRetriesMs)) {
+                        throw new TypeError('compaction durationWithoutRetriesMs total overflow');
+                    }
                     const boundaryUuid = randomUUID();
                     const summaryUuid = randomUUID();
                     const timestamp = new Date().toISOString();
@@ -2028,7 +2387,7 @@ export class ClaudeSessionService {
                             preTokens,
                             postTokens,
                             previousCumulativeDroppedTokens: getCumulativeDroppedTokens(snapshot.entries),
-                            durationMs: compacted.durationMs,
+                            durationMs: compactedDurationMs,
                             cwd: this.activeCwd(),
                             claudeVersion: this.options.claudeVersion,
                             gitBranch: null,
@@ -2071,6 +2430,59 @@ export class ClaudeSessionService {
                     ];
                     if (signal?.aborted)
                         throw new AgentRunCancelledError();
+                    // Construct the exact tracker mutations for this single committed
+                    // boundary and preflight them against a clone of the live tracker so
+                    // invalid input or cumulative overflow rejects before the compact
+                    // boundary is appended rather than after a half-commit.
+                    const tracker = this.sessionCostTrackers.get(sessionId);
+                    if (!tracker) {
+                        throw new Error(`Session cost tracker is not active for session ${sessionId}`);
+                    }
+                    const compactModel = compacted.model !== undefined && compacted.model.trim() !== ''
+                        ? compacted.model
+                        : provider.model;
+                    const compactModelNonBlank = compactModel !== undefined && compactModel.trim() !== '';
+                    if (hasNonZeroUsage(compacted.usage) && !compactModelNonBlank) {
+                        throw new Error('Auto compact usage requires a nonblank model identity');
+                    }
+                    let meteringTurnInput;
+                    if (compactModelNonBlank && hasNonZeroUsage(compacted.usage)) {
+                        const pricing = this.options.pricing?.resolve(compactModel);
+                        const costUsd = pricing
+                            ? usageCostUsd(compacted.usage, pricing)
+                            : undefined;
+                        meteringTurnInput = {
+                            model: compactModel,
+                            usage: compacted.usage,
+                            ...(costUsd === undefined ? {} : { costUsd }),
+                            ...(compacted.usage.webSearchRequests === undefined
+                                ? {}
+                                : { webSearchRequests: compacted.usage.webSearchRequests }),
+                        };
+                    }
+                    let meteringDurationsInput;
+                    if (compactedDurationMs > 0 ||
+                        compactedDurationWithoutRetriesMs > 0) {
+                        meteringDurationsInput = {
+                            ...(compactedDurationMs === 0
+                                ? {}
+                                : { apiDurationMs: compactedDurationMs }),
+                            apiDurationWithoutRetriesMs: compactedDurationWithoutRetriesMs,
+                        };
+                    }
+                    if (meteringTurnInput !== undefined ||
+                        meteringDurationsInput !== undefined) {
+                        const preflight = new ClaudeSessionCostTracker({
+                            sessionId,
+                            restored: tracker.snapshot(),
+                        });
+                        if (meteringTurnInput !== undefined) {
+                            preflight.recordTurn(meteringTurnInput);
+                        }
+                        if (meteringDurationsInput !== undefined) {
+                            preflight.recordDurations(meteringDurationsInput);
+                        }
+                    }
                     const appendResult = await lease.appendMany(snapshot.tail, entries);
                     if (appendResult.status === 'conflict') {
                         throw new Error(`Claude transcript append conflict: ${appendResult.reason}`);
@@ -2086,10 +2498,22 @@ export class ClaudeSessionService {
                         uuid: boundaryUuid,
                     });
                     compactionAnchorUuid = compactSummaryUuid;
-                    compactionUsage = {
-                        inputTokens: compactionUsage.inputTokens + compacted.usage.inputTokens,
-                        outputTokens: compactionUsage.outputTokens + compacted.usage.outputTokens,
-                    };
+                    compactionUsage = mergeUsage(compactionUsage, compacted.usage);
+                    compactionDurationMs = proposedCompactionDurationMs;
+                    compactionDurationWithoutRetriesMs =
+                        proposedCompactionDurationWithoutRetriesMs;
+                    if (meteringTurnInput !== undefined) {
+                        compactionModelUsage = mergeSessionRawModelUsage(compactionModelUsage, { [meteringTurnInput.model]: compacted.usage });
+                    }
+                    // Commit the preflighted mutations once the boundary is durable so a
+                    // later main-provider failure or cancellation cannot lose the
+                    // compactor's usage/cost/API durations.
+                    if (meteringTurnInput !== undefined) {
+                        tracker.recordTurn(meteringTurnInput);
+                    }
+                    if (meteringDurationsInput !== undefined) {
+                        tracker.recordDurations(meteringDurationsInput);
+                    }
                 };
                 await compactIfNeeded(pendingUserMessages);
                 for (const [index, message] of expandedMessages.entries()) {
@@ -2146,6 +2570,7 @@ export class ClaudeSessionService {
                     }
                 }
                 let shellUsage = { inputTokens: 0, outputTokens: 0 };
+                let shellModelUsage;
                 if (shellCommand !== undefined) {
                     const call = {
                         id: `shell_${randomUUID().replaceAll('-', '')}`,
@@ -2184,6 +2609,10 @@ export class ClaudeSessionService {
                         throw error;
                     }
                     shellUsage = shellResult.usage ?? shellUsage;
+                    if (!shellResult.isError) {
+                        shellModelUsage = shellResult.modelUsage;
+                        foregroundLineChanges.add(shellResult);
+                    }
                     const stdout = shellResult.processOutput?.stdout ??
                         (shellResult.isError ? '' : shellResult.content);
                     const stderr = shellResult.processOutput?.stderr ??
@@ -2240,7 +2669,9 @@ export class ClaudeSessionService {
                         ? { maxModelTurns: this.options.maxModelTurns }
                         : {}),
                     ...(this.options.betas?.length ? { betas: this.options.betas } : {}),
-                    ...(this.options.collectMetrics ? { collectMetrics: true } : {}),
+                    ...(this.options.collectMetrics || this.options.costStateStore
+                        ? { collectMetrics: true }
+                        : {}),
                     reloadMessages: async () => {
                         await compactIfNeeded([], currentTurnUserMessages ?? []);
                         return [
@@ -2282,16 +2713,40 @@ export class ClaudeSessionService {
                                 if (scheduled) {
                                     messages.push(...scheduled.map(({ prompt }) => prompt));
                                 }
+                                const batchUsage = background || workflow
+                                    ? mergeUsage(background?.usage ?? {
+                                        inputTokens: 0,
+                                        outputTokens: 0,
+                                    }, workflow?.usage ?? {
+                                        inputTokens: 0,
+                                        outputTokens: 0,
+                                    })
+                                    : undefined;
+                                const batchModelUsage = mergeSessionRawModelUsage(background?.modelUsage, workflow?.modelUsage);
+                                const batchDurationApiMs = addApiDuration(workflow?.durationApiMs, addApiDuration(background?.durationApiMs, 0, 'durationApiMs'), 'durationApiMs');
+                                const backgroundDurationWithoutRetries = background?.durationApiWithoutRetriesMs ??
+                                    background?.durationApiMs;
+                                const workflowDurationWithoutRetries = workflow?.durationApiWithoutRetriesMs ??
+                                    workflow?.durationApiMs;
+                                const batchDurationApiWithoutRetriesMs = addApiDuration(workflowDurationWithoutRetries, addApiDuration(backgroundDurationWithoutRetries, 0, 'durationApiWithoutRetriesMs'), 'durationApiWithoutRetriesMs');
+                                const hasBatchDuration = background?.durationApiMs !== undefined ||
+                                    background?.durationApiWithoutRetriesMs !== undefined ||
+                                    workflow?.durationApiMs !== undefined ||
+                                    workflow?.durationApiWithoutRetriesMs !== undefined;
                                 return {
                                     messages,
-                                    ...(background || workflow
+                                    ...(batchUsage
                                         ? {
-                                            usage: {
-                                                inputTokens: (background?.usage.inputTokens ?? 0) +
-                                                    (workflow?.usage.inputTokens ?? 0),
-                                                outputTokens: (background?.usage.outputTokens ?? 0) +
-                                                    (workflow?.usage.outputTokens ?? 0),
-                                            },
+                                            usage: batchUsage,
+                                            ...(batchModelUsage
+                                                ? { modelUsage: batchModelUsage }
+                                                : {}),
+                                        }
+                                        : {}),
+                                    ...(hasBatchDuration
+                                        ? {
+                                            durationApiMs: batchDurationApiMs,
+                                            durationApiWithoutRetriesMs: batchDurationApiWithoutRetriesMs,
                                         }
                                         : {}),
                                 };
@@ -2322,26 +2777,96 @@ export class ClaudeSessionService {
                     }));
                 }
                 const totalUsage = mergeUsage(mergeUsage(mergeUsage(recoveryUsage, compactionUsage), shellUsage), result.usage);
+                const tracker = this.sessionCostTrackers.get(sessionId);
+                if (!tracker) {
+                    throw new Error(`Session cost tracker is not active for session ${sessionId}`);
+                }
+                const turnModelUsage = mergeSessionRawModelUsage(recoveryModelUsage, compactionModelUsage, shellModelUsage, result.modelUsage);
+                const combinedDurationMs = compactionDurationMs === undefined &&
+                    result.durationApiMs === undefined
+                    ? undefined
+                    : (compactionDurationMs ?? 0) + (result.durationApiMs ?? 0);
+                let rawCostUsd;
+                if (turnModelUsage) {
+                    for (const [model, usage] of Object.entries(turnModelUsage)) {
+                        const pricing = this.options.pricing?.resolve(model);
+                        const costUsd = pricing ? usageCostUsd(usage, pricing) : undefined;
+                        if (costUsd !== undefined)
+                            rawCostUsd = (rawCostUsd ?? 0) + costUsd;
+                    }
+                }
+                // Auto-compaction metering was already recorded atomically with each
+                // committed boundary, and externally metered tool-summary metrics were
+                // committed through the summary callback, so the live tracker receives
+                // only the unrecorded subset here. The inclusive public aggregates
+                // above still contain every row and duration.
+                const trackedModelUsage = mergeSessionRawModelUsage(recoveryModelUsage, shellModelUsage, result.unrecordedModelUsage ?? result.modelUsage);
+                if (trackedModelUsage) {
+                    for (const [model, usage] of Object.entries(trackedModelUsage)) {
+                        const pricing = this.options.pricing?.resolve(model);
+                        const costUsd = pricing ? usageCostUsd(usage, pricing) : undefined;
+                        tracker.recordTurn({
+                            model,
+                            usage,
+                            ...(costUsd === undefined ? {} : { costUsd }),
+                            ...(usage.webSearchRequests === undefined
+                                ? {}
+                                : { webSearchRequests: usage.webSearchRequests }),
+                        });
+                    }
+                }
+                let combinedToolDurationMs = 0;
+                for (const recoveryResult of recoveryResults) {
+                    combinedToolDurationMs = addToolDuration(recoveryResult.durationToolMs, combinedToolDurationMs);
+                }
+                combinedToolDurationMs = addToolDuration(result.durationToolMs, combinedToolDurationMs);
+                const trackedDurationApiMs = result.unrecordedDurationApiMs ?? result.durationApiMs;
+                const trackedDurationApiWithoutRetriesMs = result.unrecordedDurationApiWithoutRetriesMs ??
+                    result.durationApiWithoutRetriesMs;
+                tracker.recordDurations({
+                    ...(trackedDurationApiMs === undefined
+                        ? {}
+                        : { apiDurationMs: trackedDurationApiMs }),
+                    ...(trackedDurationApiWithoutRetriesMs === undefined
+                        ? {}
+                        : {
+                            apiDurationWithoutRetriesMs: trackedDurationApiWithoutRetriesMs,
+                        }),
+                    ...(combinedToolDurationMs === 0
+                        ? {}
+                        : { toolDurationMs: combinedToolDurationMs }),
+                });
+                foregroundLineChanges.add({
+                    isError: false,
+                    ...(result.linesAdded === undefined
+                        ? {}
+                        : { linesAdded: result.linesAdded }),
+                    ...(result.linesRemoved === undefined
+                        ? {}
+                        : { linesRemoved: result.linesRemoved }),
+                });
+                if (foregroundLineChanges.linesAdded !== 0 ||
+                    foregroundLineChanges.linesRemoved !== 0) {
+                    tracker.recordLineChanges({
+                        ...(foregroundLineChanges.linesAdded === 0
+                            ? {}
+                            : { linesAdded: foregroundLineChanges.linesAdded }),
+                        ...(foregroundLineChanges.linesRemoved === 0
+                            ? {}
+                            : { linesRemoved: foregroundLineChanges.linesRemoved }),
+                    });
+                }
                 return {
                     sessionId,
                     text: structuredCapture && structuredCapture.calls === 1
                         ? JSON.stringify(structuredCapture.value)
                         : result.text,
                     usage: totalUsage,
-                    ...(result.durationApiMs === undefined
+                    ...(combinedDurationMs === undefined
                         ? {}
-                        : { durationApiMs: result.durationApiMs }),
-                    ...(this.options.pricing
-                        ? (() => {
-                            const pricing = this.options.pricing?.resolve(provider.model ?? 'praxis/provider');
-                            return pricing
-                                ? { costUsd: usageCostUsd(result.usage, pricing) }
-                                : {};
-                        })()
-                        : {}),
-                    ...(provider.model
-                        ? { modelUsage: { [provider.model]: result.usage } }
-                        : {}),
+                        : { durationApiMs: combinedDurationMs }),
+                    ...(rawCostUsd === undefined ? {} : { costUsd: rawCostUsd }),
+                    ...(turnModelUsage ? { modelUsage: { ...turnModelUsage } } : {}),
                     ...(structuredCapture && structuredCapture.calls === 1
                         ? { structuredOutput: structuredCapture.value }
                         : {}),