Equality check omits the cost sub-object

The fast-path equality check compares the five numeric fields but never checks whether the cost sub-object is present. AssistantUsageSnapshot requires cost: { input, output, cacheRead, cacheWrite, total } (see usage.ts makeZeroUsageSnapshot). A message that arrives with all five numeric fields already correct but with cost absent (or undefined) will satisfy every condition here and be skipped without normalization — leaving cost absent downstream.

If any consumer later does usage.cost.total (or similar) on such a message it will crash with the same class of TypeError this PR is fixing for totalTokens.

Consider adding a cost presence guard to the skip condition:

This is a comment left during a code review.
Path: src/agents/pi-embedded-runner/google.ts
Line: 236-244

Comment:
**Equality check omits the `cost` sub-object**

The fast-path equality check compares the five numeric fields but never checks whether the `cost` sub-object is present. `AssistantUsageSnapshot` requires `cost: { input, output, cacheRead, cacheWrite, total }` (see `usage.ts` `makeZeroUsageSnapshot`). A message that arrives with all five numeric fields already correct but with `cost` absent (or `undefined`) will satisfy every condition here and be skipped without normalization — leaving `cost` absent downstream.

If any consumer later does `usage.cost.total` (or similar) on such a message it will crash with the same class of `TypeError` this PR is fixing for `totalTokens`.

Consider adding a `cost` presence guard to the skip condition:
```suggestion
    if (
      message.usage &&
      typeof message.usage === "object" &&
      typeof (message.usage as { cost?: unknown }).cost === "object" &&
      (message.usage as { input?: unknown }).input === normalizedUsage.input &&
      (message.usage as { output?: unknown }).output === normalizedUsage.output &&
      (message.usage as { cacheRead?: unknown }).cacheRead === normalizedUsage.cacheRead &&
      (message.usage as { cacheWrite?: unknown }).cacheWrite === normalizedUsage.cacheWrite &&
      (message.usage as { totalTokens?: unknown }).totalTokens === normalizedUsage.totalTokens
    ) {
```

How can I resolve this? If you propose a fix, please make it concise.

Normalization silently zeroes the cost sub-object

When a message has a partial-but-non-empty usage (e.g. { output: 3, cache_read_input_tokens: 9 }), the function calls normalizeUsage to recover the numeric fields and then spreads makeZeroUsageSnapshot() as the base. Because makeZeroUsageSnapshot() always sets cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, any real cost information that was already present on the usage object is silently discarded.

For the missing-usage crash-fix path this is harmless (there was no cost to preserve). For the partial-usage normalization path it could mask genuine cost data from providers that do supply cost but omit totalTokens. If preserving cost is important, consider extracting it before building the normalized snapshot:

function normalizeAssistantUsageSnapshot(usage: unknown) {
  const normalized = normalizeUsage((usage ?? undefined) as UsageLike | undefined);
  if (!normalized) {
    return makeZeroUsageSnapshot();
  }
  const input = normalized.input ?? 0;
  const output = normalized.output ?? 0;
  const cacheRead = normalized.cacheRead ?? 0;
  const cacheWrite = normalized.cacheWrite ?? 0;
  const totalTokens = normalized.total ?? input + output + cacheRead + cacheWrite;
  const base = makeZeroUsageSnapshot();
  // Preserve existing cost if already present and well-formed
  const existingCost =
    usage && typeof usage === "object" && typeof (usage as { cost?: unknown }).cost === "object"
      ? (usage as { cost: typeof base.cost }).cost
      : base.cost;
  return { ...base, cost: existingCost, input, output, cacheRead, cacheWrite, totalTokens };
}

This is a comment left during a code review.
Path: src/agents/pi-embedded-runner/google.ts
Line: 203-221

Comment:
**Normalization silently zeroes the `cost` sub-object**

When a message has a partial-but-non-empty usage (e.g. `{ output: 3, cache_read_input_tokens: 9 }`), the function calls `normalizeUsage` to recover the numeric fields and then spreads `makeZeroUsageSnapshot()` as the base. Because `makeZeroUsageSnapshot()` always sets `cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }`, any real cost information that was already present on the usage object is silently discarded.

For the missing-usage crash-fix path this is harmless (there was no cost to preserve). For the partial-usage normalization path it could mask genuine cost data from providers that do supply cost but omit `totalTokens`. If preserving cost is important, consider extracting it before building the normalized snapshot:

```ts
function normalizeAssistantUsageSnapshot(usage: unknown) {
  const normalized = normalizeUsage((usage ?? undefined) as UsageLike | undefined);
  if (!normalized) {
    return makeZeroUsageSnapshot();
  }
  const input = normalized.input ?? 0;
  const output = normalized.output ?? 0;
  const cacheRead = normalized.cacheRead ?? 0;
  const cacheWrite = normalized.cacheWrite ?? 0;
  const totalTokens = normalized.total ?? input + output + cacheRead + cacheWrite;
  const base = makeZeroUsageSnapshot();
  // Preserve existing cost if already present and well-formed
  const existingCost =
    usage && typeof usage === "object" && typeof (usage as { cost?: unknown }).cost === "object"
      ? (usage as { cost: typeof base.cost }).cost
      : base.cost;
  return { ...base, cost: existingCost, input, output, cacheRead, cacheWrite, totalTokens };
}
```

How can I resolve this? If you propose a fix, please make it concise.

Preserve usage cost when normalizing assistant snapshots

When a message needs normalization (for example legacy usage with prompt_tokens/completion_tokens, or missing zero-valued cache fields), this rebuilds the snapshot from makeZeroUsageSnapshot() and overwrites any existing usage.cost with zeros. Because sanitizeSessionHistory output is fed back into session state before runs, historical cost data can be silently lost and downstream reports that sum msg.usage.cost will under-report spend for affected sessions.

Useful? React with 👍 / 👎.

Preserve unknown cost when normalizing assistant usage

When an assistant message has token counts but no usage.cost (common in legacy/provider-limited transcripts), this path returns a zeroed cost object and ensureAssistantUsageSnapshots persists it back into session history. That changes semantics from “cost unknown” to “cost is exactly zero,” so downstream aggregation in src/infra/session-cost-usage.ts (which treats finite cost.total as authoritative) will stop counting these turns as missing-cost entries and under-report spend after compaction. Keep cost undefined when the source usage has no cost block instead of synthesizing zeros.

Useful? React with 👍 / 👎.

Preserve cost when usage has no token counters

If an assistant message carries a valid usage.cost block but no token fields, normalizeAssistantUsageSnapshot returns makeZeroUsageSnapshot() immediately and never calls normalizeAssistantUsageCost, so non-zero historical cost is overwritten with zeros during sanitization. This regresses billing/report accuracy for legacy/provider-limited transcripts that only persisted cost metadata. Fresh evidence in this commit: the new early return at normalizeAssistantUsageSnapshot bypasses all cost-preservation logic when normalizeUsage(...) is falsy.

Useful? React with 👍 / 👎.

Preserve cost-only snapshots during usage normalization

If an assistant message carries only usage.cost (with no token counters), normalizeUsage(...) returns undefined and this branch replaces the message with makeZeroUsageSnapshot(), wiping the original non-zero cost in ensureAssistantUsageSnapshots. Since sanitizeSessionHistory feeds this normalized transcript back into the active session, downstream reporting (for example extractCostBreakdown in src/infra/session-cost-usage.ts) will read cost.total = 0 instead of the recorded value and under-report spend for legacy/provider-limited turns.

Useful? React with 👍 / 👎.

Preserve cost-only assistant snapshots during normalization

If an assistant message carries usage.cost but no token counters (common in legacy/provider-limited transcripts), normalizeUsage(...) returns undefined and this branch replaces the message with makeZeroUsageSnapshot(), which sets cost.total to 0. ensureAssistantUsageSnapshots then persists that normalized value back into session history, so downstream cost aggregation reads an authoritative zero instead of the recorded spend and under-reports usage costs for those turns.

Useful? React with 👍 / 👎.